feat: sync rules across all harnesses + agents to opencode/kilo

Add Rule as a first-class canonical kind (rules/<name>.md, loaded like
agents) and propagate it the way each harness actually loads it:

- claude-code: native ~/.claude/rules directory symlink (preserves rule
  path-scoping frontmatter); rules NOT folded into CLAUDE.md.
- opencode/kilo/zed/crush: fold rule bodies into the global AGENTS.md
  always-on instructions file (frontmatter stripped). crush has no global
  instructions file, so register the absolute AGENTS.md path in
  options.context_paths (defaults are re-prepended at load, so nothing is
  clobbered).
- goose: fold into ~/.config/goose/.goosehints.
- cagent: fold into the per-agent instruction.

Also:
- Wire markdown agents to opencode (~/.config/opencode/agents) and fix the
  kilo agents symlink: plural ~/.config/kilo/agents (singular "agent" is a
  silent no-op on current Kilo CLI).
- Add ManagesAgents/ManagesRules to HarnessCapabilities + ImportResult.Rules;
  claude-code/opencode import rules/agents round-trip.
- Centralize instruction selection in Bundle.InstructionText /
  InstructionTextWithRules (replaces per-adapter override duplication).
- init scaffolds + imports rules; README capability matrix gains
  Agents/Rules columns with native-vs-folded footnotes.

Grounded each harness's sink against official docs + config source this
session. Gate: gofmt, go vet, go test -race ./..., golangci-lint (0),
govulncheck (clean).

internal/adapters/cagent/cagent.go

@@ -41,6 +41,7 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          true,
 		ManagesSkills:       false,
+		ManagesRules:        true,
 		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
@@ -57,10 +58,9 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	cfgPath := filepath.Join(a.Home, ".config", "cagent", "default.yaml")
 
-	instructions := b.Instructions.Global
-	if override, ok := b.Instructions.PerHarness[name]; ok && override != "" {
-		instructions = override
-	}
+	// cagent has no rules concept; the per-agent instruction (system prompt) is
+	// the only sink, so fold rules into it.
+	instructions := b.InstructionTextWithRules(name)
 
 	mcps := map[string]any{}
 	for _, s := range b.MCP.Servers {

internal/adapters/cagent/rules_test.go

@@ -0,0 +1,37 @@
+package cagent
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+
+	"gopkg.in/yaml.v3"
+)
+
+func TestCagentFoldsRulesIntoInstruction(t *testing.T) {
+	home := t.TempDir()
+	b := &canonical.Bundle{
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "rust", Body: "# Rust\n\nno unwrap"}},
+	}
+	fs, err := New(WithHome(home)).Render(b)
+	require.NoError(t, err)
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	cfg := seen[filepath.Join(home, ".config", "cagent", "default.yaml")]
+	require.Equal(t, adapter.RenderedFile, cfg.Kind)
+
+	var parsed map[string]any
+	require.NoError(t, yaml.Unmarshal(cfg.Content, &parsed))
+	agents := parsed["agents"].(map[string]any)
+	def := agents["default"].(map[string]any)
+	instr := def["instruction"].(string)
+	assert.Contains(t, instr, "# global")
+	assert.Contains(t, instr, "no unwrap")
+}

internal/adapters/claudecode/claudecode.go

@@ -37,6 +37,8 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       false,
 		ManagesMCP:          true,
 		ManagesSkills:       true,
+		ManagesAgents:       true,
+		ManagesRules:        true,
 		ManagesInstructions: true,
 		HasBuiltInSub:       true,
 	}
@@ -65,15 +67,19 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Kind:          adapter.SymlinkDir,
 		SymlinkTarget: filepath.Join(b.Root, "agents"),
 	})
+	// Claude Code natively auto-loads ~/.claude/rules/*.md (memory feature), so
+	// rules are delivered as their own directory symlink — NOT folded into
+	// CLAUDE.md — preserving each rule's optional path-scoping frontmatter.
+	fs.Add(adapter.File{
+		Dest:          filepath.Join(base, "rules"),
+		Kind:          adapter.SymlinkDir,
+		SymlinkTarget: filepath.Join(b.Root, "rules"),
+	})
 
-	instructions := b.Instructions.Global
-	if override, ok := b.Instructions.PerHarness[name]; ok && override != "" {
-		instructions = override
-	}
 	fs.Add(adapter.File{
 		Dest:    filepath.Join(base, "CLAUDE.md"),
 		Kind:    adapter.RenderedFile,
-		Content: []byte(instructions),
+		Content: []byte(b.InstructionText(name)),
 	})
 
 	// Claude Code reads MCP servers from two files on disk:

internal/adapters/claudecode/import.go

@@ -32,6 +32,16 @@ func importFrom(home string) (*adapter.ImportResult, error) {
 		})
 	}
 
+	rules, err := common.ImportMarkdownTree(filepath.Join(base, "rules"), "")
+	if err != nil {
+		return nil, err
+	}
+	for _, r := range rules {
+		res.Rules = append(res.Rules, canonical.Rule{
+			Name: r.Name, Description: r.Description, Body: r.Body, Path: r.Path,
+		})
+	}
+
 	body, err := common.ReadIfExists(filepath.Join(base, "CLAUDE.md"))
 	if err != nil {
 		return nil, err

internal/adapters/claudecode/rules_test.go

@@ -0,0 +1,47 @@
+package claudecode
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func TestClaudeCodeRendersRulesSymlink(t *testing.T) {
+	home := t.TempDir()
+	ad := New(WithHome(home))
+	b := &canonical.Bundle{Root: "/canon"}
+	fs, err := ad.Render(b)
+	require.NoError(t, err)
+
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	rulesDest := filepath.Join(home, ".claude", "rules")
+	assert.Equal(t, adapter.SymlinkDir, seen[rulesDest].Kind)
+	assert.Equal(t, "/canon/rules", seen[rulesDest].SymlinkTarget)
+
+	// Rules are delivered natively as a directory — never folded into CLAUDE.md.
+	claudemd := string(seen[filepath.Join(home, ".claude", "CLAUDE.md")].Content)
+	assert.NotContains(t, claudemd, "/canon/rules")
+}
+
+func TestClaudeCodeImportsRules(t *testing.T) {
+	home := t.TempDir()
+	rulesDir := filepath.Join(home, ".claude", "rules")
+	require.NoError(t, os.MkdirAll(rulesDir, 0o750))
+	require.NoError(t, os.WriteFile(filepath.Join(rulesDir, "go.md"),
+		[]byte("# Go Rules\n\ngofmt always"), 0o600))
+
+	ad := New(WithHome(home))
+	res, err := ad.Import(home)
+	require.NoError(t, err)
+	require.Len(t, res.Rules, 1)
+	assert.Equal(t, "go", res.Rules[0].Name)
+	assert.Contains(t, res.Rules[0].Body, "gofmt always")
+}

internal/adapters/crush/crush.go

@@ -2,6 +2,7 @@
 package crush
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -36,7 +37,8 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          true,
 		ManagesSkills:       true,
-		ManagesInstructions: false,
+		ManagesRules:        true,
+		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
 }
@@ -60,12 +62,25 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		SymlinkTarget: filepath.Join(b.Root, "skills"),
 	})
 
+	// crush has no global instructions file and no rules directory: it loads
+	// context from the files listed in options.context_paths (defaults are always
+	// prepended; absolute paths load verbatim; the global config applies to every
+	// project). Write a global AGENTS.md with rules folded in, and register its
+	// absolute path so crush loads it in every session.
+	agentsMD := filepath.Join(base, "AGENTS.md")
+	fs.Add(adapter.File{
+		Dest:    agentsMD,
+		Kind:    adapter.RenderedFile,
+		Content: []byte(b.InstructionTextWithRules(name)),
+	})
+
 	cfgPath := filepath.Join(base, "crush.json")
 	existing, err := common.ReadExistingFile(cfgPath)
 	if err != nil {
 		return nil, fmt.Errorf("read %s: %w", cfgPath, err)
 	}
 	overlay := map[string]any{}
+	overlay["options"] = crushOptionsWithContextPath(existing, agentsMD)
 	if providers := common.ProvidersAsCrushMap(&b.Profile); len(providers) > 0 {
 		overlay["providers"] = providers
 	}
@@ -89,6 +104,34 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	return fs, nil
 }
 
+// crushOptionsWithContextPath returns the crush "options" object with contextFile
+// added to options.context_paths, preserving every other existing option key
+// (lsp, permissions, …). crush always prepends its built-in default context
+// paths at load time, so only the extra path is set here. Idempotent.
+func crushOptionsWithContextPath(existing []byte, contextFile string) map[string]any {
+	opts := map[string]any{}
+	if len(existing) > 0 {
+		var raw map[string]any
+		clean := common.StripJSONComments(string(existing))
+		if json.Unmarshal([]byte(clean), &raw) == nil {
+			if o, ok := raw["options"].(map[string]any); ok {
+				opts = o
+			}
+		}
+	}
+	var paths []any
+	if existingPaths, ok := opts["context_paths"].([]any); ok {
+		paths = existingPaths
+	}
+	for _, p := range paths {
+		if s, ok := p.(string); ok && s == contextFile {
+			return opts // already registered
+		}
+	}
+	opts["context_paths"] = append(paths, contextFile)
+	return opts
+}
+
 // Import reads crush config from home and returns a canonical ImportResult.
 func (a *Adapter) Import(home string) (*adapter.ImportResult, error) {
 	return importFrom(home)

internal/adapters/crush/rules_test.go

@@ -0,0 +1,83 @@
+package crush
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func renderCrush(t *testing.T, home string, b *canonical.Bundle) map[string]adapter.File {
+	t.Helper()
+	fs, err := New(WithHome(home)).Render(b)
+	require.NoError(t, err)
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+	return seen
+}
+
+func TestCrushWritesAGENTSAndRegistersContextPath(t *testing.T) {
+	home := t.TempDir()
+	b := &canonical.Bundle{
+		Root:         "/canon",
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "sec", Body: "# Security\n\nno secrets in code"}},
+	}
+	seen := renderCrush(t, home, b)
+
+	base := filepath.Join(home, ".config", "crush")
+	agentsMD := filepath.Join(base, "AGENTS.md")
+	assert.Equal(t, adapter.RenderedFile, seen[agentsMD].Kind)
+	body := string(seen[agentsMD].Content)
+	assert.Contains(t, body, "# global")
+	assert.Contains(t, body, "no secrets in code")
+
+	var cfg map[string]any
+	require.NoError(t, json.Unmarshal(seen[filepath.Join(base, "crush.json")].Content, &cfg))
+	opts := cfg["options"].(map[string]any)
+	paths := opts["context_paths"].([]any)
+	assert.Contains(t, paths, agentsMD, "absolute AGENTS.md path must be registered for global load")
+}
+
+func TestCrushPreservesExistingOptionsAndIsIdempotent(t *testing.T) {
+	home := t.TempDir()
+	base := filepath.Join(home, ".config", "crush")
+	require.NoError(t, os.MkdirAll(base, 0o750))
+	agentsMD := filepath.Join(base, "AGENTS.md")
+
+	// Existing crush.json with other options keys and a pre-existing context path
+	// (including our own — second apply must not duplicate it).
+	existing := map[string]any{
+		"options": map[string]any{
+			"context_paths": []any{"PROJECT.md", agentsMD},
+			"lsp":           map[string]any{"go": true},
+		},
+	}
+	body, _ := json.Marshal(existing)
+	require.NoError(t, os.WriteFile(filepath.Join(base, "crush.json"), body, 0o600))
+
+	seen := renderCrush(t, home, &canonical.Bundle{Root: "/canon"})
+
+	var cfg map[string]any
+	require.NoError(t, json.Unmarshal(seen[filepath.Join(base, "crush.json")].Content, &cfg))
+	opts := cfg["options"].(map[string]any)
+
+	// Other option keys survive.
+	assert.Contains(t, opts, "lsp")
+	// Pre-existing user path survives; ours is present exactly once (idempotent).
+	paths := opts["context_paths"].([]any)
+	count := 0
+	for _, p := range paths {
+		if p == agentsMD {
+			count++
+		}
+	}
+	assert.Equal(t, 1, count, "our context path must not be duplicated on re-apply")
+	assert.Contains(t, paths, "PROJECT.md")
+}

internal/adapters/goose/goose.go

@@ -45,7 +45,8 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          true,
 		ManagesSkills:       true,
-		ManagesInstructions: false,
+		ManagesRules:        true,
+		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
 }
@@ -113,6 +114,16 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Content: merged,
 	})
 
+	// goose has no native rules directory; ~/.config/goose/.goosehints is the
+	// global hints file applied to every session, so fold rules into it.
+	if hints := b.InstructionTextWithRules(name); hints != "" {
+		fs.Add(adapter.File{
+			Dest:    filepath.Join(a.Home, ".config", "goose", ".goosehints"),
+			Kind:    adapter.RenderedFile,
+			Content: []byte(hints),
+		})
+	}
+
 	return fs, nil
 }
 

internal/adapters/goose/rules_test.go

@@ -0,0 +1,31 @@
+package goose
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func TestGooseFoldsRulesIntoGoosehints(t *testing.T) {
+	home := t.TempDir()
+	b := &canonical.Bundle{
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "k8s", Body: "# Kube\n\nlabel everything"}},
+	}
+	fs, err := New(WithHome(home)).Render(b)
+	require.NoError(t, err)
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	hints := filepath.Join(home, ".config", "goose", ".goosehints")
+	require.Contains(t, seen, hints)
+	assert.Equal(t, adapter.RenderedFile, seen[hints].Kind)
+	body := string(seen[hints].Content)
+	assert.Contains(t, body, "# global")
+	assert.Contains(t, body, "label everything")
+}

internal/adapters/kilo/kilo.go

@@ -38,7 +38,9 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          true,
 		ManagesSkills:       true,
-		ManagesInstructions: false,
+		ManagesAgents:       true,
+		ManagesRules:        true,
+		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
 }
@@ -58,8 +60,11 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	base := filepath.Join(a.Home, ".config", "kilo")
 
+	// Kilo CLI reads global markdown subagents from ~/.config/kilo/agents/<name>.md
+	// (PLURAL — the singular "agent/" used by older OpenCode-fork builds is a
+	// silent no-op on current Kilo).
 	fs.Add(adapter.File{
-		Dest:          filepath.Join(base, "agent"),
+		Dest:          filepath.Join(base, "agents"),
 		Kind:          adapter.SymlinkDir,
 		SymlinkTarget: filepath.Join(b.Root, "agents"),
 	})
@@ -69,6 +74,13 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Kind:          adapter.SymlinkDir,
 		SymlinkTarget: filepath.Join(b.Root, "skills"),
 	})
+	// kilo has no global rules directory; ~/.config/kilo/AGENTS.md is the
+	// always-on global instructions file, so fold rules into it.
+	fs.Add(adapter.File{
+		Dest:    filepath.Join(base, "AGENTS.md"),
+		Kind:    adapter.RenderedFile,
+		Content: []byte(b.InstructionTextWithRules(name)),
+	})
 
 	cfgPath := filepath.Join(base, "kilo.json")
 	existing, err := common.ReadExistingFile(cfgPath)

internal/adapters/kilo/kilo_test.go

@@ -33,7 +33,8 @@ func TestKiloRender(t *testing.T) {
 	seen := map[string]adapter.File{}
 	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
 
-	agentDest := filepath.Join(home, ".config", "kilo", "agent")
+	// Global markdown subagents dir is PLURAL "agents" on current Kilo CLI.
+	agentDest := filepath.Join(home, ".config", "kilo", "agents")
 	assert.Equal(t, adapter.SymlinkDir, seen[agentDest].Kind)
 	assert.Equal(t, "/canon/agents", seen[agentDest].SymlinkTarget)
 

internal/adapters/kilo/rules_test.go

@@ -0,0 +1,32 @@
+package kilo
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func TestKiloFoldsRulesIntoAGENTS(t *testing.T) {
+	home := t.TempDir()
+	b := &canonical.Bundle{
+		Root:         "/canon",
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "py", Body: "# Py\n\ntype hints"}},
+	}
+	fs, err := New(WithHome(home)).Render(b)
+	require.NoError(t, err)
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	agentsMD := filepath.Join(home, ".config", "kilo", "AGENTS.md")
+	require.Contains(t, seen, agentsMD)
+	assert.Equal(t, adapter.RenderedFile, seen[agentsMD].Kind)
+	body := string(seen[agentsMD].Content)
+	assert.Contains(t, body, "# global")
+	assert.Contains(t, body, "type hints")
+}

internal/adapters/opencode/import.go

@@ -5,12 +5,23 @@ import (
 
 	"github.com/lukaszraczylo/harness-sync/internal/adapter"
 	"github.com/lukaszraczylo/harness-sync/internal/adapter/common"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
 )
 
 func importFrom(home string) (*adapter.ImportResult, error) {
 	base := filepath.Join(home, ".config", "opencode")
 	res := &adapter.ImportResult{}
 
+	agents, err := common.ImportMarkdownTree(filepath.Join(base, "agents"), "")
+	if err != nil {
+		return nil, err
+	}
+	for _, a := range agents {
+		res.Agents = append(res.Agents, canonical.Agent{
+			Name: a.Name, Description: a.Description, Body: a.Body, Path: a.Path,
+		})
+	}
+
 	cfgBody, err := common.ReadIfExists(filepath.Join(base, "opencode.jsonc"))
 	if err != nil {
 		return nil, err

internal/adapters/opencode/opencode.go

@@ -37,6 +37,8 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          true,
 		ManagesSkills:       true,
+		ManagesAgents:       true,
+		ManagesRules:        true,
 		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
@@ -62,6 +64,12 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Kind:          adapter.SymlinkDir,
 		SymlinkTarget: filepath.Join(b.Root, "skills"),
 	})
+	// opencode reads markdown subagents from ~/.config/opencode/agents/<name>.md
+	fs.Add(adapter.File{
+		Dest:          filepath.Join(base, "agents"),
+		Kind:          adapter.SymlinkDir,
+		SymlinkTarget: filepath.Join(b.Root, "agents"),
+	})
 
 	cfgPath := filepath.Join(base, "opencode.jsonc")
 	existing, err := common.ReadExistingFile(cfgPath)
@@ -104,14 +112,12 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Content: merged,
 	})
 
-	instructions := b.Instructions.Global
-	if override, ok := b.Instructions.PerHarness[name]; ok && override != "" {
-		instructions = override
-	}
+	// opencode has no native rules directory; rule content reaches it only via
+	// the global AGENTS.md instructions file, so fold the rules in here.
 	fs.Add(adapter.File{
 		Dest:    filepath.Join(base, "AGENTS.md"),
 		Kind:    adapter.RenderedFile,
-		Content: []byte(instructions),
+		Content: []byte(b.InstructionTextWithRules(name)),
 	})
 
 	return fs, nil

internal/adapters/opencode/rules_test.go

@@ -0,0 +1,52 @@
+package opencode
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func TestOpencodeRendersAgentsSymlinkAndFoldsRules(t *testing.T) {
+	home := t.TempDir()
+	ad := New(WithHome(home))
+	b := &canonical.Bundle{
+		Root:         "/canon",
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "go", Body: "# Go\n\ngofmt always"}},
+	}
+	fs, err := ad.Render(b)
+	require.NoError(t, err)
+
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	agentsDest := filepath.Join(home, ".config", "opencode", "agents")
+	assert.Equal(t, adapter.SymlinkDir, seen[agentsDest].Kind)
+	assert.Equal(t, "/canon/agents", seen[agentsDest].SymlinkTarget)
+
+	agentsMD := filepath.Join(home, ".config", "opencode", "AGENTS.md")
+	assert.Equal(t, adapter.RenderedFile, seen[agentsMD].Kind)
+	body := string(seen[agentsMD].Content)
+	assert.Contains(t, body, "# global")
+	assert.Contains(t, body, "gofmt always")
+}
+
+func TestOpencodeImportsAgents(t *testing.T) {
+	home := t.TempDir()
+	agentsDir := filepath.Join(home, ".config", "opencode", "agents")
+	require.NoError(t, os.MkdirAll(agentsDir, 0o750))
+	require.NoError(t, os.WriteFile(filepath.Join(agentsDir, "review.md"),
+		[]byte("---\nname: review\ndescription: d\n---\nbody"), 0o600))
+
+	ad := New(WithHome(home))
+	res, err := ad.Import(home)
+	require.NoError(t, err)
+	require.Len(t, res.Agents, 1)
+	assert.Equal(t, "review", res.Agents[0].Name)
+}

internal/adapters/zed/rules_test.go

@@ -0,0 +1,31 @@
+package zed
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/lukaszraczylo/harness-sync/internal/adapter"
+	"github.com/lukaszraczylo/harness-sync/internal/canonical"
+)
+
+func TestZedFoldsRulesIntoAGENTS(t *testing.T) {
+	home := t.TempDir()
+	b := &canonical.Bundle{
+		Instructions: canonical.Instructions{Global: "# global"},
+		Rules:        []canonical.Rule{{Name: "ts", Body: "# TS\n\nstrict mode"}},
+	}
+	fs, err := New(WithHome(home)).Render(b)
+	require.NoError(t, err)
+	seen := map[string]adapter.File{}
+	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
+
+	agentsMD := filepath.Join(home, ".config", "zed", "AGENTS.md")
+	require.Contains(t, seen, agentsMD)
+	assert.Equal(t, adapter.RenderedFile, seen[agentsMD].Kind)
+	body := string(seen[agentsMD].Content)
+	assert.Contains(t, body, "# global")
+	assert.Contains(t, body, "strict mode")
+}

internal/adapters/zed/zed.go

@@ -42,7 +42,8 @@ func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
 		ManagesModels:       true,
 		ManagesMCP:          false, // Agent panel uses Extensions; context_servers key causes serde parse errors
 		ManagesSkills:       false,
-		ManagesInstructions: false,
+		ManagesRules:        true,
+		ManagesInstructions: true,
 		HasBuiltInSub:       false,
 	}
 }
@@ -97,6 +98,17 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		NoMerge: true,
 	})
 
+	// Zed reads personal/global instructions from ~/.config/zed/AGENTS.md
+	// (always-on for the Agent across all projects). Zed has no rules directory,
+	// so fold rules into it.
+	if instr := b.InstructionTextWithRules(name); instr != "" {
+		fs.Add(adapter.File{
+			Dest:    filepath.Join(a.Home, ".config", "zed", "AGENTS.md"),
+			Kind:    adapter.RenderedFile,
+			Content: []byte(instr),
+		})
+	}
+
 	return fs, nil
 }