feat(daemon): add opencode as supported agent provider (#341)

* feat(daemon): add opencode as supported agent provider

Add opencode backend alongside claude and codex. The backend spawns
`opencode run --format json`, parses streaming JSON events (text,
tool_use, error, step_start/finish), and supports --prompt for system
prompts. Includes CLI detection, AGENTS.md runtime config, native skill
discovery via .config/opencode/skills/, and 21 tests covering handlers,
JSON parsing, and integration-level processEvents scenarios.

* chore: add .tool-versions to gitignore

server/internal/daemon/config.go

@@ -11,15 +11,15 @@ import (
 )
 
 const (
-	DefaultServerURL            = "ws://localhost:8080/ws"
-	DefaultPollInterval         = 3 * time.Second
-	DefaultHeartbeatInterval    = 15 * time.Second
-	DefaultAgentTimeout         = 2 * time.Hour
-	DefaultRuntimeName          = "Local Agent"
+	DefaultServerURL             = "ws://localhost:8080/ws"
+	DefaultPollInterval          = 3 * time.Second
+	DefaultHeartbeatInterval     = 15 * time.Second
+	DefaultAgentTimeout          = 2 * time.Hour
+	DefaultRuntimeName           = "Local Agent"
 	DefaultConfigReloadInterval  = 5 * time.Second
 	DefaultWorkspaceSyncInterval = 30 * time.Second
 	DefaultHealthPort            = 19514
-	DefaultMaxConcurrentTasks   = 20
+	DefaultMaxConcurrentTasks    = 20
 )
 
 // Config holds all daemon configuration.
@@ -30,7 +30,7 @@ type Config struct {
 	RuntimeName        string
 	CLIVersion         string                // multica CLI version (e.g. "0.1.13")
 	Profile            string                // profile name (empty = default)
-	Agents             map[string]AgentEntry // "claude" -> entry, "codex" -> entry
+	Agents             map[string]AgentEntry // "claude" -> entry, "codex" -> entry, "opencode" -> entry
 	WorkspacesRoot     string                // base path for execution envs (default: ~/multica_workspaces)
 	KeepEnvAfterTask   bool                  // preserve env after task for debugging
 	HealthPort         int                   // local HTTP port for health checks (default: 19514)
@@ -85,8 +85,15 @@ func LoadConfig(overrides Overrides) (Config, error) {
 			Model: strings.TrimSpace(os.Getenv("MULTICA_CODEX_MODEL")),
 		}
 	}
+	opencodePath := envOrDefault("MULTICA_OPENCODE_PATH", "opencode")
+	if _, err := exec.LookPath(opencodePath); err == nil {
+		agents["opencode"] = AgentEntry{
+			Path:  opencodePath,
+			Model: strings.TrimSpace(os.Getenv("MULTICA_OPENCODE_MODEL")),
+		}
+	}
 	if len(agents) == 0 {
-		return Config{}, fmt.Errorf("no agent CLI found: install claude or codex and ensure it is on PATH")
+		return Config{}, fmt.Errorf("no agent CLI found: install claude, codex, or opencode and ensure it is on PATH")
 	}
 
 	// Host info

server/internal/daemon/execenv/context.go

@@ -11,9 +11,10 @@ import (
 // writeContextFiles renders and writes .agent_context/issue_context.md and
 // skills into the appropriate provider-native location.
 //
-// Claude:  skills → {workDir}/.claude/skills/{name}/SKILL.md  (native discovery)
-// Codex:   skills → handled separately in Prepare via codex-home
-// Default: skills → {workDir}/.agent_context/skills/{name}/SKILL.md
+// Claude:   skills → {workDir}/.claude/skills/{name}/SKILL.md  (native discovery)
+// Codex:    skills → handled separately in Prepare via codex-home
+// OpenCode: skills → {workDir}/.config/opencode/skills/{name}/SKILL.md  (native discovery)
+// Default:  skills → {workDir}/.agent_context/skills/{name}/SKILL.md
 func writeContextFiles(workDir, provider string, ctx TaskContextForEnv) error {
 	contextDir := filepath.Join(workDir, ".agent_context")
 	if err := os.MkdirAll(contextDir, 0o755); err != nil {
@@ -50,6 +51,9 @@ func resolveSkillsDir(workDir, provider string) (string, error) {
 	case "claude":
 		// Claude Code natively discovers skills from .claude/skills/ in the workdir.
 		skillsDir = filepath.Join(workDir, ".claude", "skills")
+	case "opencode":
+		// OpenCode natively discovers skills from .config/opencode/skills/ in the workdir.
+		skillsDir = filepath.Join(workDir, ".config", "opencode", "skills")
 	default:
 		// Fallback: write to .agent_context/skills/ (referenced by meta config).
 		skillsDir = filepath.Join(workDir, ".agent_context", "skills")

server/internal/daemon/execenv/execenv_test.go

@@ -441,6 +441,148 @@ func TestInjectRuntimeConfigNoSkills(t *testing.T) {
 	}
 }
 
+func TestWriteContextFilesOpencodeNativeSkills(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+
+	ctx := TaskContextForEnv{
+		IssueID: "opencode-skill-test",
+		AgentSkills: []SkillContextForEnv{
+			{
+				Name:    "Go Conventions",
+				Content: "Follow Go conventions.",
+				Files: []SkillFileContextForEnv{
+					{Path: "templates/example.go", Content: "package main"},
+				},
+			},
+		},
+	}
+
+	if err := writeContextFiles(dir, "opencode", ctx); err != nil {
+		t.Fatalf("writeContextFiles failed: %v", err)
+	}
+
+	// Skills should be in .config/opencode/skills/ (native discovery).
+	skillMd, err := os.ReadFile(filepath.Join(dir, ".config", "opencode", "skills", "go-conventions", "SKILL.md"))
+	if err != nil {
+		t.Fatalf("failed to read .config/opencode/skills/go-conventions/SKILL.md: %v", err)
+	}
+	if !strings.Contains(string(skillMd), "Follow Go conventions.") {
+		t.Error("SKILL.md missing content")
+	}
+
+	// Supporting files should also be under .config/opencode/skills/.
+	supportFile, err := os.ReadFile(filepath.Join(dir, ".config", "opencode", "skills", "go-conventions", "templates", "example.go"))
+	if err != nil {
+		t.Fatalf("failed to read supporting file: %v", err)
+	}
+	if string(supportFile) != "package main" {
+		t.Errorf("supporting file content = %q, want %q", string(supportFile), "package main")
+	}
+
+	// .agent_context/skills/ should NOT exist for OpenCode.
+	if _, err := os.Stat(filepath.Join(dir, ".agent_context", "skills")); !os.IsNotExist(err) {
+		t.Error("expected .agent_context/skills/ to NOT exist for OpenCode provider")
+	}
+
+	// issue_context.md should still be in .agent_context/.
+	if _, err := os.Stat(filepath.Join(dir, ".agent_context", "issue_context.md")); os.IsNotExist(err) {
+		t.Error("expected .agent_context/issue_context.md to exist")
+	}
+}
+
+func TestInjectRuntimeConfigOpencode(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+
+	ctx := TaskContextForEnv{
+		IssueID:     "test-issue-id",
+		AgentSkills: []SkillContextForEnv{{Name: "Coding", Content: "Write good code."}},
+	}
+
+	if err := InjectRuntimeConfig(dir, "opencode", ctx); err != nil {
+		t.Fatalf("InjectRuntimeConfig failed: %v", err)
+	}
+
+	// OpenCode uses AGENTS.md (same as codex).
+	content, err := os.ReadFile(filepath.Join(dir, "AGENTS.md"))
+	if err != nil {
+		t.Fatalf("failed to read AGENTS.md: %v", err)
+	}
+
+	s := string(content)
+	if !strings.Contains(s, "Multica Agent Runtime") {
+		t.Error("AGENTS.md missing meta skill header")
+	}
+	if !strings.Contains(s, "Coding") {
+		t.Error("AGENTS.md missing skill name")
+	}
+	if !strings.Contains(s, "discovered automatically") {
+		t.Error("AGENTS.md missing native skill discovery hint")
+	}
+
+	// CLAUDE.md should NOT exist.
+	if _, err := os.Stat(filepath.Join(dir, "CLAUDE.md")); !os.IsNotExist(err) {
+		t.Error("expected CLAUDE.md to NOT exist for OpenCode provider")
+	}
+}
+
+func TestPrepareWithRepoContextOpencode(t *testing.T) {
+	t.Parallel()
+	workspacesRoot := t.TempDir()
+
+	taskCtx := TaskContextForEnv{
+		IssueID: "c3d4e5f6-a7b8-9012-cdef-123456789012",
+		Repos: []RepoContextForEnv{
+			{URL: "https://github.com/org/backend", Description: "Go backend"},
+		},
+	}
+	env, err := Prepare(PrepareParams{
+		WorkspacesRoot: workspacesRoot,
+		WorkspaceID:    "ws-test-oc",
+		TaskID:         "c3d4e5f6-a7b8-9012-cdef-123456789012",
+		AgentName:      "OpenCode Agent",
+		Provider:       "opencode",
+		Task:           taskCtx,
+	}, testLogger())
+	if err != nil {
+		t.Fatalf("Prepare failed: %v", err)
+	}
+	defer env.Cleanup(true)
+
+	if err := InjectRuntimeConfig(env.WorkDir, "opencode", taskCtx); err != nil {
+		t.Fatalf("InjectRuntimeConfig failed: %v", err)
+	}
+
+	// Workdir should only contain expected entries.
+	entries, err := os.ReadDir(env.WorkDir)
+	if err != nil {
+		t.Fatalf("failed to read workdir: %v", err)
+	}
+	for _, e := range entries {
+		name := e.Name()
+		if name != ".agent_context" && name != "AGENTS.md" {
+			t.Errorf("unexpected entry in workdir: %s", name)
+		}
+	}
+
+	// AGENTS.md should contain repo info.
+	content, err := os.ReadFile(filepath.Join(env.WorkDir, "AGENTS.md"))
+	if err != nil {
+		t.Fatalf("failed to read AGENTS.md: %v", err)
+	}
+	s := string(content)
+	for _, want := range []string{
+		"multica repo checkout",
+		"https://github.com/org/backend",
+		"Go backend",
+	} {
+		if !strings.Contains(s, want) {
+			t.Errorf("AGENTS.md missing %q", want)
+		}
+	}
+}
+
 func TestInjectRuntimeConfigUnknownProvider(t *testing.T) {
 	t.Parallel()
 	dir := t.TempDir()

server/internal/daemon/execenv/runtime_config.go

@@ -10,15 +10,16 @@ import (
 // InjectRuntimeConfig writes the meta skill content into the runtime-specific
 // config file so the agent discovers its environment through its native mechanism.
 //
-// For Claude: writes {workDir}/CLAUDE.md  (skills discovered natively from .claude/skills/)
-// For Codex:  writes {workDir}/AGENTS.md  (skills discovered natively via CODEX_HOME)
+// For Claude:   writes {workDir}/CLAUDE.md  (skills discovered natively from .claude/skills/)
+// For Codex:    writes {workDir}/AGENTS.md  (skills discovered natively via CODEX_HOME)
+// For OpenCode: writes {workDir}/AGENTS.md  (skills discovered natively from .config/opencode/skills/)
 func InjectRuntimeConfig(workDir, provider string, ctx TaskContextForEnv) error {
 	content := buildMetaSkillContent(provider, ctx)
 
 	switch provider {
 	case "claude":
 		return os.WriteFile(filepath.Join(workDir, "CLAUDE.md"), []byte(content), 0o644)
-	case "codex":
+	case "codex", "opencode":
 		return os.WriteFile(filepath.Join(workDir, "AGENTS.md"), []byte(content), 0o644)
 	default:
 		// Unknown provider — skip config injection, prompt-only mode.
@@ -114,8 +115,8 @@ func buildMetaSkillContent(provider string, ctx TaskContextForEnv) string {
 		case "claude":
 			// Claude discovers skills natively from .claude/skills/ — just list names.
 			b.WriteString("You have the following skills installed (discovered automatically):\n\n")
-		case "codex":
-			// Codex discovers skills natively via CODEX_HOME/skills/ — just list names.
+		case "codex", "opencode":
+			// Codex and OpenCode discover skills natively from their respective paths — just list names.
 			b.WriteString("You have the following skills installed (discovered automatically):\n\n")
 		default:
 			b.WriteString("Detailed skill instructions are in `.agent_context/skills/`. Each subdirectory contains a `SKILL.md`.\n\n")

server/internal/daemon/repocache/cache.go

@@ -29,7 +29,7 @@ type CachedRepo struct {
 
 // Cache manages bare git clones for workspace repositories.
 type Cache struct {
-	root   string       // base directory for all caches (e.g. ~/multica_workspaces/.repos)
+	root   string // base directory for all caches (e.g. ~/multica_workspaces/.repos)
 	logger *slog.Logger
 	mu     sync.Mutex
 }
@@ -195,7 +195,7 @@ func (c *Cache) CreateWorktree(params WorktreeParams) (*WorktreeResult, error) {
 	}
 
 	// Exclude agent context files from git tracking.
-	for _, pattern := range []string{".agent_context", "CLAUDE.md", "AGENTS.md", ".claude"} {
+	for _, pattern := range []string{".agent_context", "CLAUDE.md", "AGENTS.md", ".claude", ".config/opencode"} {
 		_ = excludeFromGit(worktreePath, pattern)
 	}