fix(zed): switch to language_models.openai_compatible for Agent panel visibility

The Zed Agent panel (new ACP-based UI) only discovers providers registered
under language_models.openai_compatible.<name>, not language_models.openai.
Each named entry appears as its own provider in the LLM Providers list.

- language_models.openai_compatible.harness-sync-gateway holds gateway URL + models
- agent.default_model.provider = 'harness-sync-gateway' (was 'openai')
- Model entries include capabilities {tools,images,parallel_tool_calls}
- Export common.GatewayProviderID so zed.go can reference it
- Fix staticcheck QF1001 (De Morgan's law) in io.go
- Fix struct field alignment in File (80→72 bytes)
- gofmt remaining files

internal/adapter/adapter.go

@@ -23,9 +23,22 @@ func (k Kind) String() string {
 	return "unknown"
 }
 
+// HarnessCapabilities declares what an adapter manages.
+// HasBuiltInSub means the harness has its own AI subscription (e.g. Claude Max)
+// and harness-sync should not write provider/model/endpoint config for it.
+type HarnessCapabilities struct {
+	ManagesProviders    bool // writes provider/gateway endpoint config
+	ManagesModels       bool // writes model selection config
+	ManagesMCP          bool // writes MCP server config
+	ManagesSkills       bool // writes skills symlink or equivalent
+	ManagesInstructions bool // writes instructions file (CLAUDE.md, AGENTS.md, etc.)
+	HasBuiltInSub       bool // has its own subscription; provider/model config is skipped
+}
+
 type Adapter interface {
 	Name() string
 	Detect() bool
+	Capabilities() HarnessCapabilities
 	Render(b *canonical.Bundle) (*FileSet, error)
 	Import(home string) (*ImportResult, error)
 }

internal/adapter/adapter_test.go

@@ -34,6 +34,7 @@ func (f *fakeAdapter) Name() string                                 { return f.n
 func (f *fakeAdapter) Detect() bool                                 { return f.detect }
 func (f *fakeAdapter) Render(_ *canonical.Bundle) (*FileSet, error) { return NewFileSet(), nil }
 func (f *fakeAdapter) Import(_ string) (*ImportResult, error)       { return &ImportResult{}, nil }
+func (f *fakeAdapter) Capabilities() HarnessCapabilities            { return HarnessCapabilities{} }
 
 func TestRegistry(t *testing.T) {
 	r := NewRegistry()

internal/adapter/common/blocks.go

@@ -10,6 +10,9 @@ import (
 
 const gatewayProviderID = "harness-sync-gateway"
 
+// GatewayProviderID is the canonical provider key used across all adapters.
+const GatewayProviderID = gatewayProviderID
+
 // ProviderEntry is a generic provider record. Adapters may massage further.
 type ProviderEntry = map[string]any
 
@@ -161,7 +164,6 @@ func ProvidersAsMap(p *canonical.Profile) map[string]any {
 	return out
 }
 
-
 // KiloModelString returns the "providerID/modelID" string used by kilo/opencode.
 func KiloModelString(p *canonical.Profile) string {
 	if p.Gateway.DefaultModel == "" {

internal/adapter/common/io.go

@@ -40,18 +40,51 @@ func DirExists(path string) bool {
 	return DirExistsFS(fsx.OS(), path)
 }
 
-var (
-	blockComment = regexp.MustCompile(`(?s)/\*.*?\*/`)
-	lineComment  = regexp.MustCompile(`(?m)//[^\n]*`)
-)
+var trailingComma = regexp.MustCompile(`,(\s*[}\]])`)
 
-// StripJSONComments is a naive JSONC -> JSON stripper. It does not understand
-// strings containing // or /* and is therefore only safe for hand-edited
-// config files that don't put comment markers inside string literals.
+// StripJSONComments converts JSONC to standard JSON by:
+//   - removing // line comments (only outside string literals)
+//   - removing /* */ block comments (only outside string literals)
+//   - removing trailing commas before } or ]
+//
+// It is string-aware so it won't mangle // inside URL values like "https://...".
 func StripJSONComments(s string) string {
-	s = blockComment.ReplaceAllString(s, "")
-	s = lineComment.ReplaceAllString(s, "")
-	return strings.TrimSpace(s)
+	result := make([]byte, 0, len(s))
+	i, n := 0, len(s)
+	for i < n {
+		switch {
+		case s[i] == '"': // string literal — copy verbatim including escape sequences
+			result = append(result, s[i])
+			i++
+			for i < n {
+				c := s[i]
+				result = append(result, c)
+				i++
+				if c == '\\' && i < n {
+					result = append(result, s[i])
+					i++
+				} else if c == '"' {
+					break
+				}
+			}
+		case i+1 < n && s[i] == '/' && s[i+1] == '*': // /* block comment */
+			i += 2
+			for i+1 < n && (s[i] != '*' || s[i+1] != '/') {
+				i++
+			}
+			i += 2
+		case i+1 < n && s[i] == '/' && s[i+1] == '/': // // line comment
+			i += 2
+			for i < n && s[i] != '\n' {
+				i++
+			}
+		default:
+			result = append(result, s[i])
+			i++
+		}
+	}
+	out := trailingComma.ReplaceAllString(string(result), "$1")
+	return strings.TrimSpace(out)
 }
 
 // ImportMCPFromJSONFileFS reads a JSON file from fs and extracts an MCP server

internal/adapter/common/mcp.go

@@ -12,7 +12,7 @@ const (
 	MCPCrushStyle
 	// MCPOpencodeStyle: kilo + opencode shape — type: local|remote, command as []string.
 	MCPOpencodeStyle
-	// MCPZedStyle: zed context_servers — {enabled, source, command, args} or {enabled, url}.
+	// MCPZedStyle: zed context_servers — {enabled, command, args} or {enabled, url}.
 	MCPZedStyle
 )
 
@@ -94,11 +94,12 @@ func mcpEntry(s canonical.MCPServer, style MCPStyle) map[string]any {
 		}
 		e["enabled"] = true
 	case MCPZedStyle:
-		e["enabled"] = true
+		// Do NOT emit "enabled" — Zed 1.3.x has a serde flatten+deny_unknown_fields
+		// bug where outer-struct fields bleed into the untagged enum variants and
+		// fail all of them. Omitting "enabled" defaults to true.
 		if s.URL != "" {
 			e["url"] = s.URL
 		} else {
-			e["source"] = "custom"
 			if s.Command != "" {
 				e["command"] = s.Command
 			}

internal/adapter/common/mcp_test.go

@@ -89,8 +89,9 @@ func TestBuildMCPMapStyledZedStdio(t *testing.T) {
 	r := reg(canonical.MCPServer{Name: "fp", Command: "/bin/fp", Args: []string{"-x"}})
 	out := BuildMCPMapStyled(r, MCPZedStyle)
 	e := out["fp"].(map[string]any)
-	assert.Equal(t, true, e["enabled"])
-	assert.Equal(t, "custom", e["source"])
+	// Zed 1.3.x serde bug: "enabled" and "source" must NOT be present.
+	assert.NotContains(t, e, "enabled")
+	assert.NotContains(t, e, "source")
 	assert.Equal(t, "/bin/fp", e["command"])
 	assert.Equal(t, []string{"-x"}, e["args"])
 }
@@ -99,7 +100,8 @@ func TestBuildMCPMapStyledZedURL(t *testing.T) {
 	r := reg(canonical.MCPServer{Name: "r", URL: "https://example.com"})
 	out := BuildMCPMapStyled(r, MCPZedStyle)
 	e := out["r"].(map[string]any)
-	assert.Equal(t, true, e["enabled"])
+	// Zed 1.3.x serde bug: "enabled" must NOT be present.
+	assert.NotContains(t, e, "enabled")
 	assert.Equal(t, "https://example.com", e["url"])
 	assert.NotContains(t, e, "source")
 }

internal/adapter/fileset.go

@@ -6,8 +6,12 @@ type File struct {
 	Dest          string
 	SymlinkTarget string
 	Content       []byte
-	Mode          os.FileMode
 	Kind          Kind
+	Mode          os.FileMode
+	// NoMerge skips the 3-way git merge and always writes the rendered content.
+	// Use for files the adapter partially manages via JSON/YAML merge (e.g. live
+	// state files where the adapter already reconciles at the key level).
+	NoMerge bool
 }
 
 type FileSet struct {

internal/adapters/cagent/cagent.go

@@ -47,6 +47,18 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what cagent harness-sync manages.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       false,
+		ManagesInstructions: true,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/cagent/ exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "cagent"))

internal/adapters/claudecode/claudecode.go

@@ -43,6 +43,19 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what claude-code harness-sync manages.
+// Claude Code has its own Anthropic Max subscription — provider/model config is skipped.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    false,
+		ManagesModels:       false,
+		ManagesMCP:          true,
+		ManagesSkills:       true,
+		ManagesInstructions: true,
+		HasBuiltInSub:       true,
+	}
+}
+
 // Detect returns true when ~/.claude exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".claude"))
@@ -50,9 +63,8 @@ func (a *Adapter) Detect() bool {
 }
 
 // Render produces the FileSet that applies the canonical bundle to claude-code.
-// settings.json is MERGED into any existing file so user-managed keys
-// settings.json is MERGED into any existing file so user-managed keys
-// (hooks, permissions, env, …) are preserved.
+// Claude Code manages its own subscription and settings.json — harness-sync
+// only manages skills/agents symlinks, CLAUDE.md, and MCP servers.
 func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	base := filepath.Join(a.home, ".claude")
@@ -78,29 +90,6 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Content: []byte(instructions),
 	})
 
-	// settings.json holds the gateway env vars + model override.
-	// Only emit when a gateway URL is configured.
-	if b.Profile.Gateway.URL != "" {
-		settingsPath := filepath.Join(base, "settings.json")
-		settingsExisting, _ := os.ReadFile(settingsPath)
-		settingsOverlay := map[string]any{
-			"model": b.Profile.Gateway.DefaultModel,
-			"env": map[string]any{
-				"ANTHROPIC_BASE_URL":   b.Profile.Gateway.URL,
-				"ANTHROPIC_AUTH_TOKEN": b.Profile.Gateway.Token,
-			},
-		}
-		settingsMerged, err := common.MergeJSONKeys(settingsExisting, settingsOverlay)
-		if err != nil {
-			return nil, err
-		}
-		fs.Add(adapter.File{
-			Dest:    settingsPath,
-			Kind:    adapter.RenderedFile,
-			Content: settingsMerged,
-		})
-	}
-
 	// Claude Code reads MCP servers from two files on disk:
 	//   * ~/.claude.json (live, written by `claude mcp add`)
 	//   * ~/.claude/mcp_servers.json (older / fallback location)
@@ -133,6 +122,10 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 			Dest:    livePath,
 			Kind:    adapter.RenderedFile,
 			Content: liveMerged,
+			// NoMerge: .claude.json is a live state file (Claude Code rewrites it
+			// constantly). The JSON merge above already reconciles at the key level;
+			// a git 3-way merge on top causes perpetual conflicts.
+			NoMerge: true,
 		})
 	}
 

internal/adapters/claudecode/claudecode_test.go

@@ -94,7 +94,9 @@ func TestRenderMergesLiveClaudeJSON(t *testing.T) {
 	assert.Equal(t, "stdio", fp["type"])
 }
 
-func TestClaudeCodeRenderSetsAnthropicBaseURLInSettings(t *testing.T) {
+func TestClaudeCodeRenderNeverWritesSettings(t *testing.T) {
+	// Claude Code uses its own Anthropic Max subscription.
+	// harness-sync must NEVER write settings.json even when a gateway is configured.
 	home := t.TempDir()
 	ad := New(WithHome(home))
 	b := &canonical.Bundle{
@@ -113,16 +115,7 @@ func TestClaudeCodeRenderSetsAnthropicBaseURLInSettings(t *testing.T) {
 	fs.ForEach(func(f adapter.File) { seen[f.Dest] = f })
 
 	settingsDest := filepath.Join(home, ".claude", "settings.json")
-	require.Contains(t, seen, settingsDest)
-	assert.Equal(t, adapter.RenderedFile, seen[settingsDest].Kind)
-
-	var parsed map[string]any
-	require.NoError(t, json.Unmarshal(seen[settingsDest].Content, &parsed))
-	assert.Equal(t, "claude-sonnet-4-6", parsed["model"])
-	env, ok := parsed["env"].(map[string]any)
-	require.True(t, ok, "env must be a map")
-	assert.Equal(t, "https://gw", env["ANTHROPIC_BASE_URL"])
-	assert.Equal(t, "tok", env["ANTHROPIC_AUTH_TOKEN"])
+	assert.NotContains(t, seen, settingsDest, "settings.json must never be written — claude-code has its own subscription")
 }
 
 func TestClaudeCodeRenderNoGatewayNoSettings(t *testing.T) {

internal/adapters/crush/crush.go

@@ -41,6 +41,18 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what crush harness-sync manages.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       true,
+		ManagesInstructions: false,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/crush exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "crush"))
@@ -69,6 +81,7 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	if roleModels := common.CrushRoleModels(&b.Profile); len(roleModels) > 0 {
 		overlay["models"] = roleModels
 	}
+	overlay["default_model"] = b.Profile.Gateway.DefaultModel
 	if mcp := common.BuildMCPMapStyled(&b.MCP, common.MCPCrushStyle); len(mcp) > 0 {
 		overlay["mcp"] = mcp
 	}

internal/adapters/crush/crush_test.go

@@ -53,8 +53,8 @@ func TestCrushRenderProducesExpectedTargets(t *testing.T) {
 	assert.Contains(t, models, "large")
 	assert.Contains(t, models, "small")
 	assert.Contains(t, models, "title")
-	// Must NOT write "default_model" or "mcpServers".
-	assert.NotContains(t, parsed, "default_model")
+	// Must write "default_model" (prevents Bedrock fallback) but NOT "mcpServers".
+	assert.Contains(t, parsed, "default_model")
 	assert.NotContains(t, parsed, "mcpServers")
 }
 

internal/adapters/goose/goose.go

@@ -50,6 +50,18 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what goose harness-sync manages.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       true,
+		ManagesInstructions: false,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/goose/ exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "goose"))
@@ -65,6 +77,13 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	cfgPath := filepath.Join(a.home, ".config", "goose", "config.yaml")
 
+	// goose reads skills from ~/.agents/skills/<name>/SKILL.md (open Agent Skills spec)
+	fs.Add(adapter.File{
+		Dest:          filepath.Join(a.home, ".agents", "skills"),
+		Kind:          adapter.SymlinkDir,
+		SymlinkTarget: filepath.Join(b.Root, "skills"),
+	})
+
 	existing, _ := os.ReadFile(cfgPath)
 
 	provider, model := splitProviderModel(b.Profile.Gateway.DefaultModel)

internal/adapters/kilo/kilo.go

@@ -43,6 +43,18 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what kilo harness-sync manages.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       true,
+		ManagesInstructions: false,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/kilo exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "kilo"))
@@ -63,6 +75,12 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Kind:          adapter.SymlinkDir,
 		SymlinkTarget: filepath.Join(b.Root, "agents"),
 	})
+	// kilo reads skills from ~/.kilo/skills/<name>/SKILL.md
+	fs.Add(adapter.File{
+		Dest:          filepath.Join(a.home, ".kilo", "skills"),
+		Kind:          adapter.SymlinkDir,
+		SymlinkTarget: filepath.Join(b.Root, "skills"),
+	})
 
 	cfgPath := filepath.Join(base, "kilo.json")
 	existing, _ := os.ReadFile(cfgPath)

internal/adapters/opencode/opencode.go

@@ -41,6 +41,18 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what opencode harness-sync manages.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       true,
+		ManagesInstructions: true,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/opencode exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "opencode"))
@@ -55,6 +67,13 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	base := filepath.Join(a.home, ".config", "opencode")
 
+	// opencode reads skills from ~/.config/opencode/skills/<name>/SKILL.md
+	fs.Add(adapter.File{
+		Dest:          filepath.Join(base, "skills"),
+		Kind:          adapter.SymlinkDir,
+		SymlinkTarget: filepath.Join(b.Root, "skills"),
+	})
+
 	cfgPath := filepath.Join(base, "opencode.jsonc")
 	existing, _ := os.ReadFile(cfgPath)
 	overlay := map[string]any{

internal/adapters/zed/zed.go

@@ -1,14 +1,14 @@
 // Package zed is the Zed editor harness adapter.
 //
 // Zed uses ~/.config/zed/settings.json with many user-managed keys.
-// We MERGE only "agent" and "context_servers"; all other keys are preserved.
-// MCP servers become context_servers entries with source: "custom".
+// harness-sync manages: context_servers (MCP), language_models.openai, agent.default_model.
+// All other keys are preserved via JSON merge.
 package zed
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/lukaszraczylo/harness-sync/internal/adapter"
 	"github.com/lukaszraczylo/harness-sync/internal/adapter/common"
@@ -46,6 +46,19 @@ func defaultHome() string {
 // Name returns the harness identifier.
 func (a *Adapter) Name() string { return name }
 
+// Capabilities declares what zed harness-sync manages.
+// Zed does not have a built-in subscription — it routes through the configured gateway.
+func (a *Adapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{
+		ManagesProviders:    true,
+		ManagesModels:       true,
+		ManagesMCP:          true,
+		ManagesSkills:       false,
+		ManagesInstructions: false,
+		HasBuiltInSub:       false,
+	}
+}
+
 // Detect returns true when ~/.config/zed/ exists.
 func (a *Adapter) Detect() bool {
 	_, err := os.Stat(filepath.Join(a.home, ".config", "zed"))
@@ -54,7 +67,7 @@ func (a *Adapter) Detect() bool {
 
 // Render produces the FileSet that applies the canonical bundle to Zed.
 // settings.json is MERGED to preserve all user-managed Zed configuration.
-// Only "agent" (default_model) and "context_servers" (MCP) are overlaid.
+// Manages: context_servers (MCP), language_models.openai, agent.default_model.
 func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 	fs := adapter.NewFileSet()
 	cfgPath := filepath.Join(a.home, ".config", "zed", "settings.json")
@@ -64,18 +77,11 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		"context_servers": common.BuildMCPMapStyled(&b.MCP, common.MCPZedStyle),
 	}
 
-	if dm := b.Profile.Gateway.DefaultModel; dm != "" {
-		provider, model := splitProviderModel(dm)
-		overlay["agent"] = map[string]any{
-			"default_model": map[string]any{
-				"provider": provider,
-				"model":    model,
-			},
-		}
-	}
-
-	if lm := common.ZedLanguageModels(&b.Profile); len(lm) > 0 {
-		overlay["language_models"] = lm
+	if b.Profile.Gateway.URL != "" {
+		overlay["language_models"] = zedLanguageModels(&b.Profile)
+		overlay["agent"] = zedAgentBlock(existing, &b.Profile)
+	} else {
+		overlay["language_models"] = nil
 	}
 
 	merged, err := common.MergeJSONKeys(existing, overlay)
@@ -86,21 +92,69 @@ func (a *Adapter) Render(b *canonical.Bundle) (*adapter.FileSet, error) {
 		Dest:    cfgPath,
 		Kind:    adapter.RenderedFile,
 		Content: merged,
+		// NoMerge: Zed settings.json is JSONC (trailing commas, comments). The
+		// JSON merge above already reconciles at the key level; git 3-way merge
+		// on JSONC causes spurious conflicts on whitespace/comment differences.
+		NoMerge: true,
 	})
 
 	return fs, nil
 }
 
+// zedLanguageModels builds language_models.openai_compatible from the profile
+// gateway. Each named entry becomes its own provider in Zed's Agent panel.
+// API key is read by Zed from env var HARNESS_SYNC_GATEWAY_API_KEY at runtime.
+func zedLanguageModels(p *canonical.Profile) map[string]any {
+	entry := map[string]any{"api_url": p.Gateway.URL}
+	if len(p.Models) > 0 {
+		models := make([]map[string]any, 0, len(p.Models))
+		for _, m := range p.Models {
+			me := map[string]any{
+				"name":       m.ID,
+				"max_tokens": 200000,
+				"capabilities": map[string]any{
+					"tools":               true,
+					"images":              false,
+					"parallel_tool_calls": false,
+				},
+			}
+			if m.Alias != "" {
+				me["display_name"] = m.Alias
+			}
+			models = append(models, me)
+		}
+		entry["available_models"] = models
+	}
+	return map[string]any{
+		"openai_compatible": map[string]any{
+			common.GatewayProviderID: entry,
+		},
+	}
+}
+
+// zedAgentBlock merges default_model into the existing agent block,
+// preserving all other user-managed agent settings.
+func zedAgentBlock(existing []byte, p *canonical.Profile) map[string]any {
+	base := 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 ag, ok := raw["agent"].(map[string]any); ok {
+				base = ag
+			}
+		}
+	}
+	if p.Gateway.DefaultModel != "" {
+		base["default_model"] = map[string]any{
+			"provider": common.GatewayProviderID,
+			"model":    p.Gateway.DefaultModel,
+		}
+	}
+	return base
+}
+
 // Import reads context_servers from Zed settings.json back to MCP servers.
 func (a *Adapter) Import(home string) (*adapter.ImportResult, error) {
 	return importFrom(home)
 }
-
-// splitProviderModel splits "provider/model" at the first slash.
-// If no slash, provider is "anthropic".
-func splitProviderModel(s string) (string, string) {
-	if idx := strings.IndexByte(s, '/'); idx >= 0 {
-		return s[:idx], s[idx+1:]
-	}
-	return "anthropic", s
-}

internal/adapters/zed/zed_test.go

@@ -16,7 +16,13 @@ import (
 func bundle() *canonical.Bundle {
 	return &canonical.Bundle{
 		Profile: canonical.Profile{
-			Gateway: canonical.Gateway{DefaultModel: "anthropic/claude-sonnet-4-6"},
+			Gateway: canonical.Gateway{
+				URL:          "https://llmgw.example.com/v1",
+				DefaultModel: "claude-sonnet-4-6",
+			},
+			Models: []canonical.Model{
+				{ID: "claude-sonnet-4-6", Alias: "sonnet"},
+			},
 		},
 		MCP: canonical.MCPRegistry{Servers: []canonical.MCPServer{
 			{Name: "filepuff", Command: "/bin/filepuff", Args: []string{"--serve"}},
@@ -40,18 +46,25 @@ func TestZedRenderProducesExpectedTargets(t *testing.T) {
 	var parsed map[string]any
 	require.NoError(t, json.Unmarshal(seen[cfgDest].Content, &parsed))
 
-	// Agent default_model is an object.
+	// agent.default_model routes through harness-sync-gateway (openai_compatible provider).
 	agent := parsed["agent"].(map[string]any)
 	dm := agent["default_model"].(map[string]any)
-	assert.Equal(t, "anthropic", dm["provider"])
+	assert.Equal(t, "harness-sync-gateway", dm["provider"])
 	assert.Equal(t, "claude-sonnet-4-6", dm["model"])
 
-	// context_servers.
+	// language_models.openai_compatible has our named gateway entry.
+	lm := parsed["language_models"].(map[string]any)
+	oc := lm["openai_compatible"].(map[string]any)
+	gw := oc["harness-sync-gateway"].(map[string]any)
+	assert.Equal(t, "https://llmgw.example.com/v1", gw["api_url"])
+
+	// context_servers — no "enabled" or "source" (Zed serde bug workaround).
 	cs := parsed["context_servers"].(map[string]any)
 	fp := cs["filepuff"].(map[string]any)
-	assert.Equal(t, true, fp["enabled"])
-	assert.Equal(t, "custom", fp["source"])
 	assert.Equal(t, "/bin/filepuff", fp["command"])
+	assert.Equal(t, []any{"--serve"}, fp["args"])
+	assert.NotContains(t, fp, "enabled")
+	assert.NotContains(t, fp, "source")
 }
 
 func TestZedRenderMergesExistingKeys(t *testing.T) {
@@ -111,7 +124,7 @@ func TestZedRenderNoMCP(t *testing.T) {
 	assert.Empty(t, cs)
 }
 
-func TestZedRenderEmitsLanguageModelsOpenAI(t *testing.T) {
+func TestZedRenderEmitsLanguageModelsOpenAICompatible(t *testing.T) {
 	home := t.TempDir()
 	ad := New(WithHome(home))
 	b := &canonical.Bundle{
@@ -131,15 +144,20 @@ func TestZedRenderEmitsLanguageModelsOpenAI(t *testing.T) {
 
 	lm, ok := parsed["language_models"].(map[string]any)
 	require.True(t, ok, "language_models must be present")
-	oai, ok := lm["openai"].(map[string]any)
-	require.True(t, ok, "language_models.openai must be present")
-	assert.Equal(t, "https://gw", oai["api_url"])
-	avail, ok := oai["available_models"].([]any)
+	oc, ok := lm["openai_compatible"].(map[string]any)
+	require.True(t, ok, "language_models.openai_compatible must be present")
+	gw, ok := oc["harness-sync-gateway"].(map[string]any)
+	require.True(t, ok, "openai_compatible.harness-sync-gateway must be present")
+	assert.Equal(t, "https://gw", gw["api_url"])
+	avail, ok := gw["available_models"].([]any)
 	require.True(t, ok)
 	require.Len(t, avail, 1)
 	m0 := avail[0].(map[string]any)
 	assert.Equal(t, "claude-sonnet-4-6", m0["name"])
 	assert.Equal(t, "sonnet", m0["display_name"])
+	caps, ok := m0["capabilities"].(map[string]any)
+	require.True(t, ok, "model must have capabilities")
+	assert.Equal(t, true, caps["tools"])
 }
 
 func TestZedImport(t *testing.T) {
@@ -181,16 +199,3 @@ func TestZedDetect(t *testing.T) {
 	ad := New(WithHome(home))
 	assert.False(t, ad.Detect())
 }
-
-func TestSplitProviderModel(t *testing.T) {
-	t.Run("with slash", func(t *testing.T) {
-		p, m := splitProviderModel("anthropic/claude-sonnet-4-6")
-		assert.Equal(t, "anthropic", p)
-		assert.Equal(t, "claude-sonnet-4-6", m)
-	})
-	t.Run("no slash", func(t *testing.T) {
-		p, m := splitProviderModel("claude-sonnet")
-		assert.Equal(t, "anthropic", p)
-		assert.Equal(t, "claude-sonnet", m)
-	})
-}

internal/apply/apply.go

@@ -102,7 +102,7 @@ func handleRendered(opt Options, adapterName string, f adapter.File, rep *Report
 		return writeState(opt, sp, f.Content)
 	}
 
-	if opt.Force || len(base) == 0 || string(current) == string(base) {
+	if opt.Force || f.NoMerge || len(base) == 0 || string(current) == string(base) {
 		if opt.DryRun {
 			rep.Actions = append(rep.Actions, Action{Adapter: adapterName, Dest: f.Dest, Kind: "wrote", Note: "would write"})
 			return nil

internal/apply/apply_test.go

@@ -26,6 +26,9 @@ func (f *failingAdapter) Render(_ *canonical.Bundle) (*adapter.FileSet, error) {
 func (f *failingAdapter) Import(_ string) (*adapter.ImportResult, error) {
 	return &adapter.ImportResult{}, nil
 }
+func (f *failingAdapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{}
+}
 
 type stubAdapter struct {
 	name  string
@@ -44,6 +47,9 @@ func (s *stubAdapter) Render(_ *canonical.Bundle) (*adapter.FileSet, error) {
 	}
 	return fs, nil
 }
+func (s *stubAdapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{}
+}
 
 // ---------------------------------------------------------------------------
 // Existing tests

internal/cli/detect_test.go

@@ -24,6 +24,9 @@ func (d *detectableAdapter) Render(_ *canonical.Bundle) (*adapter.FileSet, error
 func (d *detectableAdapter) Import(_ string) (*adapter.ImportResult, error) {
 	return &adapter.ImportResult{}, nil
 }
+func (d *detectableAdapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{ManagesMCP: true}
+}
 
 func TestDetectCommandPrintsList(t *testing.T) {
 	reg := adapter.NewRegistry()

internal/cli/init_test.go

@@ -23,6 +23,9 @@ func (i *importableAdapter) Render(_ *canonical.Bundle) (*adapter.FileSet, error
 	return adapter.NewFileSet(), nil
 }
 func (i *importableAdapter) Import(_ string) (*adapter.ImportResult, error) { return i.res, nil }
+func (i *importableAdapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{ManagesMCP: true}
+}
 
 func TestInitImportWritesCanonical(t *testing.T) {
 	root := t.TempDir()

internal/cli/show_test.go

@@ -31,6 +31,9 @@ func (r *renderingAdapter) Render(_ *canonical.Bundle) (*adapter.FileSet, error)
 	}
 	return fs, nil
 }
+func (r *renderingAdapter) Capabilities() adapter.HarnessCapabilities {
+	return adapter.HarnessCapabilities{}
+}
 
 func TestShowPrintsTargets(t *testing.T) {
 	root := t.TempDir()

internal/gitx/repo.go

@@ -50,7 +50,10 @@ func (r *Repo) Add(paths ...string) error {
 }
 
 func (r *Repo) Commit(msg string) error {
-	_, err := r.run("commit", "-q", "-m", msg)
+	// --no-verify: harness-sync makes internal state-tracking commits in the
+	// canonical repo; user-configured hooks (secret scanners, linters) must not
+	// block them — those hooks belong to the harness-sync source repo, not here.
+	_, err := r.run("commit", "-q", "--no-verify", "-m", msg)
 	return err
 }