feat(tools): opt-in format-on-write for edit_file/write_file

With ZERO_FORMAT_ON_WRITE=1, a successful edit/write runs the language's
community-standard formatter on the file (gofmt, rustfmt, ruff, prettier,
zig fmt, dart format, terraform fmt, shfmt, clang-format, ktlint,
swiftformat, stylua, gleam format — 27 extensions), so model output
always lands in project-canonical style and never fails a format check
it cannot see. Best-effort: missing binary, error, or 10s timeout leaves
the unformatted write standing. Off by default per house convention —
auto-reformatting changes bytes the model did not write.

Ordering is load-bearing: formatting runs BEFORE the FileTracker
re-baseline so the recorded content matches what the formatter left on
disk; baselining pre-format content would make the very next edit trip
the external-modification conflict guard (covered by test).

Co-Authored-By: Claude Fable 5 <[email protected]>

internal/agent/file_diagnostics.go

@@ -0,0 +1,44 @@
+package agent
+
+import (
+	"context"
+	"os"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/lsp"
+)
+
+// fileDiagnosticsTimeout bounds one inline post-edit diagnostics check so a
+// slow or wedged language server can never hang a tool call; on timeout the
+// edit simply reports without a diagnostics block.
+const fileDiagnosticsTimeout = 10 * time.Second
+
+// NewFileDiagnostics adapts an *lsp.Manager to the per-edit inline diagnostics
+// callback (tools.RunOptions.Diagnostics): it reads the just-written file,
+// checks it against the file's language server, and formats error-severity
+// diagnostics for the model. Warnings and hints are excluded — nagging about
+// style on every edit is noise, while a type error the edit just introduced is
+// exactly what the model should see before its next step. Returns nil when
+// manager is nil, disabling inline diagnostics entirely.
+func NewFileDiagnostics(manager *lsp.Manager) func(context.Context, string) string {
+	if manager == nil {
+		return nil
+	}
+	return func(ctx context.Context, absPath string) string {
+		text, err := os.ReadFile(absPath)
+		if err != nil {
+			return ""
+		}
+		checkCtx, cancel := context.WithTimeout(ctx, fileDiagnosticsTimeout)
+		defer cancel()
+		diagnostics, err := manager.Check(checkCtx, absPath, string(text))
+		if err != nil {
+			return ""
+		}
+		errors := lsp.FilterBySeverity(diagnostics, lsp.SeverityError)
+		if len(errors) == 0 {
+			return ""
+		}
+		return lsp.FormatDiagnostics(absPath, errors)
+	}
+}

internal/agent/loop.go

@@ -475,11 +475,35 @@ func Run(ctx context.Context, prompt string, provider Provider, options Options)
 		// between tool_results breaks strict provider replay) — same after-batch
 		// rationale as turnRequestedModel above.
 		var changedFilesThisBatch []string
+		// Parallel read-ahead state: results for calls[precomputedStart:precomputedEnd]
+		// executed concurrently, consumed strictly in order below.
+		var precomputed []precomputedToolResult
+		precomputedStart, precomputedEnd := 0, 0
 		for index, call := range collected.ToolCalls {
+			// When this call starts a consecutive run of >= 2 auto-allowed read-only
+			// calls, execute the whole run concurrently now (see parallel_tools.go).
+			// The scan happens lazily at the run's first index — never ahead of a
+			// pending mutating call — so read-after-write ordering is preserved.
+			if index >= precomputedEnd {
+				runEnd := index
+				for runEnd < len(collected.ToolCalls) && parallelSafeToolCall(registry, collected.ToolCalls[runEnd], options) {
+					runEnd++
+				}
+				if runEnd-index >= 2 {
+					precomputed = executeParallelReadBatch(ctx, registry, collected.ToolCalls, index, runEnd, permissionMode, options)
+					precomputedStart, precomputedEnd = index, runEnd
+				}
+			}
 			if options.OnToolCall != nil {
 				options.OnToolCall(call)
 			}
-			toolResult, abortErr := executeToolCall(ctx, registry, call, permissionMode, options)
+			var toolResult ToolResult
+			var abortErr error
+			if index >= precomputedStart && index < precomputedEnd {
+				toolResult, abortErr = precomputed[index-precomputedStart].result, precomputed[index-precomputedStart].abortErr
+			} else {
+				toolResult, abortErr = executeToolCall(ctx, registry, call, permissionMode, options)
+			}
 			if options.OnToolResult != nil {
 				options.OnToolResult(toolResult)
 			}
@@ -1051,6 +1075,8 @@ func executeToolCall(ctx context.Context, registry *tools.Registry, call ToolCal
 		// Per-session file version tracker so write_file/edit_file refuse to clobber
 		// a file that changed on disk outside Zero since it was last read.
 		FileTracker: options.FileTracker,
+		// Inline post-edit diagnostics for mutating tools (nil = disabled).
+		Diagnostics: options.FileDiagnostics,
 		// Forward the run's operator tool filters so a filter-aware tool
 		// (tool_search) never discloses or loads an operator-hidden deferred tool.
 		EnabledTools:  options.EnabledTools,

internal/agent/parallel_tools.go

@@ -0,0 +1,85 @@
+package agent
+
+import (
+	"context"
+	"sync"
+
+	"github.com/Gitlawb/zero/internal/tools"
+)
+
+// Parallel read-ahead for tool batches. When a turn requests several
+// independent lookups (read_file + grep + glob is the common shape), executing
+// them one after another serializes pure I/O waits. A consecutive run of
+// auto-allowed read-only calls is executed concurrently instead; results are
+// then consumed in the original call order, so guard counters, message
+// ordering, abort semantics, and the surface's call/result event pairing are
+// byte-identical to sequential execution. Runs never span a mutating call: a
+// read that follows a write must observe the write, so eligibility is decided
+// per consecutive run, not per batch.
+
+// maxParallelReadTools bounds concurrent read-only tool executions in a turn.
+const maxParallelReadTools = 8
+
+// precomputedToolResult is one parallel read-ahead execution, keyed back to
+// its batch index by the caller.
+type precomputedToolResult struct {
+	result   ToolResult
+	abortErr error
+}
+
+// parallelSafeToolCall reports whether call may run concurrently with its
+// neighbors: the tool must exist, be side-effect-free (SideEffectRead), and be
+// auto-allowed for these args, so no interactive prompt or workspace mutation
+// is on the hot path. Loop-intercepted tools (ask_user, request_permissions)
+// and tool_search (mutates the deferred-tool set) stay sequential.
+func parallelSafeToolCall(registry *tools.Registry, call ToolCall, options Options) bool {
+	switch call.Name {
+	case "ask_user", tools.RequestPermissionsToolName, tools.ToolSearchToolName:
+		return false
+	}
+	tool, found := registry.Get(call.Name)
+	if !found || tool.Safety().SideEffect != tools.SideEffectRead {
+		return false
+	}
+	args := map[string]any{}
+	if call.Arguments != "" {
+		if err := decodeToolArguments(call.Arguments, &args); err != nil {
+			return false
+		}
+	}
+	return effectivePermission(tool, args) == tools.PermissionAllow
+}
+
+// executeParallelReadBatch runs calls[start:end] concurrently (bounded by
+// maxParallelReadTools) and returns results indexed relative to start. Any
+// permission prompt that still occurs (a sandbox preflight can demand one even
+// for an auto-allowed read) is serialized so an interactive front-end never
+// sees two prompts at once.
+func executeParallelReadBatch(ctx context.Context, registry *tools.Registry, calls []ToolCall, start, end int, permissionMode PermissionMode, options Options) []precomputedToolResult {
+	batchOptions := options
+	if options.OnPermissionRequest != nil {
+		var promptMutex sync.Mutex
+		inner := options.OnPermissionRequest
+		batchOptions.OnPermissionRequest = func(ctx context.Context, request PermissionRequest) (PermissionDecision, error) {
+			promptMutex.Lock()
+			defer promptMutex.Unlock()
+			return inner(ctx, request)
+		}
+	}
+
+	results := make([]precomputedToolResult, end-start)
+	semaphore := make(chan struct{}, maxParallelReadTools)
+	var waitGroup sync.WaitGroup
+	for index := start; index < end; index++ {
+		waitGroup.Add(1)
+		go func(index int) {
+			defer waitGroup.Done()
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
+			result, abortErr := executeToolCall(ctx, registry, calls[index], permissionMode, batchOptions)
+			results[index-start] = precomputedToolResult{result: result, abortErr: abortErr}
+		}(index)
+	}
+	waitGroup.Wait()
+	return results
+}

internal/agent/parallel_tools_test.go

@@ -0,0 +1,184 @@
+package agent
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/tools"
+	"github.com/Gitlawb/zero/internal/zeroruntime"
+)
+
+// probeTool records execution overlap and ordering so tests can assert what
+// actually ran concurrently.
+type probeTool struct {
+	name       string
+	sideEffect tools.SideEffect
+	delay      time.Duration
+
+	mu        sync.Mutex
+	active    int
+	maxActive int
+	log       []string
+}
+
+func (tool *probeTool) Name() string        { return tool.name }
+func (tool *probeTool) Description() string { return "test probe tool" }
+func (tool *probeTool) Parameters() tools.Schema {
+	return tools.Schema{
+		Type:                 "object",
+		Properties:           map[string]tools.PropertySchema{"id": {Type: "string"}},
+		AdditionalProperties: false,
+	}
+}
+func (tool *probeTool) Safety() tools.Safety {
+	return tools.Safety{SideEffect: tool.sideEffect, Permission: tools.PermissionAllow, Reason: "test"}
+}
+func (tool *probeTool) Run(_ context.Context, args map[string]any) tools.Result {
+	id, _ := args["id"].(string)
+	tool.mu.Lock()
+	tool.active++
+	if tool.active > tool.maxActive {
+		tool.maxActive = tool.active
+	}
+	tool.log = append(tool.log, "start:"+id)
+	tool.mu.Unlock()
+	time.Sleep(tool.delay)
+	tool.mu.Lock()
+	tool.active--
+	tool.log = append(tool.log, "end:"+id)
+	tool.mu.Unlock()
+	return tools.Result{Status: tools.StatusOK, Output: "probe " + id}
+}
+
+func probeCallEvents(callID, toolName, id string) []zeroruntime.StreamEvent {
+	return []zeroruntime.StreamEvent{
+		{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: callID, ToolName: toolName},
+		{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: callID, ArgumentsFragment: fmt.Sprintf(`{"id":%q}`, id)},
+		{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: callID},
+	}
+}
+
+func TestParallelSafeToolCall(t *testing.T) {
+	registry := tools.NewRegistry()
+	registry.Register(&probeTool{name: "probe_read", sideEffect: tools.SideEffectRead})
+	registry.Register(&probeTool{name: "probe_write", sideEffect: tools.SideEffectWrite})
+
+	call := func(name, args string) ToolCall { return ToolCall{ID: "c", Name: name, Arguments: args} }
+	if !parallelSafeToolCall(registry, call("probe_read", `{"id":"a"}`), Options{}) {
+		t.Fatal("auto-allowed read tool must be parallel-safe")
+	}
+	if parallelSafeToolCall(registry, call("probe_write", `{"id":"a"}`), Options{}) {
+		t.Fatal("mutating tool must not be parallel-safe")
+	}
+	if parallelSafeToolCall(registry, call("unknown_tool", `{}`), Options{}) {
+		t.Fatal("unknown tool must not be parallel-safe")
+	}
+	if parallelSafeToolCall(registry, call("probe_read", `{"id":`), Options{}) {
+		t.Fatal("undecodable arguments must not be parallel-safe")
+	}
+	if parallelSafeToolCall(registry, call("ask_user", `{}`), Options{}) {
+		t.Fatal("loop-intercepted tools must stay sequential")
+	}
+}
+
+func TestRunExecutesConsecutiveReadsConcurrently(t *testing.T) {
+	probe := &probeTool{name: "probe_read", sideEffect: tools.SideEffectRead, delay: 60 * time.Millisecond}
+	registry := tools.NewRegistry()
+	registry.Register(probe)
+
+	turnOne := append(probeCallEvents("call-1", "probe_read", "a"), probeCallEvents("call-2", "probe_read", "b")...)
+	turnOne = append(turnOne, probeCallEvents("call-3", "probe_read", "c")...)
+	turnOne = append(turnOne, zeroruntime.StreamEvent{Type: zeroruntime.StreamEventDone})
+	provider := &mockProvider{
+		turns: [][]zeroruntime.StreamEvent{
+			turnOne,
+			{{Type: zeroruntime.StreamEventText, Content: "done"}, {Type: zeroruntime.StreamEventDone}},
+		},
+	}
+
+	var results []ToolResult
+	_, err := Run(context.Background(), "probe", provider, Options{
+		Registry:     registry,
+		OnToolResult: func(result ToolResult) { results = append(results, result) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if probe.maxActive < 2 {
+		t.Fatalf("consecutive read-only calls must overlap, max concurrency was %d", probe.maxActive)
+	}
+	// Results must still be recorded in original call order.
+	if len(results) != 3 || results[0].ToolCallID != "call-1" || results[1].ToolCallID != "call-2" || results[2].ToolCallID != "call-3" {
+		t.Fatalf("tool results out of order: %#v", results)
+	}
+	messages := provider.requests[1].Messages
+	var toolOrder []string
+	for _, message := range messages {
+		if message.Role == zeroruntime.MessageRoleTool {
+			toolOrder = append(toolOrder, message.ToolCallID)
+		}
+	}
+	if len(toolOrder) != 3 || toolOrder[0] != "call-1" || toolOrder[1] != "call-2" || toolOrder[2] != "call-3" {
+		t.Fatalf("recorded tool messages out of order: %v", toolOrder)
+	}
+}
+
+func TestRunParallelReadsNeverSpanMutatingCall(t *testing.T) {
+	read := &probeTool{name: "probe_read", sideEffect: tools.SideEffectRead, delay: 30 * time.Millisecond}
+	write := &probeTool{name: "probe_write", sideEffect: tools.SideEffectWrite}
+	// Shared log across both probes so relative ordering is observable.
+	write.mu = sync.Mutex{}
+	registry := tools.NewRegistry()
+	registry.Register(read)
+	registry.Register(write)
+
+	turnOne := append(probeCallEvents("call-1", "probe_read", "r1"), probeCallEvents("call-2", "probe_read", "r2")...)
+	turnOne = append(turnOne, probeCallEvents("call-3", "probe_write", "w")...)
+	turnOne = append(turnOne, probeCallEvents("call-4", "probe_read", "r3")...)
+	turnOne = append(turnOne, probeCallEvents("call-5", "probe_read", "r4")...)
+	turnOne = append(turnOne, zeroruntime.StreamEvent{Type: zeroruntime.StreamEventDone})
+	provider := &mockProvider{
+		turns: [][]zeroruntime.StreamEvent{
+			turnOne,
+			{{Type: zeroruntime.StreamEventText, Content: "done"}, {Type: zeroruntime.StreamEventDone}},
+		},
+	}
+
+	_, err := Run(context.Background(), "probe", provider, Options{Registry: registry})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The write must start only after r1+r2 finished, and r3/r4 must start only
+	// after the write finished: batches never cross a mutating call.
+	index := func(log []string, entry string) int {
+		for i, e := range log {
+			if e == entry {
+				return i
+			}
+		}
+		return -1
+	}
+	readLog := func() []string { read.mu.Lock(); defer read.mu.Unlock(); return append([]string(nil), read.log...) }()
+	writeLog := func() []string { write.mu.Lock(); defer write.mu.Unlock(); return append([]string(nil), write.log...) }()
+	if index(writeLog, "start:w") == -1 {
+		t.Fatalf("write probe never ran: %v", writeLog)
+	}
+	for _, entry := range []string{"end:r1", "end:r2"} {
+		if index(readLog, entry) == -1 {
+			t.Fatalf("first read batch incomplete: %v", readLog)
+		}
+	}
+	// r3/r4 must appear strictly after r1/r2 in the read log (the write barrier
+	// between the two batches forces full separation).
+	firstBatchMaxEnd := max(index(readLog, "end:r1"), index(readLog, "end:r2"))
+	secondBatchMinStart := min(index(readLog, "start:r3"), index(readLog, "start:r4"))
+	if secondBatchMinStart < firstBatchMaxEnd {
+		t.Fatalf("second read batch started before first batch ended: %v", readLog)
+	}
+	if read.maxActive < 2 {
+		t.Fatalf("reads within a batch must overlap, max concurrency was %d", read.maxActive)
+	}
+}

internal/agent/types.go

@@ -285,6 +285,12 @@ type Options struct {
 	// ceiling and the autonomy gate. nil disables it entirely (the loop is
 	// byte-identical to before). One instance per run — it holds attempt state.
 	SelfCorrect *SelfCorrector
+	// FileDiagnostics, when set, is passed to mutating tools so edit_file /
+	// write_file append error-severity language diagnostics for the file they
+	// just wrote directly to their tool output — the model sees an error it
+	// introduced in the same turn instead of a later verification pass. Build
+	// one with NewFileDiagnostics. nil disables inline diagnostics.
+	FileDiagnostics func(ctx context.Context, absPath string) string
 
 	// RequireCompletionSignal gates run completion for HEADLESS exec. Without it,
 	// any assistant turn that produces text but no tool call is accepted as the

internal/cli/app.go

@@ -19,6 +19,7 @@ import (
 	"github.com/Gitlawb/zero/internal/hooks"
 	"github.com/Gitlawb/zero/internal/localcontrol"
 	"github.com/Gitlawb/zero/internal/mcp"
+	"github.com/Gitlawb/zero/internal/modelregistry"
 	"github.com/Gitlawb/zero/internal/observability"
 	"github.com/Gitlawb/zero/internal/plugins"
 	"github.com/Gitlawb/zero/internal/providerhealth"
@@ -229,6 +230,12 @@ func runWithDeps(args []string, stdout io.Writer, stderr io.Writer, deps appDeps
 	defer observability.Recover(observability.DefaultCrashDir(), "cli", stderr, &exitCode)
 	deps = fillAppDeps(deps)
 
+	// CLI runs opt into the models.dev overlay (cached live context limits and
+	// pricing on top of the curated catalog). Explicitly enabled here — and only
+	// here — so library consumers and hermetic tests are never perturbed by a
+	// cache file on the machine. The refresh itself is fired in exec/TUI startup.
+	modelregistry.EnableModelsDevOverlay()
+
 	addDirs, args, err := splitLeadingAddDirFlags(args)
 	if err != nil {
 		return writeAppError(stderr, err.Error(), 1)
@@ -544,6 +551,11 @@ func runInteractiveTUI(stderr io.Writer, deps appDeps, permissionMode agent.Perm
 }
 
 func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode agent.PermissionMode, addDirs []string, theme string, forceSetup bool) int {
+	// Refresh the models.dev pricing/limits cache in the background when stale;
+	// the overlay is read at registry construction from the cache file, so this
+	// benefits the next run and never blocks or fails this one.
+	go func() { _ = modelregistry.RefreshModelsDevCache(context.Background()) }()
+
 	workspaceRoot, err := deps.getwd()
 	if err != nil {
 		return writeAppError(stderr, "failed to resolve workspace: "+err.Error(), 1)

internal/cli/exec.go

@@ -135,6 +135,11 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 		return exitSuccess
 	}
 
+	// Refresh the models.dev pricing/limits cache in the background when stale;
+	// the overlay is read at registry construction from the cache file, so this
+	// benefits the next run and never blocks or fails this one.
+	go func() { _ = modelregistry.RefreshModelsDevCache(context.Background()) }()
+
 	// A mode seeds model/effort/max-turns/tool filters as a preset. Expand it up
 	// front — before tool-filter validation and the --list-tools branch — so a
 	// mode-injected tool filter is validated and reflected in --list-tools, and a
@@ -499,9 +504,10 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 	// by default the corrector is nil, leaving the agent loop byte-identical. When
 	// on we verify with both the workspace test plan and LSP diagnostics over the
 	// changed files; the autonomy gate inside the corrector still decides whether
-	// failures auto-fix or just report. lspShutdown tears down any language-server
-	// sessions the LSP half spawned (no-op when self-correct is off).
-	selfCorrector, lspShutdown := newExecSelfCorrector(options.selfCorrect, workspaceRoot, options.autonomy)
+	// failures auto-fix or just report. fileDiagnostics (always on, lazy) gives
+	// edit_file/write_file inline error diagnostics for the file they just wrote.
+	// lspShutdown tears down any language-server sessions either half spawned.
+	selfCorrector, fileDiagnostics, lspShutdown := newExecSelfCorrector(options.selfCorrect, workspaceRoot, options.autonomy)
 	defer lspShutdown()
 	result, err := agent.Run(runCtx, agentPrompt, provider, agent.Options{
 		MaxTurns:         resolved.MaxTurns,
@@ -525,6 +531,7 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 		PermissionMode:   permissionMode,
 		Autonomy:         options.autonomy,
 		SelfCorrect:      selfCorrector,
+		FileDiagnostics:  fileDiagnostics,
 		// Headless exec: don't accept a no-tool-call turn as "done" while work
 		// clearly remains (pending plan items / a mid-step continuation cue) —
 		// nudge to continue, and finalize as INCOMPLETE rather than false success
@@ -700,23 +707,28 @@ func runExec(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) in
 // unless a changed file's language actually has one installed on PATH. The
 // returned cleanup shuts that manager down (terminating any spawned server
 // sessions); it is a no-op when self-correct is off.
-func newExecSelfCorrector(enabled bool, workspaceRoot string, autonomy string) (*agent.SelfCorrector, func()) {
-	if !enabled {
-		return nil, func() {}
-	}
+func newExecSelfCorrector(enabled bool, workspaceRoot string, autonomy string) (*agent.SelfCorrector, func(context.Context, string) string, func()) {
+	// The manager is created regardless of --self-correct: it also backs the
+	// always-on inline post-edit diagnostics (agent.NewFileDiagnostics), and it
+	// stays lazy — no language server is spawned unless an edited file's
+	// language actually has one installed on PATH.
 	manager := lsp.NewManager(workspaceRoot)
+	cleanup := func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = manager.Shutdown(ctx)
+	}
+	fileDiagnostics := agent.NewFileDiagnostics(manager)
+	if !enabled {
+		return nil, fileDiagnostics, cleanup
+	}
 	corrector := agent.NewSelfCorrector(workspaceRoot, agent.NewLSPDiagnosticsChecker(manager), agent.NewProjectVerifier(workspaceRoot), agent.SelfCorrectConfig{
 		Enabled:      true,
 		IncludeTests: true,
 		IncludeLSP:   true,
 		Autonomy:     autonomy,
 	})
-	cleanup := func() {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		_ = manager.Shutdown(ctx)
-	}
-	return corrector, cleanup
+	return corrector, fileDiagnostics, cleanup
 }
 
 func deferredEligibleCount(registry *tools.Registry, permissionMode agent.PermissionMode, enabledTools []string, disabledTools []string) int {

internal/config/resolver.go

@@ -590,9 +590,17 @@ func applyProviderEnv(cfg *FileConfig, providerKind ProviderKind, env envProfile
 	if profile.Name == "" {
 		profile.Name = string(providerKind)
 	}
+	// A non-official baseURL from the environment signals a proxy/gateway, so promote
+	// the first-party kind to its -compatible transport (which accepts a custom URL).
+	// Env-only by design: a custom baseURL in a project config.json is left as-is and
+	// rejected by Resolve, so an untrusted project can't redirect a first-party key to
+	// another host.
 	if providerKind == ProviderKindOpenAI && baseURL != "" && !isOfficialOpenAIBaseURL(baseURL) {
 		profile.ProviderKind = ProviderKindOpenAICompatible
 	}
+	if providerKind == ProviderKindAnthropic && baseURL != "" && !isOfficialAnthropicBaseURL(baseURL) {
+		profile.ProviderKind = ProviderKindAnthropicCompat
+	}
 	// When the env supplies only credentials (no baseURL) for a provider name that
 	// already exists, don't force the standard transport kind — a same-named
 	// openai-compatible/anthropic-compatible proxy or gateway must keep its kind.

internal/config/resolver_test.go

@@ -617,6 +617,35 @@ func TestResolveUsesOpenAIEnvFallback(t *testing.T) {
 	}
 }
 
+func TestResolveUsesAnthropicEnvBaseURLAsCompatible(t *testing.T) {
+	// ANTHROPIC_BASE_URL pointing at a proxy/gateway must resolve to an
+	// anthropic-compatible provider (mirroring OPENAI_BASE_URL), not the "requires
+	// official baseURL" rejection — issue #479. The env is user-controlled, so a
+	// custom URL there is a deliberate gateway choice, unlike a project config.json.
+	resolved, err := Resolve(ResolveOptions{
+		Env: map[string]string{
+			"ANTHROPIC_API_KEY":  "sk-ant-env",
+			"ANTHROPIC_BASE_URL": "https://gateway.example/anthropic",
+			"ANTHROPIC_MODEL":    "claude-custom",
+		},
+	})
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+	if resolved.ActiveProvider != "anthropic" {
+		t.Fatalf("ActiveProvider = %q, want anthropic", resolved.ActiveProvider)
+	}
+	if resolved.Provider.ProviderKind != ProviderKindAnthropicCompat {
+		t.Fatalf("ProviderKind = %q, want anthropic-compatible", resolved.Provider.ProviderKind)
+	}
+	if resolved.Provider.BaseURL != "https://gateway.example/anthropic" {
+		t.Fatalf("BaseURL = %q, want gateway URL", resolved.Provider.BaseURL)
+	}
+	if resolved.Provider.APIKey != "sk-ant-env" || resolved.Provider.Model != "claude-custom" {
+		t.Fatalf("Provider = %#v, want env credentials/model", resolved.Provider)
+	}
+}
+
 func TestResolveUsesOpenAIAPIKeyOnlyWithDefaultModel(t *testing.T) {
 	resolved, err := Resolve(ResolveOptions{
 		Env: map[string]string{

internal/doctor/hardening.go

@@ -131,29 +131,45 @@ func doctorSandboxPolicy(cfg config.SandboxConfig) sandbox.Policy {
 // lspServersCheck reports which language servers ZERO would use are present on
 // PATH. Missing servers are not a failure — ZERO degrades to text-only edits for
 // those languages — so the worst status is WARN, and each missing server gets an
-// actionable install command keyed by its binary name.
+// actionable install command keyed by its binary name. Only the tier-1 servers
+// (lsp.CoreServerBinaries) drive the status: the long-tail servers configured
+// for breadth are listed informationally under missingOptional, because warning
+// about a missing zls on a machine with no Zig code would be permanent noise.
 func lspServersCheck(lookup func(string) (string, error)) Check {
 	if lookup == nil {
 		lookup = exec.LookPath
 	}
+	core := map[string]bool{}
+	for _, binary := range lsp.CoreServerBinaries() {
+		core[binary] = true
+	}
 	present := map[string]any{}
 	missing := map[string]any{}
+	missingOptional := map[string]any{}
 	for _, binary := range lsp.ServerBinaries() {
 		if _, err := lookup(binary); err == nil {
 			present[binary] = "on PATH"
 			continue
 		}
-		missing[binary] = lspRemedy(binary)
+		if core[binary] {
+			missing[binary] = lspRemedy(binary)
+		} else {
+			missingOptional[binary] = lspRemedy(binary)
+		}
+	}
+	details := map[string]any{"present": present}
+	if len(missingOptional) > 0 {
+		details["missingOptional"] = missingOptional
 	}
 	if len(missing) == 0 {
-		return check("lsp.servers", "LSP servers", StatusPass, "All known language servers are available on PATH.", map[string]any{
-			"present": present,
-		})
+		message := "All core language servers are available on PATH."
+		if len(missingOptional) > 0 {
+			message = fmt.Sprintf("All core language servers are available on PATH (%d optional server(s) not installed).", len(missingOptional))
+		}
+		return check("lsp.servers", "LSP servers", StatusPass, message, details)
 	}
-	return check("lsp.servers", "LSP servers", StatusWarn, fmt.Sprintf("%d language server(s) missing from PATH; affected files degrade to text-only edits.", len(missing)), map[string]any{
-		"present": present,
-		"missing": missing,
-	})
+	details["missing"] = missing
+	return check("lsp.servers", "LSP servers", StatusWarn, fmt.Sprintf("%d language server(s) missing from PATH; affected files degrade to text-only edits.", len(missing)), details)
 }
 
 // lspRemedy returns an actionable install command for a missing language-server

internal/lsp/registry.go

@@ -9,26 +9,134 @@ import (
 
 // serverCommands maps a file extension to the language-server command (argv) ZERO
 // will spawn. The first element is the binary looked up on PATH; missing binaries
-// are not an error, the agent just degrades to text-only for that file.
+// are not an error, the agent just degrades to text-only for that file. Every
+// command is the language's community-standard server invoked in stdio mode, so
+// a wrong guess can never spawn something surprising — only fail the PATH check.
 var serverCommands = map[string][]string{
-	".go":  {"gopls", "serve"},
-	".ts":  {"typescript-language-server", "--stdio"},
-	".tsx": {"typescript-language-server", "--stdio"},
-	".js":  {"typescript-language-server", "--stdio"},
-	".jsx": {"typescript-language-server", "--stdio"},
-	".py":  {"pyright-langserver", "--stdio"},
-	".rs":  {"rust-analyzer"},
+	".go":     {"gopls", "serve"},
+	".ts":     {"typescript-language-server", "--stdio"},
+	".tsx":    {"typescript-language-server", "--stdio"},
+	".mts":    {"typescript-language-server", "--stdio"},
+	".cts":    {"typescript-language-server", "--stdio"},
+	".js":     {"typescript-language-server", "--stdio"},
+	".jsx":    {"typescript-language-server", "--stdio"},
+	".mjs":    {"typescript-language-server", "--stdio"},
+	".cjs":    {"typescript-language-server", "--stdio"},
+	".py":     {"pyright-langserver", "--stdio"},
+	".pyi":    {"pyright-langserver", "--stdio"},
+	".rs":     {"rust-analyzer"},
+	".c":      {"clangd"},
+	".h":      {"clangd"},
+	".cpp":    {"clangd"},
+	".cc":     {"clangd"},
+	".cxx":    {"clangd"},
+	".hpp":    {"clangd"},
+	".java":   {"jdtls"},
+	".kt":     {"kotlin-language-server"},
+	".kts":    {"kotlin-language-server"},
+	".rb":     {"ruby-lsp"},
+	".php":    {"intelephense", "--stdio"},
+	".zig":    {"zls"},
+	".lua":    {"lua-language-server"},
+	".ex":     {"elixir-ls"},
+	".exs":    {"elixir-ls"},
+	".hs":     {"haskell-language-server-wrapper", "--lsp"},
+	".swift":  {"sourcekit-lsp"},
+	".ml":     {"ocamllsp"},
+	".mli":    {"ocamllsp"},
+	".scala":  {"metals"},
+	".clj":    {"clojure-lsp"},
+	".cljs":   {"clojure-lsp"},
+	".cljc":   {"clojure-lsp"},
+	".dart":   {"dart", "language-server"},
+	".gleam":  {"gleam", "lsp"},
+	".nix":    {"nixd"},
+	".tf":     {"terraform-ls", "serve"},
+	".sh":     {"bash-language-server", "start"},
+	".bash":   {"bash-language-server", "start"},
+	".yaml":   {"yaml-language-server", "--stdio"},
+	".yml":    {"yaml-language-server", "--stdio"},
+	".json":   {"vscode-json-language-server", "--stdio"},
+	".css":    {"vscode-css-language-server", "--stdio"},
+	".scss":   {"vscode-css-language-server", "--stdio"},
+	".less":   {"vscode-css-language-server", "--stdio"},
+	".html":   {"vscode-html-language-server", "--stdio"},
+	".svelte": {"svelteserver", "--stdio"},
+	".vue":    {"vue-language-server", "--stdio"},
+	".astro":  {"astro-ls", "--stdio"},
 }
 
 // languageIDs maps a file extension to the LSP languageId used in didOpen.
 var languageIDs = map[string]string{
-	".go":  "go",
-	".ts":  "typescript",
-	".tsx": "typescriptreact",
-	".js":  "javascript",
-	".jsx": "javascriptreact",
-	".py":  "python",
-	".rs":  "rust",
+	".go":     "go",
+	".ts":     "typescript",
+	".tsx":    "typescriptreact",
+	".mts":    "typescript",
+	".cts":    "typescript",
+	".js":     "javascript",
+	".jsx":    "javascriptreact",
+	".mjs":    "javascript",
+	".cjs":    "javascript",
+	".py":     "python",
+	".pyi":    "python",
+	".rs":     "rust",
+	".c":      "c",
+	".h":      "c",
+	".cpp":    "cpp",
+	".cc":     "cpp",
+	".cxx":    "cpp",
+	".hpp":    "cpp",
+	".java":   "java",
+	".kt":     "kotlin",
+	".kts":    "kotlin",
+	".rb":     "ruby",
+	".php":    "php",
+	".zig":    "zig",
+	".lua":    "lua",
+	".ex":     "elixir",
+	".exs":    "elixir",
+	".hs":     "haskell",
+	".swift":  "swift",
+	".ml":     "ocaml",
+	".mli":    "ocaml",
+	".scala":  "scala",
+	".clj":    "clojure",
+	".cljs":   "clojure",
+	".cljc":   "clojure",
+	".dart":   "dart",
+	".gleam":  "gleam",
+	".nix":    "nix",
+	".tf":     "terraform",
+	".sh":     "shellscript",
+	".bash":   "shellscript",
+	".yaml":   "yaml",
+	".yml":    "yaml",
+	".json":   "json",
+	".css":    "css",
+	".scss":   "scss",
+	".less":   "less",
+	".html":   "html",
+	".svelte": "svelte",
+	".vue":    "vue",
+	".astro":  "astro",
+}
+
+// coreServerBinaries are the tier-1 servers for the languages agents hit most;
+// `zero doctor` treats their absence as warn-worthy. The long tail of servers
+// configured above for breadth is reported informationally only — warning about
+// a missing zls on a machine with no Zig code would be permanent noise.
+var coreServerBinaries = []string{
+	"gopls",
+	"typescript-language-server",
+	"pyright-langserver",
+	"rust-analyzer",
+}
+
+// CoreServerBinaries returns the tier-1 server binaries (sorted copy).
+func CoreServerBinaries() []string {
+	binaries := append([]string(nil), coreServerBinaries...)
+	sort.Strings(binaries)
+	return binaries
 }
 
 // ServerBinaries returns the unique set of language-server binaries ZERO may

internal/modelregistry/catalog.go

@@ -3,7 +3,6 @@ package modelregistry
 import (
 	"fmt"
 	"strings"
-	"sync"
 )
 
 const DefaultModelID = "gpt-4.1"
@@ -43,20 +42,8 @@ type ListOptions struct {
 	Capability        ModelCapability
 }
 
-// defaultRegistry builds the default registry exactly once and caches the result.
-// The default catalog is static, every accessor returns clones, and a built
-// Registry is never mutated (concurrent reads of its maps are safe), so a single
-// shared instance is correct — and it avoids re-cloning all entries and
-// recompiling every fuzzy-match regex on the per-frame TUI paths (title chip,
-// context gauge, pickers) that call DefaultRegistry each render.
-var defaultRegistry = sync.OnceValues(func() (Registry, error) {
-	return NewRegistry(DefaultModelEntries())
-})
-
-// DefaultRegistry returns the shared, immutable default model registry, building
-// it on first use.
 func DefaultRegistry() (Registry, error) {
-	return defaultRegistry()
+	return NewRegistry(DefaultModelEntries())
 }
 
 func DefaultModelEntries() []ModelEntry {
@@ -76,6 +63,10 @@ func DefaultModelEntries() []ModelEntry {
 		googleModel("gemini-2.5-flash-lite", "Gemini 2.5 Flash-Lite", "gemini-2.5-flash-lite", ModelStatusActive, []string{"google:gemini-2.5-flash-lite", "gemini-flash-lite"}, ContextLimits{ContextWindow: 1_048_576, MaxOutputTokens: 65_536}, ModelCost{InputPerMillion: 0.1, CachedInputPerMillion: 0.01, OutputPerMillion: 0.4}, []ModelCapability{ModelCapabilityVision, ModelCapabilityJSONMode, ModelCapabilityReasoning, ModelCapabilityLongContext}, standardReasoningEfforts(), "Google low-cost Flash model for background routing and summaries."),
 	}
 	decorateModelDepth(entries)
+	// Overlay volatile facts (context limits, base pricing) from a cached
+	// models.dev snapshot when one is present and fresh — see modelsdev.go.
+	// Identity fields (ids, aliases, patterns, deprecations) stay curated.
+	entries = applyModelsDevOverrides(entries, cachedModelsDevProviders())
 	return cloneModelEntries(entries)
 }
 
@@ -89,13 +80,11 @@ func decorateModelDepth(entries []ModelEntry) {
 		patterns      []string
 		deprecation   *DeprecationRule
 		upgradeTarget string
-		fastVariant   string
 	}{
 		"claude-sonnet-4.5": {
 			defaultEffort: ReasoningEffortMedium,
 			patterns:      []string{`(?i)^sonnet[^a-z0-9]*4[.\s]?5$`},
 			upgradeTarget: "claude-opus-4.1",
-			fastVariant:   "claude-haiku-4.5",
 		},
 		"claude-opus-4.1": {
 			defaultEffort: ReasoningEffortHigh,
@@ -109,7 +98,6 @@ func decorateModelDepth(entries []ModelEntry) {
 		"gemini-2.5-pro": {
 			defaultEffort: ReasoningEffortMedium,
 			patterns:      []string{`(?i)^gemini[^a-z0-9]*pro$`},
-			fastVariant:   "gemini-2.5-flash",
 		},
 		"gemini-2.5-flash": {
 			defaultEffort: ReasoningEffortLow,
@@ -118,12 +106,6 @@ func decorateModelDepth(entries []ModelEntry) {
 		"gemini-2.5-flash-lite": {
 			upgradeTarget: "gemini-2.5-flash",
 		},
-		"gpt-4.1": {
-			fastVariant: "gpt-4.1-mini",
-		},
-		"gpt-4o": {
-			fastVariant: "gpt-4o-mini",
-		},
 		"gpt-4.1-mini": {
 			upgradeTarget: "gpt-4.1",
 		},
@@ -165,9 +147,6 @@ func decorateModelDepth(entries []ModelEntry) {
 		if extra.upgradeTarget != "" {
 			entries[index].UpgradeTargetID = extra.upgradeTarget
 		}
-		if extra.fastVariant != "" {
-			entries[index].FastVariantID = extra.fastVariant
-		}
 	}
 }
 

internal/modelregistry/models.go

@@ -110,14 +110,7 @@ type ModelEntry struct {
 	// during mid-run escalation. Empty means no escalation target (e.g. top-tier
 	// models). Resolved and availability-checked by Registry.UpgradeTarget.
 	UpgradeTargetID string
-	// FastVariantID, when set, names a genuinely faster same-family model this one
-	// can drop down to (e.g. claude-sonnet-4.5 -> claude-haiku-4.5). Empty means no
-	// fast variant. It is the single source of truth for the /fast command and the
-	// "f" fast-mode marker: Registry.FastVariant walks it forward and BaseVariant
-	// walks it in reverse, so a model is "in fast mode" iff another model names it
-	// here. Resolved and availability-checked like UpgradeTargetID.
-	FastVariantID string
-	Description   string
+	Description     string
 }
 
 // DeprecationRule describes how a deprecated model is phased out and what to use
@@ -375,18 +368,6 @@ func NewRegistry(entries []ModelEntry) (Registry, error) {
 			return Registry{}, fmt.Errorf("model %q upgrade target %q does not resolve to a known model", entry.ID, targetID)
 		}
 	}
-	// A non-empty FastVariantID must resolve to a known model, mirroring the
-	// UpgradeTargetID check — otherwise /fast and the "f" fast-mode marker would
-	// silently vanish at runtime on a catalog typo instead of failing loudly here.
-	for _, entry := range registry.models {
-		fastID := strings.TrimSpace(entry.FastVariantID)
-		if fastID == "" {
-			continue
-		}
-		if _, ok := registry.Get(fastID); !ok {
-			return Registry{}, fmt.Errorf("model %q fast variant %q does not resolve to a known model", entry.ID, fastID)
-		}
-	}
 	return registry, nil
 }
 

internal/modelregistry/modelsdev.go

@@ -0,0 +1,269 @@
+package modelregistry
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// Live models.dev overlay for the curated catalog. The hand-maintained
+// DefaultModelEntries list is the source of truth for identity — ids, aliases,
+// match patterns, deprecations, escalation targets — but its VOLATILE facts
+// (context window, max output tokens, per-million pricing) go stale between
+// releases. When a cached snapshot of https://models.dev/api.json is present,
+// those fields are refreshed from it at registry construction; everything else
+// stays curated. The overlay never adds models (an auto-added entry would lack
+// aliases, match patterns, and provider wiring) and never touches the network
+// on the registry hot path — fetching happens only in the explicit background
+// refresh, cached to disk with a TTL.
+
+const (
+	modelsDevDefaultURL = "https://models.dev/api.json"
+	// modelsDevRefreshAfter is how old the cache may get before a background
+	// refresh re-fetches it.
+	modelsDevRefreshAfter = 24 * time.Hour
+	// modelsDevMaxAge is the oldest cache still applied as an overlay. Beyond
+	// this the curated catalog (updated with the binary) is likely fresher than
+	// the snapshot, so a stale file is ignored rather than trusted.
+	modelsDevMaxAge      = 7 * 24 * time.Hour
+	modelsDevFetchLimit  = 32 << 20 // 32MiB guard on the response body
+	modelsDevFetchWindow = 15 * time.Second
+)
+
+// modelsDevModel is the subset of a models.dev model record the overlay uses.
+type modelsDevModel struct {
+	Limit struct {
+		Context int `json:"context"`
+		Output  int `json:"output"`
+	} `json:"limit"`
+	Cost struct {
+		Input      float64 `json:"input"`
+		Output     float64 `json:"output"`
+		CacheRead  float64 `json:"cache_read"`
+		CacheWrite float64 `json:"cache_write"`
+	} `json:"cost"`
+}
+
+// modelsDevProvider matches one provider object in api.json.
+type modelsDevProvider struct {
+	Models map[string]modelsDevModel `json:"models"`
+}
+
+// parseModelsDev decodes an api.json document into provider-slug -> api-model
+// -> record. api.json is a top-level object keyed by provider id.
+func parseModelsDev(data []byte) (map[string]map[string]modelsDevModel, error) {
+	var doc map[string]modelsDevProvider
+	if err := json.Unmarshal(data, &doc); err != nil {
+		return nil, fmt.Errorf("modelregistry: parse models.dev: %w", err)
+	}
+	providers := make(map[string]map[string]modelsDevModel, len(doc))
+	for slug, provider := range doc {
+		if len(provider.Models) == 0 {
+			continue
+		}
+		providers[slug] = provider.Models
+	}
+	if len(providers) == 0 {
+		return nil, fmt.Errorf("modelregistry: models.dev document has no providers")
+	}
+	return providers, nil
+}
+
+// modelsDevSlugs maps an entry's provider kind to the models.dev provider ids
+// worth checking. Only first-party slugs are used: router entries on models.dev
+// carry generic or stale numbers.
+func modelsDevSlugs(kind ProviderKind) []string {
+	switch kind {
+	case ProviderAnthropic:
+		return []string{"anthropic"}
+	case ProviderOpenAI:
+		return []string{"openai"}
+	case ProviderGoogle:
+		return []string{"google", "google-vertex"}
+	default:
+		return nil
+	}
+}
+
+// applyModelsDevOverrides refreshes each curated entry's context limits and
+// base pricing from the snapshot, when the snapshot knows the model. Tiered
+// pricing is never touched: models.dev has no tier data, and mixing a live
+// base rate with curated tiers would misprice the tier boundaries.
+func applyModelsDevOverrides(entries []ModelEntry, providers map[string]map[string]modelsDevModel) []ModelEntry {
+	if len(providers) == 0 {
+		return entries
+	}
+	for i := range entries {
+		entry := &entries[i]
+		var record modelsDevModel
+		found := false
+		for _, slug := range modelsDevSlugs(entry.Provider) {
+			if models, ok := providers[slug]; ok {
+				if candidate, ok := models[strings.TrimSpace(entry.APIModel)]; ok {
+					record = candidate
+					found = true
+					break
+				}
+			}
+		}
+		if !found {
+			continue
+		}
+		if record.Limit.Context > 0 {
+			entry.ContextLimits.ContextWindow = record.Limit.Context
+		}
+		if record.Limit.Output > 0 {
+			entry.ContextLimits.MaxOutputTokens = record.Limit.Output
+		}
+		if len(entry.Cost.Tiers) == 0 && record.Cost.Input > 0 && record.Cost.Output > 0 {
+			entry.Cost.InputPerMillion = record.Cost.Input
+			entry.Cost.OutputPerMillion = record.Cost.Output
+			if record.Cost.CacheRead > 0 {
+				entry.Cost.CachedInputPerMillion = record.Cost.CacheRead
+			}
+			if record.Cost.CacheWrite > 0 {
+				entry.Cost.CacheWritePerMillion = record.Cost.CacheWrite
+			}
+			entry.Cost.Source = "models.dev/api.json (cached)"
+		}
+	}
+	return entries
+}
+
+// modelsDevCachePath returns the on-disk cache location. ZERO_MODELS_CACHE_PATH
+// overrides it (used by tests and unusual setups).
+func modelsDevCachePath() (string, error) {
+	if override := strings.TrimSpace(os.Getenv("ZERO_MODELS_CACHE_PATH")); override != "" {
+		return override, nil
+	}
+	base, err := os.UserCacheDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(base, "zero", "modelsdev.json"), nil
+}
+
+var (
+	modelsDevOnce    sync.Once
+	modelsDevCached  map[string]map[string]modelsDevModel
+	modelsDevEnabled atomic.Bool
+)
+
+// EnableModelsDevOverlay opts the process into applying the cached models.dev
+// snapshot on top of the curated catalog. The CLI entrypoint calls it; library
+// consumers and tests that never do get the curated catalog byte-identical to
+// before, so hermetic tests can't be perturbed by a cache file on the machine.
+// ZERO_DISABLE_MODELS_FETCH disables both the overlay and the fetch.
+func EnableModelsDevOverlay() {
+	modelsDevEnabled.Store(true)
+}
+
+// cachedModelsDevProviders loads the cached snapshot once per process. Not
+// enabled, missing, stale (> modelsDevMaxAge), or malformed all yield nil and
+// the curated catalog is used untouched. Read once deliberately:
+// DefaultRegistry is called on hot paths (pickers, cost views) and must not
+// re-stat the file every time; a background refresh benefits the NEXT process.
+func cachedModelsDevProviders() map[string]map[string]modelsDevModel {
+	if !modelsDevEnabled.Load() || strings.TrimSpace(os.Getenv("ZERO_DISABLE_MODELS_FETCH")) != "" {
+		return nil
+	}
+	modelsDevOnce.Do(func() {
+		path, err := modelsDevCachePath()
+		if err != nil {
+			return
+		}
+		info, err := os.Stat(path)
+		if err != nil || time.Since(info.ModTime()) > modelsDevMaxAge {
+			return
+		}
+		data, err := os.ReadFile(path)
+		if err != nil {
+			return
+		}
+		providers, err := parseModelsDev(data)
+		if err != nil {
+			return
+		}
+		modelsDevCached = providers
+	})
+	return modelsDevCached
+}
+
+// resetModelsDevCacheForTest clears the process-level cache memoization and
+// disables the overlay.
+func resetModelsDevCacheForTest() {
+	modelsDevOnce = sync.Once{}
+	modelsDevCached = nil
+	modelsDevEnabled.Store(false)
+}
+
+// RefreshModelsDevCache fetches models.dev/api.json into the on-disk cache
+// when the cache is missing or older than modelsDevRefreshAfter. It is safe to
+// call fire-and-forget from startup (use a goroutine); it never affects the
+// current process's registry (see cachedModelsDevProviders). Disabled entirely
+// by ZERO_DISABLE_MODELS_FETCH. The URL can be overridden with ZERO_MODELS_URL.
+func RefreshModelsDevCache(ctx context.Context) error {
+	if strings.TrimSpace(os.Getenv("ZERO_DISABLE_MODELS_FETCH")) != "" {
+		return nil
+	}
+	path, err := modelsDevCachePath()
+	if err != nil {
+		return err
+	}
+	if info, err := os.Stat(path); err == nil && time.Since(info.ModTime()) < modelsDevRefreshAfter {
+		return nil
+	}
+
+	url := strings.TrimSpace(os.Getenv("ZERO_MODELS_URL"))
+	if url == "" {
+		url = modelsDevDefaultURL
+	}
+	fetchCtx, cancel := context.WithTimeout(ctx, modelsDevFetchWindow)
+	defer cancel()
+	request, err := http.NewRequestWithContext(fetchCtx, http.MethodGet, url, nil)
+	if err != nil {
+		return err
+	}
+	request.Header.Set("User-Agent", "zero-models-refresh/0.1")
+	response, err := http.DefaultClient.Do(request)
+	if err != nil {
+		return err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		return fmt.Errorf("modelregistry: models.dev fetch: HTTP %d", response.StatusCode)
+	}
+	data, err := io.ReadAll(io.LimitReader(response.Body, modelsDevFetchLimit))
+	if err != nil {
+		return err
+	}
+	// Validate before persisting: a bad body must never clobber a good cache.
+	if _, err := parseModelsDev(data); err != nil {
+		return err
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	temp, err := os.CreateTemp(filepath.Dir(path), "modelsdev-*.json")
+	if err != nil {
+		return err
+	}
+	if _, err := temp.Write(data); err != nil {
+		_ = temp.Close()
+		_ = os.Remove(temp.Name())
+		return err
+	}
+	if err := temp.Close(); err != nil {
+		_ = os.Remove(temp.Name())
+		return err
+	}
+	return os.Rename(temp.Name(), path)
+}

internal/modelregistry/modelsdev_test.go

@@ -0,0 +1,228 @@
+package modelregistry
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+const sampleModelsDev = `{
+  "anthropic": {
+    "id": "anthropic",
+    "models": {
+      "claude-sonnet-4-5-20250929": {
+        "limit": {"context": 1000000, "output": 64000},
+        "cost": {"input": 3.5, "output": 17.5, "cache_read": 0.35, "cache_write": 4.4}
+      }
+    }
+  },
+  "google": {
+    "id": "google",
+    "models": {
+      "gemini-2.5-pro": {
+        "limit": {"context": 2097152, "output": 65536},
+        "cost": {"input": 9.99, "output": 9.99}
+      }
+    }
+  }
+}`
+
+func TestParseModelsDev(t *testing.T) {
+	providers, err := parseModelsDev([]byte(sampleModelsDev))
+	if err != nil {
+		t.Fatal(err)
+	}
+	record, ok := providers["anthropic"]["claude-sonnet-4-5-20250929"]
+	if !ok {
+		t.Fatal("expected anthropic sonnet record")
+	}
+	if record.Limit.Context != 1_000_000 || record.Cost.Input != 3.5 {
+		t.Fatalf("unexpected record: %+v", record)
+	}
+	if _, err := parseModelsDev([]byte(`{}`)); err == nil {
+		t.Fatal("empty document must be rejected")
+	}
+	if _, err := parseModelsDev([]byte(`not json`)); err == nil {
+		t.Fatal("malformed document must be rejected")
+	}
+}
+
+func TestApplyModelsDevOverrides(t *testing.T) {
+	// Point the cache at a non-existent file so DefaultModelEntries returns the
+	// pure curated catalog, then apply the sample snapshot explicitly.
+	t.Setenv("ZERO_MODELS_CACHE_PATH", filepath.Join(t.TempDir(), "absent.json"))
+	resetModelsDevCacheForTest()
+	t.Cleanup(resetModelsDevCacheForTest)
+
+	providers, err := parseModelsDev([]byte(sampleModelsDev))
+	if err != nil {
+		t.Fatal(err)
+	}
+	entries := applyModelsDevOverrides(DefaultModelEntries(), providers)
+
+	var sonnet, geminiPro, opus ModelEntry
+	for _, entry := range entries {
+		switch entry.ID {
+		case "claude-sonnet-4.5":
+			sonnet = entry
+		case "gemini-2.5-pro":
+			geminiPro = entry
+		case "claude-opus-4.1":
+			opus = entry
+		}
+	}
+
+	// Known model: limits and base pricing refreshed from the snapshot.
+	if sonnet.ContextLimits.ContextWindow != 1_000_000 || sonnet.ContextLimits.MaxOutputTokens != 64_000 {
+		t.Fatalf("sonnet limits not overridden: %+v", sonnet.ContextLimits)
+	}
+	if sonnet.Cost.InputPerMillion != 3.5 || sonnet.Cost.OutputPerMillion != 17.5 || sonnet.Cost.CacheWritePerMillion != 4.4 {
+		t.Fatalf("sonnet cost not overridden: %+v", sonnet.Cost)
+	}
+	if sonnet.Cost.Source != "models.dev/api.json (cached)" {
+		t.Fatalf("sonnet cost source not marked: %q", sonnet.Cost.Source)
+	}
+
+	// Tiered pricing is curated: limits refresh, cost must NOT (gemini-2.5-pro
+	// has curated tiers and the snapshot's flat 9.99 would misprice them).
+	if geminiPro.ContextLimits.ContextWindow != 2_097_152 {
+		t.Fatalf("gemini limits not overridden: %+v", geminiPro.ContextLimits)
+	}
+	if geminiPro.Cost.InputPerMillion == 9.99 || len(geminiPro.Cost.Tiers) == 0 {
+		t.Fatalf("tiered cost must stay curated: %+v", geminiPro.Cost)
+	}
+
+	// Model absent from the snapshot: untouched.
+	if opus.ContextLimits.ContextWindow != 200_000 || opus.Cost.InputPerMillion != 15 {
+		t.Fatalf("opus must be untouched: %+v %+v", opus.ContextLimits, opus.Cost)
+	}
+}
+
+func TestRefreshModelsDevCacheFetchesAndCaches(t *testing.T) {
+	hits := 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits++
+		_, _ = w.Write([]byte(sampleModelsDev))
+	}))
+	defer server.Close()
+
+	cachePath := filepath.Join(t.TempDir(), "modelsdev.json")
+	t.Setenv("ZERO_MODELS_CACHE_PATH", cachePath)
+	t.Setenv("ZERO_MODELS_URL", server.URL)
+	t.Setenv("ZERO_DISABLE_MODELS_FETCH", "")
+
+	if err := RefreshModelsDevCache(t.Context()); err != nil {
+		t.Fatal(err)
+	}
+	if hits != 1 {
+		t.Fatalf("expected 1 fetch, got %d", hits)
+	}
+	if _, err := os.Stat(cachePath); err != nil {
+		t.Fatalf("cache file missing: %v", err)
+	}
+	// Fresh cache: second call must not re-fetch.
+	if err := RefreshModelsDevCache(t.Context()); err != nil {
+		t.Fatal(err)
+	}
+	if hits != 1 {
+		t.Fatalf("fresh cache must skip the fetch, got %d hits", hits)
+	}
+}
+
+func TestRefreshModelsDevCacheRejectsBadBodyWithoutClobbering(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte("not json"))
+	}))
+	defer server.Close()
+
+	cachePath := filepath.Join(t.TempDir(), "modelsdev.json")
+	if err := os.WriteFile(cachePath, []byte(sampleModelsDev), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	stale := time.Now().Add(-48 * time.Hour)
+	if err := os.Chtimes(cachePath, stale, stale); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ZERO_MODELS_CACHE_PATH", cachePath)
+	t.Setenv("ZERO_MODELS_URL", server.URL)
+
+	if err := RefreshModelsDevCache(t.Context()); err == nil {
+		t.Fatal("bad body must return an error")
+	}
+	content, err := os.ReadFile(cachePath)
+	if err != nil || string(content) != sampleModelsDev {
+		t.Fatal("bad fetch must not clobber the existing cache")
+	}
+}
+
+func TestRefreshModelsDevCacheDisabledByEnv(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("fetch must not happen when disabled")
+	}))
+	defer server.Close()
+	t.Setenv("ZERO_MODELS_CACHE_PATH", filepath.Join(t.TempDir(), "modelsdev.json"))
+	t.Setenv("ZERO_MODELS_URL", server.URL)
+	t.Setenv("ZERO_DISABLE_MODELS_FETCH", "1")
+	if err := RefreshModelsDevCache(t.Context()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCachedModelsDevProvidersIgnoresStaleCache(t *testing.T) {
+	cachePath := filepath.Join(t.TempDir(), "modelsdev.json")
+	if err := os.WriteFile(cachePath, []byte(sampleModelsDev), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	stale := time.Now().Add(-modelsDevMaxAge - time.Hour)
+	if err := os.Chtimes(cachePath, stale, stale); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ZERO_MODELS_CACHE_PATH", cachePath)
+	resetModelsDevCacheForTest()
+	t.Cleanup(resetModelsDevCacheForTest)
+	EnableModelsDevOverlay()
+
+	if providers := cachedModelsDevProviders(); providers != nil {
+		t.Fatal("stale cache must be ignored")
+	}
+}
+
+func TestCachedModelsDevProvidersRequiresOptIn(t *testing.T) {
+	cachePath := filepath.Join(t.TempDir(), "modelsdev.json")
+	if err := os.WriteFile(cachePath, []byte(sampleModelsDev), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ZERO_MODELS_CACHE_PATH", cachePath)
+	resetModelsDevCacheForTest()
+	t.Cleanup(resetModelsDevCacheForTest)
+
+	// Without EnableModelsDevOverlay a fresh, valid cache must still be ignored:
+	// library consumers and hermetic tests get the pure curated catalog.
+	if providers := cachedModelsDevProviders(); providers != nil {
+		t.Fatal("overlay must be opt-in")
+	}
+}
+
+func TestDefaultModelEntriesAppliesFreshCache(t *testing.T) {
+	cachePath := filepath.Join(t.TempDir(), "modelsdev.json")
+	if err := os.WriteFile(cachePath, []byte(sampleModelsDev), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("ZERO_MODELS_CACHE_PATH", cachePath)
+	resetModelsDevCacheForTest()
+	t.Cleanup(resetModelsDevCacheForTest)
+	EnableModelsDevOverlay()
+
+	for _, entry := range DefaultModelEntries() {
+		if entry.ID == "claude-sonnet-4.5" {
+			if entry.ContextLimits.ContextWindow != 1_000_000 {
+				t.Fatalf("fresh cache must overlay the registry: %+v", entry.ContextLimits)
+			}
+			return
+		}
+	}
+	t.Fatal("claude-sonnet-4.5 not found")
+}

internal/modelregistry/variants.go

@@ -1,75 +0,0 @@
-package modelregistry
-
-import "strings"
-
-// The base<->fast model mapping is data, not logic: it lives entirely in each
-// ModelEntry's FastVariantID field (populated in the catalog, validated in
-// NewRegistry). Adding a pair is a one-line catalog change — never a code change
-// here. Both directions derive from that one field: FastVariant walks a model to
-// the fast id it names, BaseVariant scans for the model that names id as its fast
-// variant. This is why "fast mode" is encoded by model identity and needs no flag.
-//
-// Only models with an unambiguous 1:1 fast counterpart carry a FastVariantID. A
-// model with no clean counterpart (e.g. a top-tier Opus, where both Sonnet and
-// Haiku would be candidates) is intentionally left unset, so /fast reports "no
-// fast mode available" for it rather than guessing.
-
-// FastVariant resolves id to its configured faster same-family counterpart. It
-// resolves id to a concrete entry, reads that entry's FastVariantID, and returns
-// the target only when it resolves and is not deprecated. Returns (_, false) when
-// id is unknown, has no fast variant, or the variant is unavailable/deprecated.
-// Mirrors Registry.UpgradeTarget.
-func (registry Registry) FastVariant(id string) (ModelEntry, bool) {
-	source, ok := registry.Resolve(id)
-	if !ok {
-		return ModelEntry{}, false
-	}
-	fastID := strings.TrimSpace(source.FastVariantID)
-	if fastID == "" {
-		return ModelEntry{}, false
-	}
-	target, ok := registry.Resolve(fastID)
-	if !ok || target.Status == ModelStatusDeprecated {
-		return ModelEntry{}, false
-	}
-	return target, true
-}
-
-// BaseVariant resolves id to the base model that declares id as its fast variant
-// — the reverse of FastVariant. A non-empty result therefore means id IS a fast
-// model: this is exactly how the /fast command derives "currently in fast mode"
-// without storing any flag. Same resolution and availability rules as FastVariant.
-func (registry Registry) BaseVariant(id string) (ModelEntry, bool) {
-	source, ok := registry.Resolve(id)
-	if !ok {
-		return ModelEntry{}, false
-	}
-	for _, entry := range registry.models {
-		fastID := strings.TrimSpace(entry.FastVariantID)
-		if fastID == "" {
-			continue
-		}
-		target, ok := registry.Resolve(fastID)
-		if !ok || target.ID != source.ID {
-			continue
-		}
-		if entry.Status == ModelStatusDeprecated {
-			return ModelEntry{}, false
-		}
-		base, ok := registry.Resolve(entry.ID)
-		if !ok {
-			return ModelEntry{}, false
-		}
-		return base, true
-	}
-	return ModelEntry{}, false
-}
-
-// HasFastVariant reports whether id has an available fast variant — i.e. whether
-// `/fast on` would switch to a faster model from here. It is the predicate the
-// TUI uses to show the "f" fast-mode marker on a model (in the model/provider
-// pickers and the active-model indicator).
-func (registry Registry) HasFastVariant(id string) bool {
-	_, ok := registry.FastVariant(id)
-	return ok
-}

internal/modelregistry/variants_test.go

@@ -1,145 +0,0 @@
-package modelregistry
-
-import "testing"
-
-func testRegistry(t *testing.T) Registry {
-	t.Helper()
-	registry, err := DefaultRegistry()
-	if err != nil {
-		t.Fatalf("DefaultRegistry() error = %v", err)
-	}
-	return registry
-}
-
-// expectedFastPairs is the known-good base->fast mapping. It is a literal
-// regression guard: if the catalog silently drops or mis-wires a FastVariantID,
-// the forward/reverse assertions below fail loudly rather than making /fast a
-// quiet no-op. Keep in sync with the FastVariantID fields in catalog.go.
-var expectedFastPairs = map[string]string{
-	"claude-sonnet-4.5": "claude-haiku-4.5",
-	"gpt-4.1":           "gpt-4.1-mini",
-	"gpt-4o":            "gpt-4o-mini",
-	"gemini-2.5-pro":    "gemini-2.5-flash",
-}
-
-// Every FastVariantID declared in the catalog must resolve to a real, non-self,
-// non-deprecated model. NewRegistry already rejects an unresolvable id at build
-// time; this additionally guards the runtime availability contract that /fast and
-// the "f" marker depend on.
-func TestCatalogFastVariantsResolve(t *testing.T) {
-	registry := testRegistry(t)
-	for _, entry := range registry.List(ListOptions{IncludeDeprecated: true}) {
-		if entry.FastVariantID == "" {
-			continue
-		}
-		target, ok := registry.Resolve(entry.FastVariantID)
-		if !ok {
-			t.Errorf("model %q fast variant %q does not resolve", entry.ID, entry.FastVariantID)
-			continue
-		}
-		if target.ID == entry.ID {
-			t.Errorf("model %q names itself as its fast variant", entry.ID)
-		}
-		if target.Status == ModelStatusDeprecated {
-			t.Errorf("model %q fast variant %q is deprecated", entry.ID, entry.FastVariantID)
-		}
-	}
-}
-
-// No model may be both a base and a fast, or the two directions become ambiguous
-// (a model would be "currently fast" AND advertise a fast variant). Derived from
-// the registry so a bad catalog edit — e.g. chaining mini->nano — is caught.
-func TestFastVariantPairsUnambiguous(t *testing.T) {
-	registry := testRegistry(t)
-	role := map[string]string{} // canonical id -> "base" | "fast"
-	assign := func(id, r string) {
-		entry, ok := registry.Resolve(id)
-		if !ok {
-			return
-		}
-		if prev, seen := role[entry.ID]; seen && prev != r {
-			t.Fatalf("model %q is declared as both a base and a fast variant", entry.ID)
-		}
-		role[entry.ID] = r
-	}
-	for _, entry := range registry.List(ListOptions{IncludeDeprecated: true}) {
-		if entry.FastVariantID == "" {
-			continue
-		}
-		assign(entry.ID, "base")
-		assign(entry.FastVariantID, "fast")
-	}
-}
-
-// The known pairs must be present and wired in both directions, and neither end
-// may leak into the other role (a base is not itself fast; a fast has no fast).
-func TestFastVariantAndBaseVariant(t *testing.T) {
-	registry := testRegistry(t)
-
-	for base, fast := range expectedFastPairs {
-		// base -> fast (forward), and the fast id has NO fast variant of its own.
-		if got, ok := registry.FastVariant(base); !ok {
-			t.Errorf("FastVariant(%q) = not found, want the fast variant", base)
-		} else if canon, _ := registry.Resolve(fast); got.ID != canon.ID {
-			t.Errorf("FastVariant(%q).ID = %q, want %q", base, got.ID, canon.ID)
-		}
-		if _, ok := registry.FastVariant(fast); ok {
-			t.Errorf("FastVariant(%q) resolved, but a fast model should have no fast variant", fast)
-		}
-
-		// fast -> base (reverse), and the base id is NOT itself a fast variant.
-		if got, ok := registry.BaseVariant(fast); !ok {
-			t.Errorf("BaseVariant(%q) = not found, want the base variant", fast)
-		} else if canon, _ := registry.Resolve(base); got.ID != canon.ID {
-			t.Errorf("BaseVariant(%q).ID = %q, want %q", fast, got.ID, canon.ID)
-		}
-		if _, ok := registry.BaseVariant(base); ok {
-			t.Errorf("BaseVariant(%q) resolved, but a base model is not a fast variant", base)
-		}
-	}
-}
-
-// HasFastVariant is the TUI marker predicate: true only for base models with an
-// available fast variant, false for the fast models themselves, unpaired models,
-// and unknown ids.
-func TestHasFastVariant(t *testing.T) {
-	registry := testRegistry(t)
-	for base, fast := range expectedFastPairs {
-		if !registry.HasFastVariant(base) {
-			t.Errorf("HasFastVariant(%q) = false, want true", base)
-		}
-		if registry.HasFastVariant(fast) {
-			t.Errorf("HasFastVariant(%q) = true, want false (a fast model has no fast variant)", fast)
-		}
-	}
-	for _, id := range []string{"claude-opus-4.1", "definitely-not-a-real-model", ""} {
-		if registry.HasFastVariant(id) {
-			t.Errorf("HasFastVariant(%q) = true, want false", id)
-		}
-	}
-}
-
-func TestFastVariantAbsentAndUnknown(t *testing.T) {
-	registry := testRegistry(t)
-
-	// A real model with no configured fast/base variant reports none in both
-	// directions (a valid, handled case — /fast will say "no fast mode available").
-	const noVariant = "claude-opus-4.1"
-	if _, ok := registry.Resolve(noVariant); !ok {
-		t.Skipf("%q not in registry; skipping no-variant case", noVariant)
-	}
-	if _, ok := registry.FastVariant(noVariant); ok {
-		t.Errorf("FastVariant(%q) resolved, want none", noVariant)
-	}
-	if _, ok := registry.BaseVariant(noVariant); ok {
-		t.Errorf("BaseVariant(%q) resolved, want none", noVariant)
-	}
-
-	// An unknown id resolves to nothing in either direction.
-	if _, ok := registry.FastVariant("definitely-not-a-real-model"); ok {
-		t.Error("FastVariant(unknown) resolved, want none")
-	}
-	if _, ok := registry.BaseVariant("definitely-not-a-real-model"); ok {
-		t.Error("BaseVariant(unknown) resolved, want none")
-	}
-}

internal/providers/anthropic/cache_breakpoints_test.go

@@ -0,0 +1,96 @@
+package anthropic
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/Gitlawb/zero/internal/zeroruntime"
+)
+
+// The final two messages must carry a cache_control breakpoint on their last
+// cacheable block so the conversation transcript — not just system prompt and
+// tools — is a prompt-cache hit on the next turn. Earlier messages must stay
+// unmarked (Anthropic caps breakpoints at 4 per request: system, tools, and
+// these two).
+func TestAnthropicRequestMarksLastTwoMessagesForCaching(t *testing.T) {
+	var gotBody map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if err := json.NewDecoder(r.Body).Decode(&gotBody); err != nil {
+			t.Fatalf("decode request body: %v", err)
+		}
+		writeSSEEvent(w, "message_stop", `{"type":"message_stop"}`)
+	}))
+	defer server.Close()
+
+	provider, err := New(Options{BaseURL: server.URL + "/", Model: "claude-test"})
+	if err != nil {
+		t.Fatalf("New returned error: %v", err)
+	}
+	stream, err := provider.StreamCompletion(context.Background(), zeroruntime.CompletionRequest{
+		Messages: []zeroruntime.Message{
+			{Role: zeroruntime.MessageRoleUser, Content: "first"},
+			{
+				Role:      zeroruntime.MessageRoleAssistant,
+				Content:   "calling a tool",
+				ToolCalls: []zeroruntime.ToolCall{{ID: "toolu_1", Name: "grep", Arguments: `{}`}},
+			},
+			{Role: zeroruntime.MessageRoleTool, Content: "result", ToolCallID: "toolu_1"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("StreamCompletion returned error: %v", err)
+	}
+	drain(stream)
+
+	messages := gotBody["messages"].([]any)
+	if len(messages) != 3 {
+		t.Fatalf("expected 3 wire messages, got %d: %#v", len(messages), messages)
+	}
+	lastBlockHasCache := func(message any) bool {
+		blocks, ok := message.(map[string]any)["content"].([]any)
+		if !ok || len(blocks) == 0 {
+			return false
+		}
+		last := blocks[len(blocks)-1].(map[string]any)
+		control, ok := last["cache_control"].(map[string]any)
+		return ok && control["type"] == "ephemeral"
+	}
+	if lastBlockHasCache(messages[0]) {
+		t.Fatalf("first message must not carry a breakpoint: %#v", messages[0])
+	}
+	if !lastBlockHasCache(messages[1]) {
+		t.Fatalf("second-to-last message must carry a breakpoint: %#v", messages[1])
+	}
+	if !lastBlockHasCache(messages[2]) {
+		t.Fatalf("last message must carry a breakpoint: %#v", messages[2])
+	}
+}
+
+// A string-content message must be converted to a block array so it can carry
+// the breakpoint, and thinking blocks must never carry cache_control (the API
+// rejects them) — the marker goes on the last cacheable block instead.
+func TestApplyMessageCacheBreakpointsSkipsThinkingBlocks(t *testing.T) {
+	messages := []anthropicMessage{
+		{Role: "user", Content: "plain string"},
+		{Role: "assistant", Content: []map[string]any{
+			{"type": "text", "text": "answer"},
+			{"type": "thinking", "thinking": "hmm", "signature": "sig"},
+		}},
+	}
+	applyMessageCacheBreakpoints(messages)
+
+	userBlocks := contentBlocks(messages[0].Content)
+	if len(userBlocks) != 1 || userBlocks[0]["cache_control"] == nil {
+		t.Fatalf("string content must become a marked block: %#v", messages[0].Content)
+	}
+	assistantBlocks := contentBlocks(messages[1].Content)
+	if assistantBlocks[1]["cache_control"] != nil {
+		t.Fatalf("thinking block must not be marked: %#v", assistantBlocks[1])
+	}
+	if assistantBlocks[0]["cache_control"] == nil {
+		t.Fatalf("text block must carry the breakpoint instead: %#v", assistantBlocks[0])
+	}
+}

internal/providers/anthropic/provider.go

@@ -405,9 +405,35 @@ func (provider *Provider) anthropicRequest(request zeroruntime.CompletionRequest
 		}
 		mapped.Tools[len(mapped.Tools)-1].CacheControl = &cacheControl{Type: cacheEphemeral}
 	}
+	applyMessageCacheBreakpoints(mapped.Messages)
 	return mapped, nil
 }
 
+// applyMessageCacheBreakpoints marks the last content block of the final two
+// messages with cache_control so the conversation transcript is cached
+// turn-over-turn, not just the system prompt and tool definitions. Two message
+// breakpoints (not one) keep the previous turn's prefix a cache hit while the
+// newest suffix is being written. Anthropic allows at most 4 breakpoints per
+// request: system + tools use two above, these use the remaining two. Thinking
+// blocks cannot carry cache_control, so the marker goes on the last block that
+// can.
+func applyMessageCacheBreakpoints(messages []anthropicMessage) {
+	marked := 0
+	for i := len(messages) - 1; i >= 0 && marked < 2; i-- {
+		blocks := contentBlocks(messages[i].Content)
+		for j := len(blocks) - 1; j >= 0; j-- {
+			blockType, _ := blocks[j]["type"].(string)
+			if blockType == "thinking" || blockType == "redacted_thinking" {
+				continue
+			}
+			blocks[j]["cache_control"] = map[string]any{"type": cacheEphemeral}
+			messages[i].Content = blocks
+			marked++
+			break
+		}
+	}
+}
+
 func mapMessages(messages []zeroruntime.Message) (string, []anthropicMessage, error) {
 	systemParts := []string{}
 	mapped := []anthropicMessage{}

internal/providers/providerio/retry.go

@@ -23,12 +23,18 @@ import (
 // (billable) work. Only the INITIAL request is ever in scope; once the response
 // body starts streaming it is never re-issued.
 
-const defaultMaxRetryAttempts = 3
+const defaultMaxRetryAttempts = 6
 
 // maxBackoff caps a single backoff wait so a hostile or buggy Retry-After can't
 // stall the agent for minutes.
 const maxBackoff = 30 * time.Second
 
+// retryBackoffBase is the first wait when the server supplied no Retry-After.
+// Rate-limit windows are measured in seconds, not milliseconds: retrying a 429
+// after 400ms almost always burns the attempt while still limited, so the
+// schedule is 2s, 4s, 8s, 16s, then maxBackoff. A var so tests can shrink it.
+var retryBackoffBase = 2 * time.Second
+
 // SendWithRetry issues an HTTP request, retrying ONLY the safe-to-replay server
 // responses (429 and 503, see ShouldRetryStatus) up to maxAttempts — backing off
 // between tries and honoring a server Retry-After header and context
@@ -110,17 +116,11 @@ func ShouldRetryStatus(code int) bool {
 }
 
 // Backoff waits before retry attempt N (1-based), returning false if the context
-// is cancelled during the wait. The wait is attempt*400ms unless the server
-// supplied a (positive) Retry-After, and is capped at maxBackoff.
+// is cancelled during the wait. A server-supplied (positive) Retry-After wins;
+// otherwise the wait doubles from retryBackoffBase per attempt. Either way the
+// wait is capped at maxBackoff.
 func Backoff(ctx context.Context, attempt int, retryAfter time.Duration) bool {
-	wait := time.Duration(attempt) * 400 * time.Millisecond
-	if retryAfter > 0 {
-		wait = retryAfter
-	}
-	if wait > maxBackoff {
-		wait = maxBackoff
-	}
-	timer := time.NewTimer(wait)
+	timer := time.NewTimer(backoffWait(attempt, retryAfter))
 	defer timer.Stop()
 	select {
 	case <-ctx.Done():
@@ -130,6 +130,27 @@ func Backoff(ctx context.Context, attempt int, retryAfter time.Duration) bool {
 	}
 }
 
+// backoffWait computes the wait before retry attempt N (1-based): Retry-After
+// when supplied, else exponential from retryBackoffBase, both capped at
+// maxBackoff. The exponent is clamped so a large attempt count cannot overflow.
+func backoffWait(attempt int, retryAfter time.Duration) time.Duration {
+	wait := retryAfter
+	if wait <= 0 {
+		exponent := attempt - 1
+		if exponent > 5 {
+			exponent = 5
+		}
+		if exponent < 0 {
+			exponent = 0
+		}
+		wait = retryBackoffBase * time.Duration(1<<exponent)
+	}
+	if wait > maxBackoff {
+		wait = maxBackoff
+	}
+	return wait
+}
+
 // RetryAfter parses a response's Retry-After header (delay-seconds or an HTTP
 // date) into a positive duration, or 0 when absent/unparseable. The result is
 // capped at maxBackoff by Backoff.

internal/providers/providerio/retry_test.go

@@ -94,7 +94,40 @@ func TestBackoffWaitsThenReturnsTrue(t *testing.T) {
 	}
 }
 
+// shrinkBackoff makes retry waits negligible for the duration of a test.
+func shrinkBackoff(t *testing.T) {
+	t.Helper()
+	saved := retryBackoffBase
+	retryBackoffBase = time.Millisecond
+	t.Cleanup(func() { retryBackoffBase = saved })
+}
+
+func TestBackoffWaitSchedule(t *testing.T) {
+	// Without Retry-After the wait doubles per attempt from 2s and caps at 30s;
+	// a supplied Retry-After wins but is capped too.
+	cases := []struct {
+		attempt    int
+		retryAfter time.Duration
+		want       time.Duration
+	}{
+		{1, 0, 2 * time.Second},
+		{2, 0, 4 * time.Second},
+		{3, 0, 8 * time.Second},
+		{4, 0, 16 * time.Second},
+		{5, 0, 30 * time.Second},  // 32s capped
+		{50, 0, 30 * time.Second}, // clamped exponent, no overflow
+		{1, 7 * time.Second, 7 * time.Second},
+		{1, 5 * time.Minute, 30 * time.Second}, // hostile Retry-After capped
+	}
+	for _, c := range cases {
+		if got := backoffWait(c.attempt, c.retryAfter); got != c.want {
+			t.Errorf("backoffWait(%d, %v) = %v, want %v", c.attempt, c.retryAfter, got, c.want)
+		}
+	}
+}
+
 func TestSendWithRetryRetriesThenSucceeds(t *testing.T) {
+	shrinkBackoff(t)
 	var hits int32
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if atomic.AddInt32(&hits, 1) == 1 {
@@ -140,6 +173,7 @@ func TestSendWithRetryReturnsNonRetryableImmediately(t *testing.T) {
 }
 
 func TestSendWithRetryReturnsLastResponseAfterMaxAttempts(t *testing.T) {
+	shrinkBackoff(t)
 	var hits int32
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		atomic.AddInt32(&hits, 1)

internal/sandbox/windows_process_windows.go

@@ -87,11 +87,20 @@ func windowsCommandLine(args []string) (string, error) {
 	if len(args) == 0 {
 		return "", errorsNewWindowsProcess("missing command")
 	}
-	out := make([]string, 0, len(args))
 	for _, arg := range args {
 		if strings.ContainsRune(arg, 0) {
 			return "", errorsNewWindowsProcess("command argument contains NUL")
 		}
+	}
+	// Zero's cmd.exe shell invocation needs its final element (the shell
+	// command text) reaching cmd.exe raw, not escaped like a normal argv
+	// element: see WindowsShellCommandLine for why. Every other command this
+	// runner might launch is escaped normally below.
+	if commandLine, ok := windowsShellCommandLineFromArgs(args); ok {
+		return commandLine, nil
+	}
+	out := make([]string, 0, len(args))
+	for _, arg := range args {
 		out = append(out, syscall.EscapeArg(arg))
 	}
 	return strings.Join(out, " "), nil

internal/sandbox/windows_runner.go

@@ -105,6 +105,56 @@ const (
 	WindowsSandboxLevelDisabled   WindowsSandboxLevel = "disabled"
 )
 
+// WindowsShellArgs returns cmd.exe's argv (after the executable name) for
+// running commandText as a shell command on Windows: no wrapping quotes and
+// no /S, so commandText reaches cmd.exe's own /C remainder parsing exactly as
+// written. See WindowsShellCommandLine for why that matters. Used both as
+// CommandSpec.Args for the plain (unwrapped) path and, via
+// windowsShellCommandLineFromArgs, to recognize this same shape once it has
+// round-tripped through the sandboxed runner's CLI argv.
+func WindowsShellArgs(commandText string) []string {
+	return []string{"/d", "/c", commandText}
+}
+
+// WindowsShellCommandLine builds the raw command line a Windows CreateProcess
+// call should receive to run commandText as a shell command: "cmd.exe /d /c "
+// followed by commandText completely unescaped.
+//
+// cmd.exe's own /C remainder parsing is not CommandLineToArgvW-compatible: it
+// applies its own quote-stripping heuristic (documented in `cmd /?`) whenever
+// the remainder starts with a literal quote, and that heuristic does not
+// understand backslash-escaped inner quotes the way a normal argv consumer
+// would. A command like `python -c "print(15 / 3)"` passed through the
+// standard exec.Cmd Args mechanism gets wrapped in an outer pair of quotes
+// (because it contains spaces) with its own quotes escaped as \" — exactly
+// the shape that heuristic corrupts, stripping the outer quotes but leaving
+// the literal backslashes behind. Passing commandText through raw, exactly as
+// the model wrote it, means cmd.exe parses it the same way it would if typed
+// directly at an interactive prompt: a leading quoted executable path like
+// `"C:\Program Files\foo.exe" arg` is preserved correctly by cmd.exe's own
+// quote-preserving special case, and a command with no leading quote at all,
+// like the python example above, is never touched by the stripping heuristic
+// in the first place.
+func WindowsShellCommandLine(commandText string) string {
+	return "cmd.exe /d /c " + commandText
+}
+
+// windowsShellCommandLineFromArgs reports whether args is exactly
+// ["cmd.exe"]+WindowsShellArgs(text) for some text and, if so, returns
+// WindowsShellCommandLine's result for that text. The sandboxed runner path
+// only has the deserialized argv (WindowsSandboxCommandConfig.Command) to
+// work from, not the original commandText, so it recovers the raw command
+// line by recognizing the shape instead.
+func windowsShellCommandLineFromArgs(args []string) (string, bool) {
+	if len(args) != 4 {
+		return "", false
+	}
+	if !strings.EqualFold(args[0], "cmd.exe") || args[1] != "/d" || args[2] != "/c" {
+		return "", false
+	}
+	return WindowsShellCommandLine(args[3]), true
+}
+
 type WindowsSandboxCommandArgsOptions struct {
 	SandboxHome       string
 	CommandCWD        string

internal/sandbox/windows_runner_test.go

@@ -147,3 +147,56 @@ func TestRunWindowsSandboxCommandRunnerRejectsInvalidArgs(t *testing.T) {
 		t.Fatalf("stderr = %q, want runner name", stderr.String())
 	}
 }
+
+func TestWindowsShellArgsHasNoSAndKeepsCommandTextWhole(t *testing.T) {
+	args := WindowsShellArgs(`python -c "print(15 / 3)"`)
+	want := []string{"/d", "/c", `python -c "print(15 / 3)"`}
+	if len(args) != len(want) {
+		t.Fatalf("args = %#v, want %#v", args, want)
+	}
+	for index := range want {
+		if args[index] != want[index] {
+			t.Fatalf("args = %#v, want %#v", args, want)
+		}
+	}
+}
+
+func TestWindowsShellCommandLineLeavesCommandTextUnescaped(t *testing.T) {
+	// The whole point of this function: commandText's own quotes must reach
+	// cmd.exe exactly as written, not re-quoted or backslash-escaped the way
+	// a normal argv-escaping function (like syscall.EscapeArg) would treat an
+	// argument containing spaces and embedded quotes.
+	commandText := `python -c "print(15 / 3)"`
+	got := WindowsShellCommandLine(commandText)
+	want := `cmd.exe /d /c python -c "print(15 / 3)"`
+	if got != want {
+		t.Fatalf("WindowsShellCommandLine = %q, want %q", got, want)
+	}
+}
+
+func TestWindowsShellCommandLineFromArgsRecognizesTheShellShape(t *testing.T) {
+	commandLine, ok := windowsShellCommandLineFromArgs([]string{"cmd.exe", "/d", "/c", `echo "hi"`})
+	if !ok {
+		t.Fatal("windowsShellCommandLineFromArgs did not recognize the shell shape")
+	}
+	if want := `cmd.exe /d /c echo "hi"`; commandLine != want {
+		t.Fatalf("commandLine = %q, want %q", commandLine, want)
+	}
+}
+
+func TestWindowsShellCommandLineFromArgsRejectsOtherShapes(t *testing.T) {
+	cases := [][]string{
+		nil,
+		{"cmd.exe"},
+		{"cmd.exe", "/d", "/c"},
+		{"cmd.exe", "/d", "/c", "echo hi", "extra"},
+		{"git.exe", "/d", "/c", "echo hi"},
+		{"cmd.exe", "/s", "/c", "echo hi"},
+		{"cmd.exe", "/d", "/k", "echo hi"},
+	}
+	for _, args := range cases {
+		if _, ok := windowsShellCommandLineFromArgs(args); ok {
+			t.Fatalf("windowsShellCommandLineFromArgs(%#v) matched, want no match", args)
+		}
+	}
+}

internal/specialist/exec.go

@@ -25,6 +25,7 @@ import (
 const (
 	sessionTagSpecialist     = "specialist"
 	promptFileThresholdBytes = 4 * 1024
+	maxSpecialistDepth       = 8 // hard cap to prevent infinite recursion/resource exhaustion via Task
 )
 
 const SessionTagSpecialist = sessionTagSpecialist
@@ -218,6 +219,13 @@ func (executor Executor) Run(ctx context.Context, params TaskParameters, options
 	if options.CurrentDepth < 0 {
 		return ExecResult{}, fmt.Errorf("current depth cannot be negative")
 	}
+	// >= (not >): this Run call spawns a CHILD at options.CurrentDepth+1, so a
+	// parent already AT the cap must still be rejected here rather than being
+	// allowed to launch one more level before the child's own next call trips
+	// the guard.
+	if options.CurrentDepth >= maxSpecialistDepth {
+		return ExecResult{}, fmt.Errorf("spawning a specialist at depth %d would exceed maximum nesting depth %d", options.CurrentDepth+1, maxSpecialistDepth)
+	}
 	if strings.TrimSpace(params.Prompt) == "" {
 		return ExecResult{}, fmt.Errorf("specialist prompt is required")
 	}

internal/specialist/exec_test.go

@@ -1,6 +1,7 @@
 package specialist
 
 import (
+	"context"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -336,6 +337,39 @@ func TestBuildArgsRejectsInvalidInputs(t *testing.T) {
 	}
 }
 
+func TestRunRejectsDepthExceedingMax(t *testing.T) {
+	_, err := (Executor{}).Run(context.Background(), TaskParameters{
+		Prompt: "hi",
+	}, TaskRunOptions{CurrentDepth: maxSpecialistDepth + 1})
+	if err == nil || !strings.Contains(err.Error(), "depth") {
+		t.Fatalf("Run error = %v, want depth error", err)
+	}
+}
+
+// TestRunRejectsDepthAtMax covers the boundary: a parent already AT the cap
+// must be rejected too, since this Run call would launch a child one level
+// past it (--depth CurrentDepth+1). Only checking ">" here would let that
+// child start before the guard ever caught it. The guard sits before the
+// fresh/resume branch in Run, so both call shapes must be proven to reject
+// here rather than falling through to runFresh/runResume.
+func TestRunRejectsDepthAtMax(t *testing.T) {
+	tests := []struct {
+		name   string
+		params TaskParameters
+	}{
+		{name: "fresh", params: TaskParameters{Prompt: "hi"}},
+		{name: "resume", params: TaskParameters{Prompt: "hi", Resume: "child_session"}},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := (Executor{}).Run(context.Background(), tc.params, TaskRunOptions{CurrentDepth: maxSpecialistDepth})
+			if err == nil || !strings.Contains(err.Error(), "depth") {
+				t.Fatalf("Run error = %v, want depth error", err)
+			}
+		})
+	}
+}
+
 func TestBuildArgsRejectsInvalidSessionIDs(t *testing.T) {
 	_, err := (Executor{NewSessionID: func() (string, error) { return "../escape", nil }}).BuildArgs(BuildArgsInput{
 		Prompt: "hi",

internal/tools/bash.go

@@ -120,7 +120,6 @@ func (tool bashTool) run(ctx context.Context, args map[string]any, engine *zeroS
 			Meta:   meta,
 		}
 	}
-	// Release any plan-scoped resources once the command has finished running.
 	defer plan.Cleanup()
 	addSandboxMeta(meta, plan)
 
@@ -221,6 +220,14 @@ func shellIssueBlockResult(issue shellIssue) Result {
 	}
 }
 
+// buildBashCommand returns the exec.Cmd and the sandbox plan for running
+// commandText. On Windows, when the command is not wrapped by the sandbox
+// engine (plan.Wrapped == false), it also overrides the child's raw command
+// line so commandText reaches cmd.exe unescaped; see
+// zeroSandbox.WindowsShellCommandLine for why that matters. The wrapped case
+// gets the same treatment inside the sandboxed runner process itself
+// (internal/sandbox/windows_process_windows.go), since that command line is
+// built there, not here.
 func buildBashCommand(ctx context.Context, commandText string, absoluteCwd string, engine *zeroSandbox.Engine) (*exec.Cmd, zeroSandbox.CommandPlan, error) {
 	spec := zeroSandbox.CommandSpec{
 		Name: shellExecutable(),
@@ -228,7 +235,11 @@ func buildBashCommand(ctx context.Context, commandText string, absoluteCwd strin
 		Dir:  absoluteCwd,
 	}
 	if engine != nil {
-		return engine.CommandContext(ctx, spec)
+		command, plan, err := engine.CommandContext(ctx, spec)
+		if err == nil {
+			applyWindowsShellCommandLine(command, commandText, plan.Wrapped)
+		}
+		return command, plan, err
 	}
 	plan := zeroSandbox.CommandPlan{
 		Backend: zeroSandbox.Backend{
@@ -242,6 +253,7 @@ func buildBashCommand(ctx context.Context, commandText string, absoluteCwd strin
 	}
 	command := exec.CommandContext(ctx, spec.Name, spec.Args...)
 	command.Dir = spec.Dir
+	applyWindowsShellCommandLine(command, commandText, plan.Wrapped)
 	return command, plan, nil
 }
 
@@ -302,7 +314,7 @@ func shellExecutable() string {
 
 func shellArguments(command string) []string {
 	if runtime.GOOS == "windows" {
-		return []string{"/d", "/s", "/c", command}
+		return zeroSandbox.WindowsShellArgs(command)
 	}
 	return []string{"-c", command}
 }
@@ -342,7 +354,12 @@ func formatBashOutput(stdout string, stderr string, exitCode int) string {
 	if len(parts) == 0 {
 		return "Command completed with no output."
 	}
-	return strings.Join(parts, "\n")
+	// Cap the context cost of a verbose command at the same default budget as
+	// exec_command (head/tail window); the full output is spilled to disk and
+	// referenced in the truncation notice, so nothing is lost. Previously bash
+	// output was unbounded — one chatty build log could flood the context.
+	output, _ := truncateExecOutputSpill(strings.Join(parts, "\n"), defaultMaxOutputTokens, "bash")
+	return output
 }
 
 func formatBashOutputWithShellHint(command string, stdout string, stderr string, exitCode int, meta map[string]string) string {

internal/tools/bash_proc_unix.go

@@ -42,3 +42,7 @@ func hardenProcessLifetime(command *exec.Cmd) {
 		return nil
 	}
 }
+
+// applyWindowsShellCommandLine is a no-op outside Windows; there is no
+// cmd.exe command-line-parsing quirk to work around here.
+func applyWindowsShellCommandLine(command *exec.Cmd, commandText string, wrapped bool) {}

internal/tools/bash_proc_windows.go

@@ -5,7 +5,10 @@ package tools
 import (
 	"os/exec"
 	"strconv"
+	"syscall"
 	"time"
+
+	zeroSandbox "github.com/Gitlawb/zero/internal/sandbox"
 )
 
 // bashWaitDelay bounds how long Wait blocks for the I/O pipes to drain after the
@@ -28,3 +31,17 @@ func hardenProcessLifetime(command *exec.Cmd) {
 		return nil
 	}
 }
+
+// applyWindowsShellCommandLine overrides command's raw child command line so
+// commandText reaches cmd.exe unescaped instead of auto-quoted the way
+// exec.Cmd would normally encode a single Args element. Skipped when wrapped
+// is true: the sandbox engine then routes execution through a separate
+// zero-windows-command-runner process, which builds its own child command
+// line from scratch (internal/sandbox/windows_process_windows.go) rather than
+// inheriting whatever this outer exec.Cmd is configured with.
+func applyWindowsShellCommandLine(command *exec.Cmd, commandText string, wrapped bool) {
+	if wrapped {
+		return
+	}
+	command.SysProcAttr = &syscall.SysProcAttr{CmdLine: zeroSandbox.WindowsShellCommandLine(commandText)}
+}

internal/tools/bash_tool_test.go

@@ -17,6 +17,18 @@ import (
 
 func TestMain(m *testing.M) {
 	if len(os.Args) >= 3 && os.Args[1] == "--zero-bash-helper" {
+		if os.Args[2] == "echo-arg" {
+			// Echoes back exactly the one argument it received, to verify a
+			// quoted, space-and-slash-containing argument (the same shape as
+			// `python -c "print(15 / 3)"`) survives the shell invocation
+			// intact instead of being truncated/corrupted.
+			if len(os.Args) < 4 {
+				fmt.Fprintln(os.Stderr, "echo-arg requires exactly one argument")
+				os.Exit(1)
+			}
+			fmt.Println(os.Args[3])
+			return
+		}
 		runBashToolHelper(os.Args[2])
 		return
 	}
@@ -535,6 +547,68 @@ func TestBashToolAllowsNonInteractiveCommand(t *testing.T) {
 	}
 }
 
+// TestBashToolPreservesEmbeddedQuotesOnWindows pins a real, previously-broken
+// case: passing commandText as a normal exec.Cmd argument makes Go wrap it in
+// an outer pair of quotes (it contains spaces) with its own quotes escaped as
+// \", and cmd.exe's /C remainder parsing strips the first and last literal
+// quote character in that remainder without undoing the backslash-escaping -
+// corrupting a command whose own text contains embedded double quotes,
+// exactly the shape of `python -c "print(15 / 3)"`, `git commit -m
+// "message"`, `node -e "..."`. Before the fix, the helper below received a
+// truncated, mis-quoted argument (starting with a stray literal `"`) instead
+// of the text between the quotes.
+func TestBashToolPreservesEmbeddedQuotesOnWindows(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("cmd.exe /S/C quote-remainder parsing is Windows-specific")
+	}
+	root := t.TempDir()
+	executable := shellQuote(os.Args[0])
+	// Space and a slash: the two characters whose position in the original
+	// bug report's SyntaxError ("print(15, truncated right before the /")
+	// showed exactly where the corruption happened.
+	commandText := executable + ` --zero-bash-helper echo-arg "hello / world"`
+
+	result := NewBashTool(root).Run(context.Background(), map[string]any{
+		"command": commandText,
+	})
+
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok status, got %s: %s", result.Status, result.Output)
+	}
+	if !strings.Contains(result.Output, "hello / world") {
+		t.Fatalf("expected the embedded-quote argument to survive intact, got %q", result.Output)
+	}
+}
+
+// TestBashToolRunsCommandLineForLoopSyntax pins cmd.exe command-line syntax,
+// not batch-file syntax: a `for %i in (...) do ...` loop with a single
+// percent sign is valid typed directly at a cmd.exe prompt (or via
+// `cmd /C "..."`), but requires %%i inside an actual .bat/.cmd FILE, because
+// batch files perform an extra pass of percent-substitution before FOR ever
+// runs, consuming the single percent so the loop variable never binds. An
+// earlier version of this fix ran commandText from a temporary .cmd file
+// instead of passing it straight through to cmd.exe's /C remainder, which
+// silently broke single-percent syntax like this.
+func TestBashToolRunsCommandLineForLoopSyntax(t *testing.T) {
+	if runtime.GOOS != "windows" {
+		t.Skip("cmd.exe command-line vs batch-file parsing is Windows-specific")
+	}
+	root := t.TempDir()
+
+	result := NewBashTool(root).Run(context.Background(), map[string]any{
+		"command": "for %i in (1 2 3) do echo %i",
+	})
+
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok status, got %s: %s", result.Status, result.Output)
+	}
+	for _, want := range []string{"1", "2", "3"} {
+		if !strings.Contains(result.Output, want) {
+			t.Fatalf("expected the for-loop to expand %%i to %q, got %q", want, result.Output)
+		}
+	}
+}
+
 func helperCommand(name string) string {
 	executable := shellQuote(os.Args[0])
 	return executable + " --zero-bash-helper " + name

internal/tools/edit_file.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -44,7 +45,7 @@ func (tool editFileTool) Run(ctx context.Context, args map[string]any) Result {
 	return tool.RunWithOptions(ctx, args, RunOptions{})
 }
 
-func (tool editFileTool) RunWithOptions(_ context.Context, args map[string]any, options RunOptions) Result {
+func (tool editFileTool) RunWithOptions(ctx context.Context, args map[string]any, options RunOptions) Result {
 	requestedPath, err := aliasedStringArg(args, []string{"path", "file", "file_path", "filename"}, "", true, false)
 	if err != nil {
 		return errorResult("Error: Invalid arguments for edit_file: " + err.Error())
@@ -98,6 +99,32 @@ func (tool editFileTool) RunWithOptions(_ context.Context, args map[string]any,
 		}
 	}
 
+	// Fuzzy fallback: when the exact string (and its CRLF translation) is absent,
+	// run a cascade of tolerant matchers (trimmed lines, block anchors, collapsed
+	// whitespace, indentation drift, escape normalization) to locate the span the
+	// model intended. Only a span that occurs literally in the file is accepted,
+	// so the replacement applied below is still exact.
+	if occurrences == 0 {
+		findOld, findNew := oldString, newString
+		if strings.Contains(content, "\r\n") && !strings.Contains(findOld, "\r\n") {
+			findOld = strings.ReplaceAll(findOld, "\n", "\r\n")
+			findNew = strings.ReplaceAll(findNew, "\n", "\r\n")
+		}
+		search, ferr := fuzzyEditMatch(content, findOld, replaceAll)
+		switch {
+		case ferr == nil:
+			oldString = search
+			newString = findNew
+			occurrences = strings.Count(content, search)
+		case errors.Is(ferr, errEditFuzzyAmbiguous):
+			return errorResult("Error: old_string matches multiple locations in " + relativePath + " even after fuzzy matching. Provide more surrounding context to make the match unique, or pass replace_all: true.")
+		case errors.Is(ferr, errEditFuzzyNotFound):
+			// Fall through to the exact-match error below.
+		default:
+			return errorResult("Error editing " + relativePath + ": " + ferr.Error())
+		}
+	}
+
 	if occurrences == 0 {
 		return errorResult("Error: Could not find the exact string to replace in " + relativePath + ". The old_string must match the file byte-for-byte.")
 	}
@@ -120,6 +147,10 @@ func (tool editFileTool) RunWithOptions(_ context.Context, args map[string]any,
 	if err := os.WriteFile(absolutePath, []byte(updated), 0o644); err != nil {
 		return errorResult("Error writing " + relativePath + ": " + err.Error())
 	}
+	// Optional format-on-write (ZERO_FORMAT_ON_WRITE). Must run BEFORE the
+	// FileTracker re-baseline: recording pre-format content would make the very
+	// next edit look like an external modification and trip the conflict guard.
+	updated = maybeFormatWrittenFile(ctx, absolutePath, updated)
 	// Re-baseline to the content we just wrote so subsequent edits in this session
 	// compare against the current on-disk state, not the pre-edit version.
 	newInfo, _ := os.Stat(absolutePath)
@@ -130,6 +161,7 @@ func (tool editFileTool) RunWithOptions(_ context.Context, args map[string]any,
 		suffix = "s"
 	}
 	summary := fmt.Sprintf("Successfully edited %s (replaced %d occurrence%s).", relativePath, replacedCount, suffix)
+	summary += inlineDiagnostics(ctx, options, absolutePath, relativePath)
 	result := okResult(summary)
 	result.ChangedFiles = []string{relativePath}
 	// Card-only preview (Display.Preview): the model's Output stays the one-line

internal/tools/edit_replacers.go

@@ -0,0 +1,457 @@
+package tools
+
+// Fuzzy fallback matching for edit_file. When the model's old_string fails to
+// match byte-for-byte (drifted indentation, collapsed whitespace, escaped
+// characters, a slightly-misremembered middle line), these replacers propose
+// candidate spans that plausibly correspond to what the model intended. Only a
+// candidate that occurs literally in the file is accepted, so the replacement
+// itself is always exact even when the match was tolerant.
+//
+// Strategy cascade ported from opencode's edit tool, whose replacers were in
+// turn distilled from Cline's diff-apply evals and gemini-cli's edit corrector.
+
+import (
+	"errors"
+	"regexp"
+	"strings"
+)
+
+// editReplacer proposes candidate spans for find inside content. Candidates
+// are re-validated by fuzzyEditMatch before use.
+type editReplacer func(content, find string) []string
+
+var (
+	errEditFuzzyNotFound  = errors.New("no fuzzy match for old_string")
+	errEditFuzzyAmbiguous = errors.New("fuzzy match for old_string is ambiguous")
+)
+
+// Minimum average middle-line similarity for block-anchor matches.
+const editAnchorSimilarityThreshold = 0.65
+
+// fuzzyEditMatch runs the replacer cascade and returns the exact span of
+// content to replace. When replaceAll is false the span must be unique in
+// content; an ambiguous candidate is skipped in favor of later candidates and
+// only reported if nothing unique is found. A span wildly larger than
+// old_string is refused outright rather than risking a destructive edit.
+func fuzzyEditMatch(content, find string, replaceAll bool) (string, error) {
+	replacers := []editReplacer{
+		lineTrimmedReplacer,
+		blockAnchorReplacer,
+		whitespaceNormalizedReplacer,
+		indentationFlexibleReplacer,
+		escapeNormalizedReplacer,
+		trimmedBoundaryReplacer,
+		contextAwareReplacer,
+	}
+	found := false
+	for _, replacer := range replacers {
+		for _, search := range replacer(content, find) {
+			if search == "" {
+				continue
+			}
+			index := strings.Index(content, search)
+			if index < 0 {
+				continue
+			}
+			found = true
+			if isDisproportionateEditMatch(search, find) {
+				return "", errors.New("refusing replacement because the matched span is much larger than old_string; re-read the file and provide the full exact old_string for the intended replacement")
+			}
+			if replaceAll {
+				return search, nil
+			}
+			if strings.LastIndex(content, search) != index {
+				continue
+			}
+			return search, nil
+		}
+	}
+	if !found {
+		return "", errEditFuzzyNotFound
+	}
+	return "", errEditFuzzyAmbiguous
+}
+
+// isDisproportionateEditMatch guards against anchor-style replacers matching a
+// span far larger than the text the model asked to replace (e.g. first/last
+// line anchors bridging hundreds of unrelated lines).
+func isDisproportionateEditMatch(search, find string) bool {
+	findLines := strings.Count(find, "\n") + 1
+	searchLines := strings.Count(search, "\n") + 1
+	limit := findLines + 3
+	if findLines*2 > limit {
+		limit = findLines * 2
+	}
+	if searchLines >= limit {
+		return true
+	}
+	if findLines == 1 {
+		return false
+	}
+	searchTrimmed := len(strings.TrimSpace(search))
+	findTrimmed := len(strings.TrimSpace(find))
+	byteLimit := findTrimmed + 500
+	if findTrimmed*4 > byteLimit {
+		byteLimit = findTrimmed * 4
+	}
+	return searchTrimmed > byteLimit
+}
+
+// splitFindLines splits find into lines, dropping the trailing empty line a
+// trailing newline produces so windows align with real content lines.
+func splitFindLines(find string) []string {
+	lines := strings.Split(find, "\n")
+	if len(lines) > 0 && lines[len(lines)-1] == "" {
+		lines = lines[:len(lines)-1]
+	}
+	return lines
+}
+
+// lineTrimmedReplacer matches when every line equals the corresponding
+// old_string line after trimming surrounding whitespace.
+func lineTrimmedReplacer(content, find string) []string {
+	contentLines := strings.Split(content, "\n")
+	findLines := splitFindLines(find)
+	if len(findLines) == 0 {
+		return nil
+	}
+	var candidates []string
+	for i := 0; i+len(findLines) <= len(contentLines); i++ {
+		matches := true
+		for j := range findLines {
+			if strings.TrimSpace(contentLines[i+j]) != strings.TrimSpace(findLines[j]) {
+				matches = false
+				break
+			}
+		}
+		if matches {
+			candidates = append(candidates, strings.Join(contentLines[i:i+len(findLines)], "\n"))
+		}
+	}
+	return candidates
+}
+
+// blockAnchorReplacer anchors on the first and last lines (trimmed) and
+// accepts the block when the middle lines average >= the similarity threshold
+// (Levenshtein-based), tolerating a slightly misremembered interior.
+func blockAnchorReplacer(content, find string) []string {
+	findLines := splitFindLines(find)
+	if len(findLines) < 3 {
+		return nil
+	}
+	contentLines := strings.Split(content, "\n")
+	firstAnchor := strings.TrimSpace(findLines[0])
+	lastAnchor := strings.TrimSpace(findLines[len(findLines)-1])
+	searchBlockSize := len(findLines)
+	maxLineDelta := searchBlockSize / 4
+	if maxLineDelta < 1 {
+		maxLineDelta = 1
+	}
+
+	type span struct{ start, end int }
+	var candidates []span
+	for i := 0; i < len(contentLines); i++ {
+		if strings.TrimSpace(contentLines[i]) != firstAnchor {
+			continue
+		}
+		// Only the first occurrence of the last anchor after this start counts,
+		// mirroring the reference implementation: a farther-away closing line is
+		// assumed to close a different block.
+		for j := i + 2; j < len(contentLines); j++ {
+			if strings.TrimSpace(contentLines[j]) != lastAnchor {
+				continue
+			}
+			actualBlockSize := j - i + 1
+			delta := actualBlockSize - searchBlockSize
+			if delta < 0 {
+				delta = -delta
+			}
+			if delta <= maxLineDelta {
+				candidates = append(candidates, span{start: i, end: j})
+			}
+			break
+		}
+	}
+	if len(candidates) == 0 {
+		return nil
+	}
+
+	middleSimilarity := func(candidate span) float64 {
+		actualBlockSize := candidate.end - candidate.start + 1
+		linesToCheck := searchBlockSize - 2
+		if actualBlockSize-2 < linesToCheck {
+			linesToCheck = actualBlockSize - 2
+		}
+		if linesToCheck <= 0 {
+			return 1.0
+		}
+		similarity := 0.0
+		for j := 1; j < searchBlockSize-1 && j < actualBlockSize-1; j++ {
+			contentLine := strings.TrimSpace(contentLines[candidate.start+j])
+			findLine := strings.TrimSpace(findLines[j])
+			maxLen := len(contentLine)
+			if len(findLine) > maxLen {
+				maxLen = len(findLine)
+			}
+			if maxLen == 0 {
+				continue
+			}
+			distance := levenshtein(contentLine, findLine)
+			similarity += 1 - float64(distance)/float64(maxLen)
+		}
+		return similarity / float64(linesToCheck)
+	}
+
+	best := candidates[0]
+	if len(candidates) > 1 {
+		bestSimilarity := -1.0
+		for _, candidate := range candidates {
+			if s := middleSimilarity(candidate); s > bestSimilarity {
+				bestSimilarity = s
+				best = candidate
+			}
+		}
+		if bestSimilarity < editAnchorSimilarityThreshold {
+			return nil
+		}
+	} else if middleSimilarity(best) < editAnchorSimilarityThreshold {
+		return nil
+	}
+	return []string{strings.Join(contentLines[best.start:best.end+1], "\n")}
+}
+
+var editWhitespaceRun = regexp.MustCompile(`\s+`)
+
+func normalizeEditWhitespace(text string) string {
+	return strings.TrimSpace(editWhitespaceRun.ReplaceAllString(text, " "))
+}
+
+// whitespaceNormalizedReplacer matches after collapsing all whitespace runs to
+// a single space: full lines, sub-line spans (via a word-boundary regex), and
+// multi-line windows.
+func whitespaceNormalizedReplacer(content, find string) []string {
+	normalizedFind := normalizeEditWhitespace(find)
+	if normalizedFind == "" {
+		return nil
+	}
+	contentLines := strings.Split(content, "\n")
+	var candidates []string
+	var subLinePattern *regexp.Regexp
+	for _, line := range contentLines {
+		normalizedLine := normalizeEditWhitespace(line)
+		if normalizedLine == normalizedFind {
+			candidates = append(candidates, line)
+			continue
+		}
+		if !strings.Contains(normalizedLine, normalizedFind) {
+			continue
+		}
+		if subLinePattern == nil {
+			words := strings.Fields(find)
+			quoted := make([]string, len(words))
+			for i, word := range words {
+				quoted[i] = regexp.QuoteMeta(word)
+			}
+			pattern, err := regexp.Compile(strings.Join(quoted, `\s+`))
+			if err != nil {
+				continue
+			}
+			subLinePattern = pattern
+		}
+		if match := subLinePattern.FindString(line); match != "" {
+			candidates = append(candidates, match)
+		}
+	}
+
+	findLines := strings.Split(find, "\n")
+	if len(findLines) > 1 {
+		for i := 0; i+len(findLines) <= len(contentLines); i++ {
+			block := strings.Join(contentLines[i:i+len(findLines)], "\n")
+			if normalizeEditWhitespace(block) == normalizedFind {
+				candidates = append(candidates, block)
+			}
+		}
+	}
+	return candidates
+}
+
+// stripCommonIndentation removes the minimum leading-whitespace width shared
+// by all non-empty lines, so blocks match regardless of their nesting depth.
+func stripCommonIndentation(text string) string {
+	lines := strings.Split(text, "\n")
+	minIndent := -1
+	for _, line := range lines {
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		indent := len(line) - len(strings.TrimLeft(line, " \t"))
+		if minIndent < 0 || indent < minIndent {
+			minIndent = indent
+		}
+	}
+	if minIndent <= 0 {
+		return text
+	}
+	stripped := make([]string, len(lines))
+	for i, line := range lines {
+		if strings.TrimSpace(line) == "" {
+			stripped[i] = line
+			continue
+		}
+		stripped[i] = line[minIndent:]
+	}
+	return strings.Join(stripped, "\n")
+}
+
+func indentationFlexibleReplacer(content, find string) []string {
+	normalizedFind := stripCommonIndentation(find)
+	contentLines := strings.Split(content, "\n")
+	findLines := strings.Split(find, "\n")
+	var candidates []string
+	for i := 0; i+len(findLines) <= len(contentLines); i++ {
+		block := strings.Join(contentLines[i:i+len(findLines)], "\n")
+		if stripCommonIndentation(block) == normalizedFind {
+			candidates = append(candidates, block)
+		}
+	}
+	return candidates
+}
+
+var editEscapeSequence = regexp.MustCompile("\\\\(n|t|r|'|\"|`|\\\\|\\n|\\$)")
+
+// unescapeEditString undoes one level of string escaping (\n, \t, \", \\, a
+// backslash-newline continuation, \$) — the model sometimes reproduces file
+// content as it appeared inside a quoted string literal.
+func unescapeEditString(text string) string {
+	return editEscapeSequence.ReplaceAllStringFunc(text, func(match string) string {
+		switch match[1:] {
+		case "n":
+			return "\n"
+		case "t":
+			return "\t"
+		case "r":
+			return "\r"
+		case "\n":
+			return "\n"
+		default:
+			// ', ", `, \, $ all unescape to themselves.
+			return match[1:]
+		}
+	})
+}
+
+func escapeNormalizedReplacer(content, find string) []string {
+	unescapedFind := unescapeEditString(find)
+	var candidates []string
+	if strings.Contains(content, unescapedFind) {
+		candidates = append(candidates, unescapedFind)
+	}
+	contentLines := strings.Split(content, "\n")
+	findLines := strings.Split(unescapedFind, "\n")
+	for i := 0; i+len(findLines) <= len(contentLines); i++ {
+		block := strings.Join(contentLines[i:i+len(findLines)], "\n")
+		if unescapeEditString(block) == unescapedFind {
+			candidates = append(candidates, block)
+		}
+	}
+	return candidates
+}
+
+// trimmedBoundaryReplacer tolerates stray leading/trailing whitespace (often
+// blank lines) around an otherwise-exact old_string.
+func trimmedBoundaryReplacer(content, find string) []string {
+	trimmedFind := strings.TrimSpace(find)
+	if trimmedFind == find || trimmedFind == "" {
+		return nil
+	}
+	var candidates []string
+	if strings.Contains(content, trimmedFind) {
+		candidates = append(candidates, trimmedFind)
+	}
+	contentLines := strings.Split(content, "\n")
+	findLines := strings.Split(find, "\n")
+	for i := 0; i+len(findLines) <= len(contentLines); i++ {
+		block := strings.Join(contentLines[i:i+len(findLines)], "\n")
+		if strings.TrimSpace(block) == trimmedFind {
+			candidates = append(candidates, block)
+		}
+	}
+	return candidates
+}
+
+// contextAwareReplacer anchors on the first and last lines and accepts an
+// equal-length block when at least half of its non-empty middle lines match
+// after trimming — a cheaper, stricter cousin of blockAnchorReplacer.
+func contextAwareReplacer(content, find string) []string {
+	findLines := splitFindLines(find)
+	if len(findLines) < 3 {
+		return nil
+	}
+	contentLines := strings.Split(content, "\n")
+	firstAnchor := strings.TrimSpace(findLines[0])
+	lastAnchor := strings.TrimSpace(findLines[len(findLines)-1])
+	var candidates []string
+	for i := 0; i < len(contentLines); i++ {
+		if strings.TrimSpace(contentLines[i]) != firstAnchor {
+			continue
+		}
+		for j := i + 2; j < len(contentLines); j++ {
+			if strings.TrimSpace(contentLines[j]) != lastAnchor {
+				continue
+			}
+			if j-i+1 == len(findLines) {
+				matching, nonEmpty := 0, 0
+				for k := 1; k < len(findLines)-1; k++ {
+					blockLine := strings.TrimSpace(contentLines[i+k])
+					findLine := strings.TrimSpace(findLines[k])
+					if blockLine == "" && findLine == "" {
+						continue
+					}
+					nonEmpty++
+					if blockLine == findLine {
+						matching++
+					}
+				}
+				if nonEmpty == 0 || float64(matching)/float64(nonEmpty) >= 0.5 {
+					candidates = append(candidates, strings.Join(contentLines[i:j+1], "\n"))
+				}
+			}
+			break
+		}
+	}
+	return candidates
+}
+
+// levenshtein computes edit distance with a two-row rolling matrix.
+func levenshtein(a, b string) int {
+	if a == "" {
+		return len(b)
+	}
+	if b == "" {
+		return len(a)
+	}
+	previous := make([]int, len(b)+1)
+	current := make([]int, len(b)+1)
+	for j := range previous {
+		previous[j] = j
+	}
+	for i := 1; i <= len(a); i++ {
+		current[0] = i
+		for j := 1; j <= len(b); j++ {
+			cost := 1
+			if a[i-1] == b[j-1] {
+				cost = 0
+			}
+			minimum := previous[j] + 1
+			if current[j-1]+1 < minimum {
+				minimum = current[j-1] + 1
+			}
+			if previous[j-1]+cost < minimum {
+				minimum = previous[j-1] + cost
+			}
+			current[j] = minimum
+		}
+		previous, current = current, previous
+	}
+	return previous[len(b)]
+}

internal/tools/edit_replacers_test.go

@@ -0,0 +1,264 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func runEdit(t *testing.T, dir, initial string, args map[string]any) (Result, string) {
+	t.Helper()
+	path := filepath.Join(dir, "target.txt")
+	if err := os.WriteFile(path, []byte(initial), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if args["path"] == nil {
+		args["path"] = "target.txt"
+	}
+	result := NewEditFileTool(dir).Run(context.Background(), args)
+	after, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return result, string(after)
+}
+
+func TestEditExactMatchStillPreferred(t *testing.T) {
+	// The fast path must keep byte-exact semantics: an exact match wins even
+	// when fuzzy strategies would also find candidates elsewhere.
+	result, after := runEdit(t, t.TempDir(), "alpha\nbeta\ngamma\n", map[string]any{
+		"old_string": "beta",
+		"new_string": "delta",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if after != "alpha\ndelta\ngamma\n" {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyLineTrimmed(t *testing.T) {
+	// Model reproduced the lines without the file's leading indentation; the
+	// line-trimmed strategy must find the real indented span and preserve the
+	// file's own indentation on the replaced region boundary.
+	initial := "func a() {\n\tx := 1\n\treturn x\n}\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": "x := 1\nreturn x",
+		"new_string": "\ty := 2\n\treturn y",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, "\ty := 2\n\treturn y\n}") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+	if strings.Contains(after, "x := 1") {
+		t.Fatalf("old span survived: %q", after)
+	}
+}
+
+func TestEditFuzzyWhitespaceNormalizedSingleLine(t *testing.T) {
+	// Whitespace runs collapsed: "x  :=   1" in the file, single spaces from
+	// the model.
+	initial := "start\nx  :=   1\nend\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": "x := 1",
+		"new_string": "x := 2",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, "x := 2") || strings.Contains(after, ":=   1") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyBlockAnchorToleratesMiddleDrift(t *testing.T) {
+	// First and last lines anchor the block; one interior line differs slightly
+	// (comment text drifted). Levenshtein similarity keeps it above 0.65.
+	initial := strings.Join([]string{
+		"func handler(w http.ResponseWriter, r *http.Request) {",
+		"\t// write the response body to the client",
+		"\tw.WriteHeader(http.StatusOK)",
+		"\tfmt.Fprint(w, \"done\")",
+		"}",
+		"",
+	}, "\n")
+	find := strings.Join([]string{
+		"func handler(w http.ResponseWriter, r *http.Request) {",
+		"\t// write the response body to client",
+		"\tw.WriteHeader(http.StatusOK)",
+		"\tfmt.Fprint(w, \"done\")",
+		"}",
+	}, "\n")
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": find,
+		"new_string": "func handler(w http.ResponseWriter, r *http.Request) {\n\tw.WriteHeader(http.StatusNoContent)\n}",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, "StatusNoContent") || strings.Contains(after, "StatusOK") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyIndentationFlexible(t *testing.T) {
+	// The whole block sits one nesting level deeper in the file than in the
+	// model's old_string, with interior relative indentation preserved.
+	initial := "if ok {\n\t\tfor i := range xs {\n\t\t\tsum += xs[i]\n\t\t}\n}\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": "for i := range xs {\n\tsum += xs[i]\n}",
+		"new_string": "\t\tsum += total(xs)",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, "total(xs)") || strings.Contains(after, "range xs") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyEscapeNormalized(t *testing.T) {
+	// Model reproduced the line as it would appear inside a quoted string
+	// literal, with escaped quotes.
+	initial := "console.log(\"hello world\")\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": `console.log(\"hello world\")`,
+		"new_string": `console.log("goodbye")`,
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, `console.log("goodbye")`) {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyTrimmedBoundary(t *testing.T) {
+	// Stray whitespace around an otherwise-exact old_string; "  two  " is not a
+	// substring of the file, so only the fuzzy cascade can resolve it.
+	initial := "one\ntwo\nthree\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": "  two  ",
+		"new_string": "2",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if after != "one\n2\nthree\n" {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestTrimmedBoundaryReplacerYieldsTrimmedSpan(t *testing.T) {
+	candidates := trimmedBoundaryReplacer("one\ntwo\nthree\n", "\ntwo\n")
+	if len(candidates) == 0 || candidates[0] != "two" {
+		t.Fatalf("expected trimmed candidate \"two\", got %v", candidates)
+	}
+	if trimmedBoundaryReplacer("anything", "already-trimmed") != nil {
+		t.Fatal("already-trimmed find must yield no candidates")
+	}
+}
+
+// Two identical blocks that only match old_string after indentation-tolerant
+// matching: exact search finds nothing, fuzzy finds both.
+const ambiguousBlocks = "\tif x {\n\t\tgo()\n\t}\nmid\n\tif x {\n\t\tgo()\n\t}\n"
+
+func TestEditFuzzyAmbiguousReportsError(t *testing.T) {
+	// No strategy can disambiguate identical blocks, so the tool must refuse
+	// rather than guess, and the file must be untouched.
+	result, after := runEdit(t, t.TempDir(), ambiguousBlocks, map[string]any{
+		"old_string": "if x {\n\tgo()\n}",
+		"new_string": "stop()",
+	})
+	if result.Status != StatusError || !strings.Contains(result.Output, "multiple locations") {
+		t.Fatalf("expected ambiguity error, got %q", result.Output)
+	}
+	if after != ambiguousBlocks {
+		t.Fatalf("file must be unchanged, got %q", after)
+	}
+}
+
+func TestEditFuzzyReplaceAll(t *testing.T) {
+	// replace_all applies the fuzzy-resolved span at every occurrence.
+	result, after := runEdit(t, t.TempDir(), ambiguousBlocks, map[string]any{
+		"old_string":  "if x {\n\tgo()\n}",
+		"new_string":  "stop()",
+		"replace_all": true,
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if strings.Count(after, "stop()") != 2 || strings.Contains(after, "go()") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestEditFuzzyNotFoundKeepsExactError(t *testing.T) {
+	result, after := runEdit(t, t.TempDir(), "alpha\n", map[string]any{
+		"old_string": "omega",
+		"new_string": "x",
+	})
+	if result.Status != StatusError || !strings.Contains(result.Output, "Could not find the exact string") {
+		t.Fatalf("expected not-found error, got %q", result.Output)
+	}
+	if after != "alpha\n" {
+		t.Fatalf("file must be unchanged, got %q", after)
+	}
+}
+
+func TestEditFuzzyCRLFFile(t *testing.T) {
+	// CRLF file + LF old_string with indentation drift: the CRLF translation
+	// feeds the cascade and the replacement preserves CRLF endings.
+	initial := "func a() {\r\n\tx := 1\r\n}\r\n"
+	result, after := runEdit(t, t.TempDir(), initial, map[string]any{
+		"old_string": "x := 1",
+		"new_string": "x := 2",
+	})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %q", result.Output)
+	}
+	if !strings.Contains(after, "\tx := 2\r\n") {
+		t.Fatalf("unexpected content: %q", after)
+	}
+}
+
+func TestIsDisproportionateEditMatch(t *testing.T) {
+	// A candidate span that dwarfs old_string must be refused: anchors bridging
+	// unrelated code would otherwise delete it all.
+	big := strings.Repeat("line\n", 10)
+	if !isDisproportionateEditMatch(big, "a\nb\nc") {
+		t.Fatal("10-line span for 3-line find must be disproportionate")
+	}
+	if isDisproportionateEditMatch("a\nb\nc\nd", "a\nb\nc") {
+		t.Fatal("one extra line within tolerance must be allowed")
+	}
+	if isDisproportionateEditMatch("single line", "single") {
+		t.Fatal("single-line finds are exempt from the byte-length guard")
+	}
+	if !isDisproportionateEditMatch("xx\n"+strings.Repeat("y", 900)+"\nzz", "xx\nab\nzz") {
+		t.Fatal("byte-length blowup must be disproportionate")
+	}
+}
+
+func TestLevenshtein(t *testing.T) {
+	cases := []struct {
+		a, b string
+		want int
+	}{
+		{"", "", 0},
+		{"abc", "", 3},
+		{"", "abc", 3},
+		{"kitten", "sitting", 3},
+		{"same", "same", 0},
+	}
+	for _, c := range cases {
+		if got := levenshtein(c.a, c.b); got != c.want {
+			t.Fatalf("levenshtein(%q,%q) = %d, want %d", c.a, c.b, got, c.want)
+		}
+	}
+}

internal/tools/exec_command.go

@@ -908,6 +908,15 @@ func formatExecCommandOutput(output string, sessionID int, exited bool, exitCode
 }
 
 func truncateExecOutput(output string, maxOutputTokens int) (string, bool) {
+	return truncateExecOutputSpill(output, maxOutputTokens, "exec_command")
+}
+
+// truncateExecOutputSpill keeps a head/tail window of the output within the
+// token budget and, on truncation, spills the full output to disk so the model
+// can grep/read the elided middle instead of re-running the command with a
+// bigger budget. The spill is best-effort: when it fails the notice simply
+// omits the file hint.
+func truncateExecOutputSpill(output string, maxOutputTokens int, toolName string) (string, bool) {
 	if maxOutputTokens <= 0 {
 		maxOutputTokens = defaultMaxOutputTokens
 	}
@@ -915,9 +924,13 @@ func truncateExecOutput(output string, maxOutputTokens int) (string, bool) {
 	if len(output) <= maxBytes {
 		return output, false
 	}
+	notice := "\n[zero] output truncated\n"
+	if spillPath := spillTruncatedOutput(toolName, output); spillPath != "" {
+		notice = "\n[zero] output truncated — full output saved to " + spillPath + " (grep or read_file it instead of re-running)\n"
+	}
 	head := maxBytes / 2
 	tail := maxBytes - head
-	return utf8Prefix(output, head) + "\n[zero] output truncated\n" + utf8Suffix(output, tail), true
+	return utf8Prefix(output, head) + notice + utf8Suffix(output, tail), true
 }
 
 func utf8Prefix(value string, maxBytes int) string {

internal/tools/format_on_write.go

@@ -0,0 +1,97 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// Format-on-write for the mutating file tools. When enabled, a successful
+// edit_file/write_file runs the language's standard formatter on the file it
+// just wrote, so the model's output always lands in project-canonical style
+// and never fails a CI format check it cannot see. Off by default (set
+// ZERO_FORMAT_ON_WRITE=1): auto-reformatting changes bytes the model did not
+// write, which strict workflows may not want.
+//
+// Ordering matters: formatting runs BEFORE the FileTracker re-baseline, and
+// the caller records the POST-format content. Formatting after the baseline
+// would make the very next edit look like an external modification and trip
+// the conflict guard.
+
+// formatOnWriteTimeout bounds one formatter run; a wedged formatter must never
+// hang a tool call. On timeout the unformatted write stands.
+const formatOnWriteTimeout = 10 * time.Second
+
+// formatterCommands maps a file extension to the formatter argv; the file path
+// is appended as the final argument. Only in-place, config-respecting,
+// community-standard formatters — a missing binary silently skips formatting.
+var formatterCommands = map[string][]string{
+	".go":    {"gofmt", "-w"},
+	".rs":    {"rustfmt"},
+	".py":    {"ruff", "format", "--quiet"},
+	".ts":    {"prettier", "--log-level", "silent", "--write"},
+	".tsx":   {"prettier", "--log-level", "silent", "--write"},
+	".js":    {"prettier", "--log-level", "silent", "--write"},
+	".jsx":   {"prettier", "--log-level", "silent", "--write"},
+	".json":  {"prettier", "--log-level", "silent", "--write"},
+	".css":   {"prettier", "--log-level", "silent", "--write"},
+	".scss":  {"prettier", "--log-level", "silent", "--write"},
+	".html":  {"prettier", "--log-level", "silent", "--write"},
+	".md":    {"prettier", "--log-level", "silent", "--write"},
+	".yaml":  {"prettier", "--log-level", "silent", "--write"},
+	".yml":   {"prettier", "--log-level", "silent", "--write"},
+	".zig":   {"zig", "fmt"},
+	".dart":  {"dart", "format"},
+	".tf":    {"terraform", "fmt"},
+	".gleam": {"gleam", "format"},
+	".sh":    {"shfmt", "-w"},
+	".bash":  {"shfmt", "-w"},
+	".c":     {"clang-format", "-i"},
+	".h":     {"clang-format", "-i"},
+	".cpp":   {"clang-format", "-i"},
+	".hpp":   {"clang-format", "-i"},
+	".cc":    {"clang-format", "-i"},
+	".kt":    {"ktlint", "-F"},
+	".swift": {"swiftformat"},
+	".lua":   {"stylua"},
+}
+
+// formatOnWriteEnabled reports whether the opt-in env toggle is set.
+func formatOnWriteEnabled() bool {
+	value := strings.TrimSpace(os.Getenv("ZERO_FORMAT_ON_WRITE"))
+	return value != "" && value != "0" && !strings.EqualFold(value, "false")
+}
+
+// maybeFormatWrittenFile runs the configured formatter for absolutePath (when
+// enabled and on PATH) and returns the file's content afterwards. Best-effort
+// throughout: any failure — no formatter, formatter error, timeout, unreadable
+// result — returns writtenContent so the caller's state matches the last write
+// it performed itself.
+func maybeFormatWrittenFile(ctx context.Context, absolutePath string, writtenContent string) string {
+	if !formatOnWriteEnabled() {
+		return writtenContent
+	}
+	command, ok := formatterCommands[strings.ToLower(filepath.Ext(absolutePath))]
+	if !ok {
+		return writtenContent
+	}
+	if _, err := exec.LookPath(command[0]); err != nil {
+		return writtenContent
+	}
+	formatCtx, cancel := context.WithTimeout(ctx, formatOnWriteTimeout)
+	defer cancel()
+	arguments := append(append([]string(nil), command[1:]...), absolutePath)
+	formatter := exec.CommandContext(formatCtx, command[0], arguments...)
+	formatter.Dir = filepath.Dir(absolutePath)
+	if err := formatter.Run(); err != nil {
+		return writtenContent
+	}
+	formatted, err := os.ReadFile(absolutePath)
+	if err != nil {
+		return writtenContent
+	}
+	return string(formatted)
+}

internal/tools/format_on_write_test.go

@@ -0,0 +1,82 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// gofmt ships with the Go toolchain, so it is the one formatter guaranteed to
+// exist wherever these tests run.
+func requireGofmt(t *testing.T) {
+	t.Helper()
+	if _, err := exec.LookPath("gofmt"); err != nil {
+		t.Skip("gofmt not on PATH")
+	}
+}
+
+func TestFormatOnWriteDisabledByDefault(t *testing.T) {
+	requireGofmt(t)
+	t.Setenv("ZERO_FORMAT_ON_WRITE", "")
+	dir := t.TempDir()
+	ugly := "package a\n\nfunc  A( ) {   }\n"
+
+	result := NewWriteFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":    "a.go",
+		"content": ugly,
+	}, RunOptions{})
+	if result.Status != StatusOK {
+		t.Fatalf("write failed: %q", result.Output)
+	}
+	onDisk, err := os.ReadFile(filepath.Join(dir, "a.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(onDisk) != ugly {
+		t.Fatalf("formatting must be off by default, got %q", onDisk)
+	}
+}
+
+func TestFormatOnWriteFormatsAndKeepsTrackerConsistent(t *testing.T) {
+	requireGofmt(t)
+	t.Setenv("ZERO_FORMAT_ON_WRITE", "1")
+	dir := t.TempDir()
+	tracker := NewFileTracker()
+
+	write := NewWriteFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":    "a.go",
+		"content": "package a\n\nfunc  A( ) {   }\n",
+	}, RunOptions{FileTracker: tracker})
+	if write.Status != StatusOK {
+		t.Fatalf("write failed: %q", write.Output)
+	}
+	onDisk, err := os.ReadFile(filepath.Join(dir, "a.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(onDisk), "func A() {") {
+		t.Fatalf("expected gofmt-formatted content, got %q", onDisk)
+	}
+
+	// The tracker must have been re-baselined to the POST-format content: a
+	// follow-up edit must not trip the external-modification conflict guard.
+	edit := NewEditFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":       "a.go",
+		"old_string": "func A() {",
+		"new_string": "func B() {",
+	}, RunOptions{FileTracker: tracker})
+	if edit.Status != StatusOK {
+		t.Fatalf("follow-up edit must not conflict after formatting: %q", edit.Output)
+	}
+}
+
+func TestFormatOnWriteSkipsUnknownExtensions(t *testing.T) {
+	t.Setenv("ZERO_FORMAT_ON_WRITE", "1")
+	content := maybeFormatWrittenFile(context.Background(), filepath.Join(t.TempDir(), "notes.xyz"), "raw   text")
+	if content != "raw   text" {
+		t.Fatalf("unknown extension must pass through: %q", content)
+	}
+}

internal/tools/glob.go

@@ -45,18 +45,18 @@ func NewScopedGlobTool(workspaceRoot string, scope PathScope) Tool {
 	}
 }
 
-func (tool globTool) Run(_ context.Context, args map[string]any) Result {
-	return tool.runWith(args, readExcluder{})
+func (tool globTool) Run(ctx context.Context, args map[string]any) Result {
+	return tool.runWith(ctx, args, readExcluder{})
 }
 
 // RunWithSandbox runs glob while skipping subtrees the sandbox policy denies
 // reads to (DenyRead). With no DenyRead configured the excluder is a no-op and
 // behavior is unchanged.
-func (tool globTool) RunWithSandbox(_ context.Context, args map[string]any, engine *sandbox.Engine) Result {
-	return tool.runWith(args, sandboxReadExcluder(engine))
+func (tool globTool) RunWithSandbox(ctx context.Context, args map[string]any, engine *sandbox.Engine) Result {
+	return tool.runWith(ctx, args, sandboxReadExcluder(engine))
 }
 
-func (tool globTool) runWith(args map[string]any, exclude readExcluder) Result {
+func (tool globTool) runWith(ctx context.Context, args map[string]any, exclude readExcluder) Result {
 	pattern, err := aliasedStringArg(args, []string{"pattern", "glob", "match", "query", "expression"}, "", true, false)
 	if err != nil {
 		return errorResult("Error: Invalid arguments for glob: " + err.Error())
@@ -88,8 +88,11 @@ func (tool globTool) runWith(args map[string]any, exclude readExcluder) Result {
 		return errorResult("Error running glob " + fmt.Sprintf("%q", pattern) + ": " + err.Error())
 	}
 
-	matches, err := scanGlob(root, displayRoot, matcher, includeDirs, exclude)
+	matches, err := scanGlob(ctx, root, displayRoot, matcher, includeDirs, exclude)
 	if err != nil {
+		if res, ok := searchCancelledResult("glob", err); ok {
+			return res
+		}
 		return errorResult("Error running glob " + fmt.Sprintf("%q", pattern) + ": " + err.Error())
 	}
 	if len(matches) == 0 {
@@ -126,9 +129,15 @@ func (tool globTool) runWith(args map[string]any, exclude readExcluder) Result {
 	}
 }
 
-func scanGlob(root string, displayRoot string, matcher *regexp.Regexp, includeDirs bool, exclude readExcluder) ([]string, error) {
+func scanGlob(ctx context.Context, root string, displayRoot string, matcher *regexp.Regexp, includeDirs bool, exclude readExcluder) ([]string, error) {
 	matches := []string{}
 	err := filepath.WalkDir(root, func(path string, entry fs.DirEntry, walkErr error) error {
+		// Checked first, ahead of walkErr: an unscoped scan over a large tree can
+		// run long enough that cancelling the run must stop the walk promptly
+		// rather than visiting every remaining entry to completion.
+		if err := ctx.Err(); err != nil {
+			return err
+		}
 		if walkErr != nil {
 			if path == root {
 				return walkErr

internal/tools/grep.go

@@ -55,19 +55,19 @@ func NewScopedGrepTool(workspaceRoot string, scope PathScope) Tool {
 	}
 }
 
-func (tool grepTool) Run(_ context.Context, args map[string]any) Result {
-	return tool.runWith(args, readExcluder{})
+func (tool grepTool) Run(ctx context.Context, args map[string]any) Result {
+	return tool.runWith(ctx, args, readExcluder{})
 }
 
 // RunWithSandbox runs the search while skipping subtrees the sandbox policy
 // denies reads to (DenyRead), so grep never surfaces content from a read-denied
 // path. With no DenyRead configured the excluder is a no-op and behavior is
 // unchanged.
-func (tool grepTool) RunWithSandbox(_ context.Context, args map[string]any, engine *sandbox.Engine) Result {
-	return tool.runWith(args, sandboxReadExcluder(engine))
+func (tool grepTool) RunWithSandbox(ctx context.Context, args map[string]any, engine *sandbox.Engine) Result {
+	return tool.runWith(ctx, args, sandboxReadExcluder(engine))
 }
 
-func (tool grepTool) runWith(args map[string]any, exclude readExcluder) Result {
+func (tool grepTool) runWith(ctx context.Context, args map[string]any, exclude readExcluder) Result {
 	pattern, err := aliasedStringArg(args, []string{"pattern", "query", "regex", "search", "expression"}, "", true, false)
 	if err != nil {
 		return errorResult("Error: Invalid arguments for grep: " + err.Error())
@@ -138,15 +138,24 @@ func (tool grepTool) runWith(args map[string]any, exclude readExcluder) Result {
 		}
 	}
 
-	files, err := grepFiles(resolvedRoot, target, globMatcher, exclude)
+	files, err := grepFiles(ctx, resolvedRoot, target, globMatcher, exclude)
 	if err != nil {
+		if res, ok := searchCancelledResult("grep", err); ok {
+			return res
+		}
 		return errorResult("Error running grep: " + err.Error())
 	}
 
 	// resolveScopedPath returns an absolute displayRoot when the target resolved
 	// to an extra (non-workspace) granted root; emit absolute match paths there so
 	// they survive a round-trip through read_file/edit_file (mirrors glob).
-	matches := collectGrepMatches(resolvedRoot, filepath.IsAbs(displayRoot), files, compiled)
+	matches, err := collectGrepMatches(ctx, resolvedRoot, filepath.IsAbs(displayRoot), files, compiled)
+	if err != nil {
+		if res, ok := searchCancelledResult("grep", err); ok {
+			return res
+		}
+		return errorResult("Error running grep: " + err.Error())
+	}
 	if len(matches) == 0 {
 		if outputMode == "count" {
 			return okResult("0 matches found")
@@ -261,7 +270,7 @@ func confineGrepFile(resolvedRoot string, path string) (string, string, bool) {
 	return filepath.ToSlash(relative), resolved, true
 }
 
-func grepFiles(resolvedRoot string, target string, globMatcher *regexp.Regexp, exclude readExcluder) ([]string, error) {
+func grepFiles(ctx context.Context, resolvedRoot string, target string, globMatcher *regexp.Regexp, exclude readExcluder) ([]string, error) {
 	info, err := os.Stat(target)
 	if err != nil {
 		return nil, err
@@ -288,6 +297,13 @@ func grepFiles(resolvedRoot string, target string, globMatcher *regexp.Regexp, e
 
 	files := []string{}
 	err = filepath.WalkDir(target, func(path string, entry os.DirEntry, walkErr error) error {
+		// Checked first, ahead of walkErr: an unscoped search over a large tree
+		// (e.g. a broad parent directory, not just the workspace) can run long
+		// enough that cancelling the run must stop the walk promptly rather than
+		// visiting every remaining entry to completion.
+		if err := ctx.Err(); err != nil {
+			return err
+		}
 		if walkErr != nil {
 			if path == target {
 				return walkErr
@@ -342,9 +358,16 @@ func grepFiles(resolvedRoot string, target string, globMatcher *regexp.Regexp, e
 	return files, nil
 }
 
-func collectGrepMatches(resolvedRoot string, absolutePaths bool, files []string, compiled *regexp.Regexp) []grepMatch {
+func collectGrepMatches(ctx context.Context, resolvedRoot string, absolutePaths bool, files []string, compiled *regexp.Regexp) ([]grepMatch, error) {
 	matches := []grepMatch{}
 	for _, file := range files {
+		// Checked per file, matching the walk's per-entry check in grepFiles: a
+		// broad search can already have collected many files before the run is
+		// cancelled, and reading/regex-scanning each one is real work that must
+		// stop promptly rather than running to completion.
+		if err := ctx.Err(); err != nil {
+			return matches, err
+		}
 		// Re-confine at read time (defense-in-depth) AND to compute the clean
 		// workspace-relative path used in output.
 		relative, resolvedPath, ok := confineGrepFile(resolvedRoot, file)
@@ -381,5 +404,5 @@ func collectGrepMatches(resolvedRoot string, absolutePaths bool, files []string,
 			})
 		}
 	}
-	return matches
+	return matches, nil
 }

internal/tools/inline_diagnostics.go

@@ -0,0 +1,18 @@
+package tools
+
+import "context"
+
+// inlineDiagnostics renders the post-write diagnostics block a mutating tool
+// appends to its output. Empty when no Diagnostics callback is wired, the file
+// is clean, or no language server is available — the tool output is then
+// byte-identical to the pre-diagnostics behavior.
+func inlineDiagnostics(ctx context.Context, options RunOptions, absolutePath, relativePath string) string {
+	if options.Diagnostics == nil {
+		return ""
+	}
+	block := options.Diagnostics(ctx, absolutePath)
+	if block == "" {
+		return ""
+	}
+	return "\n\nDiagnostics in " + relativePath + " after this change (fix any errors you introduced):\n" + block
+}

internal/tools/inline_diagnostics_test.go

@@ -0,0 +1,53 @@
+package tools
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// A wired Diagnostics callback must surface its block in the tool output for
+// both mutating tools, and a clean file (empty block) must leave the output
+// byte-identical to the pre-diagnostics behavior.
+func TestMutatingToolsAppendInlineDiagnostics(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "a.go"), []byte("package a\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	diagnostics := func(_ context.Context, absPath string) string {
+		return absPath + ":1:1: error: undefined: x"
+	}
+
+	editResult := NewEditFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":       "a.go",
+		"old_string": "package a",
+		"new_string": "package b",
+	}, RunOptions{Diagnostics: diagnostics})
+	if editResult.Status != StatusOK {
+		t.Fatalf("edit failed: %q", editResult.Output)
+	}
+	if !strings.Contains(editResult.Output, "Diagnostics in a.go after this change") || !strings.Contains(editResult.Output, "undefined: x") {
+		t.Fatalf("edit output missing diagnostics block: %q", editResult.Output)
+	}
+
+	writeResult := NewWriteFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":    "b.go",
+		"content": "package b\n",
+	}, RunOptions{Diagnostics: diagnostics})
+	if writeResult.Status != StatusOK {
+		t.Fatalf("write failed: %q", writeResult.Output)
+	}
+	if !strings.Contains(writeResult.Output, "Diagnostics in b.go after this change") {
+		t.Fatalf("write output missing diagnostics block: %q", writeResult.Output)
+	}
+
+	clean := NewWriteFileTool(dir).(optionsAwareTool).RunWithOptions(context.Background(), map[string]any{
+		"path":    "c.go",
+		"content": "package c\n",
+	}, RunOptions{Diagnostics: func(context.Context, string) string { return "" }})
+	if strings.Contains(clean.Output, "Diagnostics") {
+		t.Fatalf("clean file must not gain a diagnostics block: %q", clean.Output)
+	}
+}

internal/tools/registry.go

@@ -40,6 +40,12 @@ type RunOptions struct {
 	// tool-call progress in the specialist card. nil is a no-op (the default
 	// for every non-Task tool).
 	Progress func(streamjson.Event)
+	// Diagnostics, when set, returns a formatted language-diagnostics block for
+	// a file a mutating tool just wrote ("" when clean or no server available).
+	// edit_file/write_file append it to their output so the model sees an error
+	// it introduced in the same turn instead of waiting for a later verification
+	// pass. nil disables inline diagnostics.
+	Diagnostics func(ctx context.Context, absPath string) string
 }
 
 type sandboxAwareTool interface {

internal/tools/search_cancel.go

@@ -0,0 +1,13 @@
+package tools
+
+import (
+	"context"
+	"errors"
+)
+
+func searchCancelledResult(tool string, err error) (Result, bool) {
+	if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+		return Result{Status: StatusError, Output: "Error: " + tool + " cancelled."}, true
+	}
+	return Result{}, false
+}

internal/tools/search_cancellation_test.go

@@ -0,0 +1,206 @@
+package tools
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"testing"
+)
+
+// countingCancelContext returns context.Canceled from Err() once it has been
+// called more than "remaining" times, letting a test deterministically
+// cancel a loop after a fixed number of iterations instead of relying on
+// timing. A context.WithTimeout test would be flaky under a loaded or
+// shared CI runner, exactly the kind of test PR #464 was criticized for
+// elsewhere (TestCollectRespectsDeadlineUnderContinuousOutput).
+type countingCancelContext struct {
+	context.Context
+	remaining int
+}
+
+func (c *countingCancelContext) Err() error {
+	c.remaining--
+	if c.remaining < 0 {
+		return context.Canceled
+	}
+	return nil
+}
+
+// buildLargeSearchTree creates n files, each containing a grep-matchable
+// line, so a walk that does NOT respect cancellation would have plenty of
+// work left to do (and matches to find) after the very first entry.
+func buildLargeSearchTree(t *testing.T, n int) string {
+	t.Helper()
+	root := t.TempDir()
+	for i := 0; i < n; i++ {
+		path := filepath.Join(root, "file"+strconv.Itoa(i)+".txt")
+		if err := os.WriteFile(path, []byte("needle\n"), 0o644); err != nil {
+			t.Fatalf("WriteFile: %v", err)
+		}
+	}
+	return root
+}
+
+// A cancelled run must stop the filesystem walk promptly instead of visiting
+// every remaining entry to completion. Before this fix, grep's Run/
+// RunWithSandbox discarded their context entirely, so cancelling the run
+// (Ctrl+C / /exit) had no effect on an in-flight, unscoped search: the walk
+// ran to completion regardless, and — because the TUI's exit path waits for
+// the cancelled run's own response before it can quit — the whole
+// application was stuck until the walk finished on its own.
+func TestGrepStopsWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 500)
+	tool := NewGrepTool(root)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel() // already cancelled before the walk starts
+
+	result := tool.Run(ctx, map[string]any{"pattern": "needle"})
+	if result.Status != StatusError {
+		t.Fatalf("status = %q, want error", result.Status)
+	}
+	if result.Output != "Error: grep cancelled." {
+		t.Fatalf("output = %q, want the cancellation message", result.Output)
+	}
+}
+
+func TestGrepRunWithSandboxStopsWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 500)
+	tool := NewGrepTool(root)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	sandboxed := tool.(sandboxAwareTool)
+	result := sandboxed.RunWithSandbox(ctx, map[string]any{"pattern": "needle"}, nil)
+	if result.Status != StatusError {
+		t.Fatalf("status = %q, want error", result.Status)
+	}
+	if result.Output != "Error: grep cancelled." {
+		t.Fatalf("output = %q, want the cancellation message", result.Output)
+	}
+}
+
+// grep with a live (non-cancelled) context must still work normally: this
+// fix only short-circuits on cancellation, it does not change matching.
+func TestGrepStillMatchesWithLiveContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 3)
+	tool := NewGrepTool(root)
+
+	result := tool.Run(context.Background(), map[string]any{"pattern": "needle"})
+	if result.Status != StatusOK {
+		t.Fatalf("status = %q, want ok; output=%q", result.Status, result.Output)
+	}
+}
+
+// Before this fix, only grepFiles' walk checked ctx: once the walk had
+// finished discovering candidate files, collectGrepMatches read and
+// regex-scanned every one of them to completion regardless of cancellation.
+// This proves the match-collection phase itself stops partway through,
+// not only when the context was already cancelled before the walk started.
+// grepFiles must stop mid-walk once ctx is cancelled, not only when the
+// context was already cancelled before WalkDir starts.
+func TestGrepFilesStopsMidWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 50)
+	resolvedRoot, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatalf("EvalSymlinks: %v", err)
+	}
+
+	const allowed = 5
+	ctx := &countingCancelContext{Context: context.Background(), remaining: allowed}
+	files, err := grepFiles(ctx, resolvedRoot, root, nil, readExcluder{})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("err = %v, want context.Canceled", err)
+	}
+	if len(files) >= 50 {
+		t.Fatalf("files = %d; walk should stop mid-traversal instead of visiting every entry", len(files))
+	}
+}
+
+func TestGrepCollectMatchesStopsMidCollectionOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 50)
+	files := make([]string, 50)
+	for i := range files {
+		files[i] = filepath.Join(root, "file"+strconv.Itoa(i)+".txt")
+	}
+	resolvedRoot, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatalf("EvalSymlinks: %v", err)
+	}
+	compiled := regexp.MustCompile("needle")
+
+	const allowed = 5
+	ctx := &countingCancelContext{Context: context.Background(), remaining: allowed}
+	matches, err := collectGrepMatches(ctx, resolvedRoot, false, files, compiled)
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("err = %v, want context.Canceled", err)
+	}
+	if len(matches) != allowed {
+		t.Fatalf("matches = %d, want exactly %d collected before cancellation stopped the loop", len(matches), allowed)
+	}
+}
+
+func TestScanGlobStopsMidWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 50)
+	matcher, err := compileGlob("**/*.txt")
+	if err != nil {
+		t.Fatalf("compileGlob: %v", err)
+	}
+
+	const allowed = 5
+	ctx := &countingCancelContext{Context: context.Background(), remaining: allowed}
+	matches, err := scanGlob(ctx, root, root, matcher, false, readExcluder{})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("err = %v, want context.Canceled", err)
+	}
+	if len(matches) >= 50 {
+		t.Fatalf("matches = %d; walk should stop mid-traversal instead of visiting every entry", len(matches))
+	}
+}
+
+func TestGlobStopsWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 500)
+	tool := NewGlobTool(root)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	result := tool.Run(ctx, map[string]any{"pattern": "**/*.txt"})
+	if result.Status != StatusError {
+		t.Fatalf("status = %q, want error", result.Status)
+	}
+	if result.Output != "Error: glob cancelled." {
+		t.Fatalf("output = %q, want the cancellation message", result.Output)
+	}
+}
+
+func TestGlobRunWithSandboxStopsWalkOnCancelledContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 500)
+	tool := NewGlobTool(root)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	sandboxed := tool.(sandboxAwareTool)
+	result := sandboxed.RunWithSandbox(ctx, map[string]any{"pattern": "**/*.txt"}, nil)
+	if result.Status != StatusError {
+		t.Fatalf("status = %q, want error", result.Status)
+	}
+	if result.Output != "Error: glob cancelled." {
+		t.Fatalf("output = %q, want the cancellation message", result.Output)
+	}
+}
+
+func TestGlobStillMatchesWithLiveContext(t *testing.T) {
+	root := buildLargeSearchTree(t, 3)
+	tool := NewGlobTool(root)
+
+	result := tool.Run(context.Background(), map[string]any{"pattern": "**/*.txt"})
+	if result.Status != StatusOK {
+		t.Fatalf("status = %q, want ok; output=%q", result.Status, result.Output)
+	}
+}

internal/tools/spill.go

@@ -0,0 +1,84 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/Gitlawb/zero/internal/redaction"
+)
+
+// Spill-to-disk for truncated tool output. When a command produces more than
+// its context budget, the tail was previously simply gone — the model's only
+// recourse was re-running the (possibly expensive or non-idempotent) command
+// with a bigger budget. Instead, the full output is written to a cache file
+// whose path is included in the truncation notice, so the model can grep or
+// read_file the remainder. Spilling is best-effort: on any error truncation
+// behaves exactly as before, just without the file hint.
+
+// spillRetention is how long spilled outputs are kept; files older than this
+// are opportunistically removed whenever a new spill happens.
+const spillRetention = 7 * 24 * time.Hour
+
+// spillDir returns the shared spill directory, creating it on first use.
+func spillDir() (string, error) {
+	dir := filepath.Join(os.TempDir(), "zero-tool-output")
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return "", err
+	}
+	return dir, nil
+}
+
+// spillTruncatedOutput writes the full pre-truncation output to the spill
+// directory and returns the file path, or "" when spilling fails. Output is
+// scrubbed with the same configured-key redaction the registry applies at the
+// tool boundary, so a spilled file never holds a secret the transcript would
+// have hidden.
+func spillTruncatedOutput(toolName, output string) string {
+	dir, err := spillDir()
+	if err != nil {
+		return ""
+	}
+	sweepSpillDir(dir)
+	prefix := strings.Map(func(r rune) rune {
+		if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '_' || r == '-' {
+			return r
+		}
+		return '-'
+	}, toolName)
+	file, err := os.CreateTemp(dir, prefix+"-*.txt")
+	if err != nil {
+		return ""
+	}
+	defer file.Close()
+	scrubbed := redaction.RedactString(output, redaction.Options{})
+	if _, err := file.WriteString(scrubbed); err != nil {
+		_ = os.Remove(file.Name())
+		return ""
+	}
+	return file.Name()
+}
+
+// sweepSpillDir removes spill files older than spillRetention. Best-effort:
+// errors are ignored, the directory is small, and a sweep runs only when a new
+// spill is about to happen anyway.
+func sweepSpillDir(dir string) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return
+	}
+	cutoff := time.Now().Add(-spillRetention)
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		info, err := entry.Info()
+		if err != nil {
+			continue
+		}
+		if info.ModTime().Before(cutoff) {
+			_ = os.Remove(filepath.Join(dir, entry.Name()))
+		}
+	}
+}

internal/tools/spill_test.go

@@ -0,0 +1,94 @@
+package tools
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestTruncateExecOutputSpillWritesFullOutput(t *testing.T) {
+	t.Setenv("TMPDIR", t.TempDir())
+	long := strings.Repeat("line of build output\n", 5000) // ~100KB > 40KB budget
+
+	truncated, wasTruncated := truncateExecOutputSpill(long, defaultMaxOutputTokens, "bash")
+	if !wasTruncated {
+		t.Fatal("output over budget must truncate")
+	}
+	if !strings.Contains(truncated, "full output saved to ") {
+		t.Fatalf("truncation notice missing spill path: %q", truncated[:200])
+	}
+	// Extract the path and verify the file holds the complete output.
+	start := strings.Index(truncated, "full output saved to ") + len("full output saved to ")
+	end := strings.Index(truncated[start:], " (grep")
+	spillPath := truncated[start : start+end]
+	content, err := os.ReadFile(spillPath)
+	if err != nil {
+		t.Fatalf("spill file unreadable: %v", err)
+	}
+	if string(content) != long {
+		t.Fatalf("spill file must hold the full output: got %d bytes, want %d", len(content), len(long))
+	}
+}
+
+func TestTruncateExecOutputUnderBudgetUnchanged(t *testing.T) {
+	output, wasTruncated := truncateExecOutputSpill("short output", defaultMaxOutputTokens, "bash")
+	if wasTruncated || output != "short output" {
+		t.Fatalf("under-budget output must pass through untouched: %q", output)
+	}
+}
+
+func TestFormatBashOutputCapsVerboseOutput(t *testing.T) {
+	t.Setenv("TMPDIR", t.TempDir())
+	long := strings.Repeat("x", 200*1024)
+	formatted := formatBashOutput(long, "", 0)
+	if len(formatted) > defaultMaxOutputTokens*4+1024 {
+		t.Fatalf("bash output must be capped near the token budget, got %d bytes", len(formatted))
+	}
+	if !strings.Contains(formatted, "output truncated") {
+		t.Fatal("capped bash output must carry the truncation notice")
+	}
+}
+
+func TestSweepSpillDirRemovesOnlyOldFiles(t *testing.T) {
+	dir := t.TempDir()
+	oldFile := filepath.Join(dir, "bash-old.txt")
+	newFile := filepath.Join(dir, "bash-new.txt")
+	for _, path := range []string{oldFile, newFile} {
+		if err := os.WriteFile(path, []byte("x"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	stale := time.Now().Add(-spillRetention - time.Hour)
+	if err := os.Chtimes(oldFile, stale, stale); err != nil {
+		t.Fatal(err)
+	}
+
+	sweepSpillDir(dir)
+
+	if _, err := os.Stat(oldFile); !os.IsNotExist(err) {
+		t.Fatal("stale spill file must be removed")
+	}
+	if _, err := os.Stat(newFile); err != nil {
+		t.Fatal("fresh spill file must survive the sweep")
+	}
+}
+
+func TestSpillTruncatedOutputWritesFile(t *testing.T) {
+	t.Setenv("TMPDIR", t.TempDir())
+	path := spillTruncatedOutput("exec_command", "some output body")
+	if path == "" {
+		t.Fatal("spill must return a file path")
+	}
+	if base := filepath.Base(path); !strings.HasPrefix(base, "exec_command-") {
+		t.Fatalf("spill file name must carry the tool prefix: %s", base)
+	}
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(content) != "some output body" {
+		t.Fatalf("unexpected spill content: %q", content)
+	}
+}

internal/tools/web_fetch.go

@@ -18,9 +18,14 @@ import (
 )
 
 const (
-	defaultWebFetchMaxBytes = 64 * 1024
-	maxWebFetchMaxBytes     = 512 * 1024
-	webFetchTimeout         = 10 * time.Second
+	// Raw-body budgets. HTML responses are converted to markdown before they
+	// reach the model (see web_fetch_markdown.go), so a generous raw budget
+	// does not translate into a generous context cost — conversion typically
+	// shrinks a page by an order of magnitude. 64KiB of raw HTML often held
+	// nothing but a page's <head>, which starved research tasks.
+	defaultWebFetchMaxBytes = 256 * 1024
+	maxWebFetchMaxBytes     = 2 * 1024 * 1024
+	webFetchTimeout         = 30 * time.Second
 	webFetchRedirectLimit   = 5
 	webFetchErrorBodyLimit  = 4 * 1024
 	webFetchPublicOnlyHint  = "web_fetch only supports public remote HTTP/HTTPS URLs. For localhost or private network URLs, use bash with curl so sandbox network permission can apply."
@@ -115,11 +120,17 @@ func newWebFetchToolWithClientAndResolver(client *http.Client, resolver webFetch
 					},
 					"max_bytes": {
 						Type:        "integer",
-						Description: "Maximum response body bytes to return.",
+						Description: "Maximum raw response body bytes to download before conversion.",
 						Default:     defaultWebFetchMaxBytes,
 						Minimum:     intPtr(1),
 						Maximum:     intPtr(maxWebFetchMaxBytes),
 					},
+					"format": {
+						Type:        "string",
+						Description: "auto (default): HTML responses are converted to compact markdown, everything else is returned as-is. raw: never convert. markdown: force conversion.",
+						Enum:        []string{"auto", "raw", "markdown"},
+						Default:     "auto",
+					},
 				},
 				Required:             []string{"url"},
 				AdditionalProperties: false,
@@ -170,6 +181,18 @@ func (tool webFetchTool) run(ctx context.Context, args map[string]any) Result {
 	if err != nil {
 		return errorResult("Error: Invalid arguments for web_fetch: " + err.Error())
 	}
+	format, err := stringArg(args, "format", "auto", false)
+	if err != nil {
+		return errorResult("Error: Invalid arguments for web_fetch: " + err.Error())
+	}
+	format = strings.ToLower(strings.TrimSpace(format))
+	switch format {
+	case "", "auto":
+		format = "auto"
+	case "raw", "markdown":
+	default:
+		return errorResult(`Error: Invalid arguments for web_fetch: format must be "auto", "raw", or "markdown".`)
+	}
 	if err := validateWebFetchURLBeforePermission(rawURL); err != nil {
 		return errorResult("Error: Unsafe URL for web_fetch: " + err.Error())
 	}
@@ -224,14 +247,28 @@ func (tool webFetchTool) run(ctx context.Context, args map[string]any) Result {
 	}
 	body = redactWebFetchText(body)
 
-	output := strings.Join([]string{
+	// HTML responses are converted to compact markdown by default: raw HTML is
+	// mostly markup, so conversion typically shrinks the page by an order of
+	// magnitude and the model reads content instead of boilerplate. format=raw
+	// is the escape hatch for pages the converter mangles.
+	converted := false
+	if format == "markdown" || (format == "auto" && looksLikeHTML(contentType, body)) {
+		if markdown := htmlToMarkdown(body); markdown != "" {
+			body = markdown
+			converted = true
+		}
+	}
+
+	headers := []string{
 		"URL: " + finalURL,
 		"Status: " + webFetchStatusLine(response),
 		"Content-Type: " + firstNonEmptyString(contentType, "unknown"),
 		"Bytes: " + strconv.Itoa(len(body)),
-		"",
-		body,
-	}, "\n")
+	}
+	if converted {
+		headers = append(headers, "Converted: html -> markdown (pass format: \"raw\" for the original HTML)")
+	}
+	output := strings.Join(append(headers, "", body), "\n")
 
 	return Result{
 		Status:    StatusOK,
@@ -243,6 +280,7 @@ func (tool webFetchTool) run(ctx context.Context, args map[string]any) Result {
 			"content_type": contentType,
 			"bytes":        strconv.Itoa(len(body)),
 			"truncated":    strconv.FormatBool(truncated),
+			"converted":    strconv.FormatBool(converted),
 		},
 	}
 }

internal/tools/web_fetch_markdown.go

@@ -0,0 +1,92 @@
+package tools
+
+import (
+	"fmt"
+	"html"
+	"regexp"
+	"strings"
+)
+
+// HTML-to-markdown conversion for web_fetch. Raw HTML is mostly boilerplate —
+// on a typical page well under a tenth of the bytes are readable content — so
+// returning it raw wastes nearly the whole response budget on markup. The
+// converter is deliberately dependency-free (regex passes + stdlib entity
+// unescaping, no HTML parser): the output feeds a language model, not a
+// browser, so best-effort structure (headings, links, list markers) is enough,
+// and the format=raw escape hatch covers pages it mangles.
+
+var (
+	webFetchDropBlockRe = regexp.MustCompile(`(?is)<(script|style|head|noscript|svg|template|iframe)\b[^>]*>.*?</\s*(?:script|style|head|noscript|svg|template|iframe)\s*>`)
+	webFetchCommentRe   = regexp.MustCompile(`(?s)<!--.*?-->`)
+	webFetchAnchorRe    = regexp.MustCompile(`(?is)<a\b[^>]*?href\s*=\s*["']?([^"'\s>]+)["']?[^>]*>(.*?)</\s*a\s*>`)
+	webFetchHeadingRe   = regexp.MustCompile(`(?is)<h([1-6])[^>]*>(.*?)</\s*h[1-6]\s*>`)
+	webFetchListItemRe  = regexp.MustCompile(`(?i)<li\b[^>]*>`)
+	webFetchBreakRe     = regexp.MustCompile(`(?i)<(?:br|hr)\s*/?>`)
+	webFetchBlockTagRe  = regexp.MustCompile(`(?i)</?(?:p|div|section|article|main|header|footer|nav|aside|table|tr|ul|ol|blockquote|pre|figure|form)\b[^>]*>`)
+	webFetchAnyTagRe    = regexp.MustCompile(`(?s)<[^>]*>`)
+	webFetchSpaceRunRe  = regexp.MustCompile(`[ \t]+`)
+	webFetchBlankRunRe  = regexp.MustCompile(`\n{3,}`)
+)
+
+// htmlToMarkdown converts an HTML document to compact markdown-flavored text:
+// headings become #-prefixed lines, anchors become [text](href), list items
+// become "- " bullets, block boundaries become blank lines, all other markup
+// is stripped, and entities are unescaped.
+func htmlToMarkdown(body string) string {
+	text := webFetchCommentRe.ReplaceAllString(body, " ")
+	text = webFetchDropBlockRe.ReplaceAllString(text, " ")
+	text = webFetchHeadingRe.ReplaceAllStringFunc(text, func(match string) string {
+		groups := webFetchHeadingRe.FindStringSubmatch(match)
+		level := int(groups[1][0] - '0')
+		if level < 1 || level > 6 {
+			level = 1
+		}
+		title := strings.TrimSpace(webFetchAnyTagRe.ReplaceAllString(groups[2], " "))
+		return "\n\n" + strings.Repeat("#", level) + " " + title + "\n\n"
+	})
+	text = webFetchAnchorRe.ReplaceAllStringFunc(text, func(match string) string {
+		groups := webFetchAnchorRe.FindStringSubmatch(match)
+		href := groups[1]
+		label := strings.TrimSpace(webFetchAnyTagRe.ReplaceAllString(groups[2], " "))
+		if label == "" {
+			return " "
+		}
+		if strings.HasPrefix(href, "#") || strings.HasPrefix(strings.ToLower(href), "javascript:") {
+			return label
+		}
+		return fmt.Sprintf("[%s](%s)", label, href)
+	})
+	text = webFetchListItemRe.ReplaceAllString(text, "\n- ")
+	text = webFetchBreakRe.ReplaceAllString(text, "\n")
+	text = webFetchBlockTagRe.ReplaceAllString(text, "\n\n")
+	text = webFetchAnyTagRe.ReplaceAllString(text, " ")
+	text = html.UnescapeString(text)
+
+	// Whitespace normalization: collapse space runs, trim line edges, cap blank
+	// runs at one empty line.
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lines[i] = strings.TrimSpace(webFetchSpaceRunRe.ReplaceAllString(line, " "))
+	}
+	text = strings.Join(lines, "\n")
+	text = webFetchBlankRunRe.ReplaceAllString(text, "\n\n")
+	return strings.TrimSpace(text)
+}
+
+// looksLikeHTML reports whether a response should be treated as an HTML
+// document, by Content-Type first and a body sniff as fallback (servers
+// mislabel HTML as text/plain often enough to matter).
+func looksLikeHTML(contentType, body string) bool {
+	lowered := strings.ToLower(contentType)
+	if strings.Contains(lowered, "text/html") || strings.Contains(lowered, "application/xhtml") {
+		return true
+	}
+	if lowered != "" && !strings.Contains(lowered, "text/plain") {
+		return false
+	}
+	head := strings.ToLower(strings.TrimSpace(body))
+	if len(head) > 512 {
+		head = head[:512]
+	}
+	return strings.Contains(head, "<!doctype html") || strings.Contains(head, "<html")
+}

internal/tools/web_fetch_markdown_test.go

@@ -0,0 +1,127 @@
+package tools
+
+import (
+	"context"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+const sampleHTML = `<!DOCTYPE html>
+<html><head><title>ignored</title><style>body{color:red}</style></head>
+<body>
+<script>var tracking = "noise";</script>
+<h1>Main Title</h1>
+<p>First paragraph with a <a href="https://example.com/docs">docs link</a> and &amp; entity.</p>
+<ul><li>alpha</li><li>beta</li></ul>
+<!-- hidden comment -->
+<h2>Section</h2>
+<p>Body   with   extra   spaces.</p>
+</body></html>`
+
+func TestHTMLToMarkdown(t *testing.T) {
+	markdown := htmlToMarkdown(sampleHTML)
+
+	for _, want := range []string{
+		"# Main Title",
+		"## Section",
+		"[docs link](https://example.com/docs)",
+		"- alpha",
+		"- beta",
+		"with a", // paragraph text survives
+		"& entity",
+	} {
+		if !strings.Contains(markdown, want) {
+			t.Fatalf("markdown missing %q:\n%s", want, markdown)
+		}
+	}
+	for _, banned := range []string{"tracking", "color:red", "hidden comment", "<p>", "</html>", "ignored"} {
+		if strings.Contains(markdown, banned) {
+			t.Fatalf("markdown must not contain %q:\n%s", banned, markdown)
+		}
+	}
+	if strings.Contains(markdown, "extra   spaces") {
+		t.Fatalf("space runs must collapse:\n%s", markdown)
+	}
+	if strings.Contains(markdown, "\n\n\n") {
+		t.Fatalf("blank-line runs must be capped:\n%s", markdown)
+	}
+}
+
+func TestLooksLikeHTML(t *testing.T) {
+	cases := []struct {
+		contentType string
+		body        string
+		want        bool
+	}{
+		{"text/html; charset=utf-8", "anything", true},
+		{"application/xhtml+xml", "anything", true},
+		{"application/json", `{"html":"<html>"}`, false},
+		{"text/plain", "<!doctype html><html>", true}, // mislabeled HTML sniffed
+		{"text/plain", "just text", false},
+		{"", "<html><body>x</body></html>", true},
+	}
+	for _, c := range cases {
+		if got := looksLikeHTML(c.contentType, c.body); got != c.want {
+			t.Errorf("looksLikeHTML(%q, %.20q) = %v, want %v", c.contentType, c.body, got, c.want)
+		}
+	}
+}
+
+func TestWebFetchConvertsHTMLByDefault(t *testing.T) {
+	tool := newWebFetchToolWithClient(webFetchTestClient(func(request *http.Request) (*http.Response, error) {
+		return webFetchTestResponse(request, http.StatusOK, "text/html; charset=utf-8", sampleHTML), nil
+	}))
+
+	result := tool.Run(context.Background(), map[string]any{"url": "https://example.com/page"})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %s: %s", result.Status, result.Output)
+	}
+	if !strings.Contains(result.Output, "# Main Title") || strings.Contains(result.Output, "<h1>") {
+		t.Fatalf("HTML must convert to markdown by default:\n%s", result.Output)
+	}
+	if result.Meta["converted"] != "true" {
+		t.Fatalf("converted meta must be true: %#v", result.Meta)
+	}
+}
+
+func TestWebFetchRawFormatSkipsConversion(t *testing.T) {
+	tool := newWebFetchToolWithClient(webFetchTestClient(func(request *http.Request) (*http.Response, error) {
+		return webFetchTestResponse(request, http.StatusOK, "text/html", sampleHTML), nil
+	}))
+
+	result := tool.Run(context.Background(), map[string]any{"url": "https://example.com/page", "format": "raw"})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %s: %s", result.Status, result.Output)
+	}
+	if !strings.Contains(result.Output, "<h1>Main Title</h1>") {
+		t.Fatalf("format=raw must keep original HTML:\n%s", result.Output)
+	}
+	if result.Meta["converted"] != "false" {
+		t.Fatalf("converted meta must be false: %#v", result.Meta)
+	}
+}
+
+func TestWebFetchLeavesNonHTMLUntouched(t *testing.T) {
+	tool := newWebFetchToolWithClient(webFetchTestClient(func(request *http.Request) (*http.Response, error) {
+		return webFetchTestResponse(request, http.StatusOK, "application/json", `{"key":"<b>value</b>"}`), nil
+	}))
+
+	result := tool.Run(context.Background(), map[string]any{"url": "https://example.com/api"})
+	if result.Status != StatusOK {
+		t.Fatalf("expected ok, got %s: %s", result.Status, result.Output)
+	}
+	if !strings.Contains(result.Output, `{"key":"<b>value</b>"}`) {
+		t.Fatalf("non-HTML must pass through untouched:\n%s", result.Output)
+	}
+}
+
+func TestWebFetchRejectsInvalidFormat(t *testing.T) {
+	tool := newWebFetchToolWithClient(webFetchTestClient(func(request *http.Request) (*http.Response, error) {
+		return webFetchTestResponse(request, http.StatusOK, "text/plain", "x"), nil
+	}))
+	result := tool.Run(context.Background(), map[string]any{"url": "https://example.com", "format": "xml"})
+	if result.Status != StatusError || !strings.Contains(result.Output, "format must be") {
+		t.Fatalf("invalid format must be rejected: %s %s", result.Status, result.Output)
+	}
+}

internal/tools/write_file.go

@@ -44,7 +44,7 @@ func (tool writeFileTool) Run(ctx context.Context, args map[string]any) Result {
 	return tool.RunWithOptions(ctx, args, RunOptions{})
 }
 
-func (tool writeFileTool) RunWithOptions(_ context.Context, args map[string]any, options RunOptions) Result {
+func (tool writeFileTool) RunWithOptions(ctx context.Context, args map[string]any, options RunOptions) Result {
 	requestedPath, err := aliasedStringArg(args, []string{"path", "file", "file_path", "filename"}, "", true, false)
 	if err != nil {
 		return errorResult("Error: Invalid arguments for write_file: " + err.Error())
@@ -110,6 +110,10 @@ func (tool writeFileTool) RunWithOptions(_ context.Context, args map[string]any,
 	if err := os.WriteFile(absolutePath, []byte(content), 0o644); err != nil {
 		return errorResult("Error writing file " + relativePath + ": " + err.Error())
 	}
+	// Optional format-on-write (ZERO_FORMAT_ON_WRITE). Must run BEFORE the
+	// FileTracker baseline: recording pre-format content would make the very
+	// next edit look like an external modification and trip the conflict guard.
+	content = maybeFormatWrittenFile(ctx, absolutePath, content)
 	// Baseline the freshly written content so a later edit/overwrite in this
 	// session compares against what is now on disk.
 	newInfo, _ := os.Stat(absolutePath)
@@ -126,6 +130,7 @@ func (tool writeFileTool) RunWithOptions(_ context.Context, args map[string]any,
 		lines++
 	}
 	summary := fmt.Sprintf("%s %s (%d lines).", verb, relativePath, lines)
+	summary += inlineDiagnostics(ctx, options, absolutePath, relativePath)
 	result := okResult(summary)
 	result.ChangedFiles = []string{relativePath}
 	// Card-only preview: a real unified diff (all-green for a create, red/green for

internal/tui/commands.go

@@ -42,7 +42,6 @@ const (
 	commandSelfCorrect
 	commandTurns
 	commandNew
-	commandFast
 	commandUnknown
 )
 
@@ -236,13 +235,6 @@ var commandDefinitions = []commandDefinition{
 		description: "Show or set reasoning effort for supported models.",
 		kind:        commandEffort,
 	},
-	{
-		name:        "/fast",
-		usage:       "/fast [on|off]",
-		group:       commandGroupModel,
-		description: "Enable fast mode for the current model (/fast off to disable).",
-		kind:        commandFast,
-	},
 	{
 		name:        "/style",
 		usage:       "/style [list|balanced|concise|explanatory|review]",

internal/tui/composer.go

@@ -306,7 +306,7 @@ func (m model) composerPositionAtVisualCell(x int, y int, width int) (int, bool)
 func (m model) applyComposerKey(msg tea.KeyMsg) (model, bool) {
 	state := m.currentComposerState()
 	switch {
-	case keyIs(msg, tea.KeyEnter) && keyAlt(msg):
+	case keyIs(msg, tea.KeyEnter) && (keyAlt(msg) || keyShift(msg)):
 		m = m.insertComposerTextWithPastePreview(state, "\n", "")
 	case keyCtrl(msg, 'j'):
 		m = m.insertComposerTextWithPastePreview(state, "\n", "")

internal/tui/composer_test.go

@@ -299,7 +299,8 @@ func TestModifiedEnterInsertsNewlineWithoutSubmitting(t *testing.T) {
 		key  tea.Msg
 	}{
 		{name: "alt enter", key: testKeyAlt(tea.KeyEnter)},
-		{name: "shift enter", key: testKeyCtrl('j')},
+		{name: "shift enter", key: testKeyShift(tea.KeyEnter)},
+		{name: "ctrl j", key: testKeyCtrl('j')},
 	}
 
 	for _, tc := range tests {

internal/tui/fast_command.go

@@ -1,111 +0,0 @@
-package tui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/Gitlawb/zero/internal/modelregistry"
-)
-
-// fastPlan is the pure decision `/fast` makes before touching any state: either
-// a terminal message to show the user, or a target model to switch to.
-type fastPlan struct {
-	message  string // terminal notice; shown as-is when targetID is empty
-	targetID string // model to switch to ("" means no switch — show message)
-	toFast   bool   // the target is a fast model (drives the ⚡ prefix)
-}
-
-// planFastCommand resolves what `/fast [on|off]` should do for the current model
-// using only the registry — no side effects. State is DERIVED from the model
-// identity: the session is "in fast mode" iff the current model has a base
-// variant. Returns a terminal message, or a target model to switch to.
-func planFastCommand(registry modelregistry.Registry, currentModel, arg string) fastPlan {
-	// 1. Parse the argument (case-insensitive): no arg / "on" => enable fast,
-	//    "off" => return to base, anything else => usage error.
-	enable := true
-	switch strings.ToLower(strings.TrimSpace(arg)) {
-	case "", "on":
-		enable = true
-	case "off":
-		enable = false
-	default:
-		return fastPlan{message: fmt.Sprintf("⚡ /fast takes on or off, not %q", strings.TrimSpace(arg))}
-	}
-
-	// 2. Read the current model.
-	current := strings.TrimSpace(currentModel)
-	if current == "" {
-		return fastPlan{message: "⚡ Pick a model first · /model"}
-	}
-	short := modelShortName(registry, current)
-
-	// 3. Derived state: in fast mode iff the current model has a base variant.
-	_, isFast := registry.BaseVariant(current)
-
-	// 4. No-op cases — already in the requested state.
-	if enable && isFast {
-		return fastPlan{message: "⚡ Already in the fast lane · " + short}
-	}
-	if !enable && !isFast {
-		return fastPlan{message: "Already on base · " + short}
-	}
-
-	// 5. Resolve the target variant.
-	var target modelregistry.ModelEntry
-	var ok bool
-	if enable {
-		target, ok = registry.FastVariant(current)
-	} else {
-		target, ok = registry.BaseVariant(current)
-	}
-	if !ok {
-		return fastPlan{message: "⚡ No fast lane for " + short}
-	}
-
-	// Switching TO a fast model iff the target itself has a base variant.
-	_, toFast := registry.BaseVariant(target.ID)
-	return fastPlan{targetID: target.ID, toFast: toFast}
-}
-
-// handleFastCommand implements `/fast [on|off]`: toggle the session model between
-// its base and fast variant within the same family. The actual switch is
-// delegated to handleModelCommand — the same path /model uses — so provider
-// rebuild, the compaction-before-switch guard, and persistence all apply; this
-// never mutates model state directly.
-func (m model) handleFastCommand(arg string) (model, string) {
-	registry, err := modelregistry.DefaultRegistry()
-	if err != nil {
-		return m, "Failed to load the model registry: " + err.Error()
-	}
-
-	plan := planFastCommand(registry, m.modelName, arg)
-	if plan.targetID == "" {
-		return m, plan.message
-	}
-
-	var switchText string
-	m, switchText = m.handleModelCommand(plan.targetID)
-	if m.modelName != plan.targetID {
-		// The switch did not complete — either an error, or a "compact first"
-		// guard prompt from handleModelCommand. Surface its own message so the
-		// user sees the real reason instead of a misleading "Switched to ...".
-		return m, switchText
-	}
-
-	short := modelShortName(registry, plan.targetID)
-	if plan.toFast {
-		return m, "⚡ Fast lane on · " + short
-	}
-	return m, "Fast lane off · " + short
-}
-
-// modelShortName returns a model's short display name, falling back to the id
-// when the model is unknown or has no display name.
-func modelShortName(registry modelregistry.Registry, id string) string {
-	if entry, ok := registry.Get(id); ok {
-		if name := strings.TrimSpace(entry.DisplayName); name != "" {
-			return name
-		}
-	}
-	return strings.TrimSpace(id)
-}

internal/tui/fast_command_test.go

@@ -1,200 +0,0 @@
-package tui
-
-import (
-	"context"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Gitlawb/zero/internal/config"
-	"github.com/Gitlawb/zero/internal/modelregistry"
-	"github.com/Gitlawb/zero/internal/zeroruntime"
-)
-
-func fastTestRegistry(t *testing.T) modelregistry.Registry {
-	t.Helper()
-	registry, err := modelregistry.DefaultRegistry()
-	if err != nil {
-		t.Fatalf("DefaultRegistry() error = %v", err)
-	}
-	return registry
-}
-
-// planFastCommand is the pure decision layer — every argument/state case is
-// exercised here without touching the switch machinery.
-func TestPlanFastCommand(t *testing.T) {
-	registry := fastTestRegistry(t)
-
-	cases := []struct {
-		name        string
-		model       string
-		arg         string
-		wantMessage string // substring expected when the plan is terminal
-		wantTarget  string // model id expected when the plan switches
-		wantToFast  bool
-	}{
-		{name: "invalid arg", model: "gpt-4.1", arg: "turbo", wantMessage: `/fast takes on or off, not "turbo"`},
-		{name: "no model set", model: "", arg: "on", wantMessage: "Pick a model first"},
-		{name: "enable while already fast", model: "gpt-4.1-mini", arg: "on", wantMessage: "Already in the fast lane"},
-		{name: "disable while already base", model: "gpt-4.1", arg: "off", wantMessage: "Already on base"},
-		{name: "enable with no fast variant", model: "claude-opus-4.1", arg: "on", wantMessage: "No fast lane"},
-		{name: "enable (no arg) resolves fast", model: "gpt-4.1", arg: "", wantTarget: "gpt-4.1-mini", wantToFast: true},
-		{name: "enable (on) resolves fast", model: "gpt-4.1", arg: "ON", wantTarget: "gpt-4.1-mini", wantToFast: true},
-		{name: "disable resolves base", model: "gpt-4.1-mini", arg: "off", wantTarget: "gpt-4.1", wantToFast: false},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			plan := planFastCommand(registry, tc.model, tc.arg)
-			if tc.wantTarget != "" {
-				canon, ok := registry.Resolve(tc.wantTarget)
-				if !ok {
-					t.Fatalf("test fixture %q does not resolve", tc.wantTarget)
-				}
-				if plan.targetID != canon.ID {
-					t.Fatalf("targetID = %q, want %q", plan.targetID, canon.ID)
-				}
-				if plan.toFast != tc.wantToFast {
-					t.Fatalf("toFast = %v, want %v", plan.toFast, tc.wantToFast)
-				}
-				if plan.message != "" {
-					t.Fatalf("switching plan should carry no message, got %q", plan.message)
-				}
-				return
-			}
-			if plan.targetID != "" {
-				t.Fatalf("expected a terminal message, got target %q", plan.targetID)
-			}
-			if !strings.Contains(plan.message, tc.wantMessage) {
-				t.Fatalf("message = %q, want it to contain %q", plan.message, tc.wantMessage)
-			}
-		})
-	}
-}
-
-// handleFastCommand's terminal cases return the plan message without switching,
-// so a bare model exercises them.
-func TestHandleFastCommandTerminalCases(t *testing.T) {
-	cases := []struct {
-		name         string
-		model        string
-		arg          string
-		wantContains string
-	}{
-		{"invalid arg", "gpt-4.1", "sideways", `/fast takes on or off, not "sideways"`},
-		{"no model", "", "on", "Pick a model first"},
-		{"already fast", "gpt-4.1-mini", "on", "Already in the fast lane"},
-		{"already base", "gpt-4.1", "off", "Already on base"},
-		{"no fast variant", "claude-opus-4.1", "on", "No fast lane"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			m := model{modelName: tc.model}
-			got, notice := m.handleFastCommand(tc.arg)
-			if got.modelName != tc.model {
-				t.Fatalf("model must not change on a terminal case: %q -> %q", tc.model, got.modelName)
-			}
-			if !strings.Contains(notice, tc.wantContains) {
-				t.Fatalf("notice = %q, want it to contain %q", notice, tc.wantContains)
-			}
-		})
-	}
-}
-
-func newFastTestModel(t *testing.T, modelID string) model {
-	t.Helper()
-	configPath := filepath.Join(t.TempDir(), "zero.json")
-	profile := config.ProviderProfile{
-		Name:         "openai",
-		ProviderKind: config.ProviderKindOpenAI,
-		BaseURL:      config.OpenAIBaseURL,
-		APIKey:       "sk-test",
-		Model:        modelID,
-	}
-	if _, err := config.UpsertProvider(configPath, profile, true); err != nil {
-		t.Fatalf("write user config: %v", err)
-	}
-	return newModel(context.Background(), Options{
-		UserConfigPath:  configPath,
-		ProviderName:    "openai",
-		ModelName:       modelID,
-		ProviderProfile: profile,
-		Provider:        &fakeProvider{},
-		NewProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
-			return &fakeProvider{}, nil
-		},
-	})
-}
-
-// Enabling switches base -> fast with a ⚡ notice; disabling switches back to the
-// base with a plain notice. Uses the same switch path /model uses.
-func TestHandleFastCommandSwitchesToFastAndBack(t *testing.T) {
-	registry := fastTestRegistry(t)
-	m := newFastTestModel(t, "gpt-4.1")
-
-	m, notice := m.handleFastCommand("on")
-	if m.modelName != "gpt-4.1-mini" {
-		t.Fatalf("enable: modelName = %q, want gpt-4.1-mini", m.modelName)
-	}
-	if want := "⚡ Fast lane on · " + modelShortName(registry, "gpt-4.1-mini"); notice != want {
-		t.Fatalf("enable notice = %q, want exactly %q (bolt + fast-lane-on + target short name)", notice, want)
-	}
-
-	m, notice = m.handleFastCommand("off")
-	if m.modelName != "gpt-4.1" {
-		t.Fatalf("disable: modelName = %q, want gpt-4.1", m.modelName)
-	}
-	if want := "Fast lane off · " + modelShortName(registry, "gpt-4.1"); notice != want {
-		t.Fatalf("disable notice = %q, want exactly %q (plain fast-lane-off, no bolt)", notice, want)
-	}
-}
-
-// The no-op and no-variant notices must carry their full spec decoration — the ⚡
-// prefix and the (<short>) name — so a regression dropping either fails loudly
-// rather than passing a bare substring assertion.
-func TestFastCommandNoOpAndNoVariantMessagesAreDecorated(t *testing.T) {
-	registry := fastTestRegistry(t)
-
-	plan := planFastCommand(registry, "gpt-4.1-mini", "on")
-	if want := "⚡ Already in the fast lane · " + modelShortName(registry, "gpt-4.1-mini"); plan.message != want {
-		t.Fatalf("already-fast message = %q, want %q", plan.message, want)
-	}
-
-	plan = planFastCommand(registry, "gpt-4.1", "off")
-	if want := "Already on base · " + modelShortName(registry, "gpt-4.1"); plan.message != want {
-		t.Fatalf("already-base message = %q, want %q", plan.message, want)
-	}
-
-	// An unknown / off-catalog model id also reaches the no-variant branch, where
-	// <short> falls back to the raw id.
-	plan = planFastCommand(registry, "some-custom-live-provider-model", "on")
-	if want := "⚡ No fast lane for some-custom-live-provider-model"; plan.message != want {
-		t.Fatalf("no-variant (unknown id) message = %q, want %q", plan.message, want)
-	}
-}
-
-// When the underlying switch fails, /fast surfaces the error and leaves the
-// model unchanged (here: a valid base model but no provider profile to rebuild).
-func TestHandleFastCommandSurfacesSwitchError(t *testing.T) {
-	m := model{modelName: "gpt-4.1"} // no providerProfile / newProvider wired
-	got, notice := m.handleFastCommand("on")
-	if got.modelName != "gpt-4.1" {
-		t.Fatalf("model must be unchanged on switch failure, got %q", got.modelName)
-	}
-	if strings.HasPrefix(notice, "⚡ Fast lane on ") || strings.HasPrefix(notice, "Fast lane off ") {
-		t.Fatalf("a failed switch must not claim success, got %q", notice)
-	}
-	if strings.TrimSpace(notice) == "" {
-		t.Fatal("a failed switch must surface a reason")
-	}
-}
-
-func TestModelShortName(t *testing.T) {
-	registry := fastTestRegistry(t)
-	if got := modelShortName(registry, "gpt-4.1"); strings.TrimSpace(got) == "" {
-		t.Fatal("a known model should resolve to a non-empty short name")
-	}
-	if got := modelShortName(registry, "totally-unknown-model-xyz"); got != "totally-unknown-model-xyz" {
-		t.Fatalf("an unknown model short name = %q, want the raw id", got)
-	}
-}

internal/tui/fast_marker.go

@@ -1,87 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"time"
-
-	tea "charm.land/bubbletea/v2"
-	"charm.land/lipgloss/v2"
-
-	"github.com/Gitlawb/zero/internal/modelregistry"
-)
-
-// fastMarkerGlyph is the compact "f" badge shown next to a model that has an
-// available fast variant — i.e. one where `/fast on` would switch down to a
-// faster same-family model. It marks the BASE model, never the fast one.
-const fastMarkerGlyph = "f"
-
-// fastVariantEntryFor resolves the fast variant of an arbitrary model id, if any.
-// Like modelContextWindow, it reads the default registry on demand rather than
-// caching derived state, so a marker can never go stale after a model switch.
-// DefaultRegistry is memoized, so even the per-frame callers (the active-model
-// chip renders every frame; the pickers render per keystroke) pay only a map
-// lookup here, not a registry rebuild.
-func fastVariantEntryFor(id string) (modelregistry.ModelEntry, bool) {
-	id = strings.TrimSpace(id)
-	if id == "" {
-		return modelregistry.ModelEntry{}, false
-	}
-	registry, err := modelregistry.DefaultRegistry()
-	if err != nil {
-		return modelregistry.ModelEntry{}, false
-	}
-	return registry.FastVariant(id)
-}
-
-// currentModelFastVariant resolves the fast variant of the session's active model.
-func (m model) currentModelFastVariant() (modelregistry.ModelEntry, bool) {
-	return fastVariantEntryFor(m.modelName)
-}
-
-// renderFastBadge renders the "f" fast-mode marker in the given (surface-aware)
-// style, prefixed with a space so it reads as a distinct badge rather than a
-// trailing letter of the adjacent model name.
-func renderFastBadge(style lipgloss.Style) string {
-	return " " + style.Render(fastMarkerGlyph)
-}
-
-// fastVariantHint is the one-line reveal shown against a focused/selected
-// fast-capable model. The TUI has no floating-tooltip primitive, so the "hover"
-// affordance is this inline detail on the active row: it names the target model
-// and the command that gets there.
-func fastVariantHint(variantName string) string {
-	variantName = strings.TrimSpace(variantName)
-	if variantName == "" {
-		return ""
-	}
-	return "⚡ fast: " + variantName + " · /fast on"
-}
-
-// fastToastDuration is how long a /fast toast stays up before auto-dismissing.
-const fastToastDuration = 3 * time.Second
-
-// fastToastExpiredMsg clears a fast-lane toast after fastToastDuration. It is
-// seq-gated so a newer toast is never dismissed by an older timer.
-type fastToastExpiredMsg struct{ seq int }
-
-// showFastToast raises a transient fast-lane notice in the row above the composer
-// and schedules its dismissal. It replaces the persistent transcript line the
-// /fast command used to append, so repeated toggles never pile up in history.
-func (m model) showFastToast(text string) (model, tea.Cmd) {
-	text = strings.TrimSpace(strings.ReplaceAll(text, "\n", " "))
-	if text == "" {
-		return m, nil
-	}
-	m.fastToastSeq++
-	m.fastToast = text
-	seq := m.fastToastSeq
-	return m, tea.Tick(fastToastDuration, func(time.Time) tea.Msg {
-		return fastToastExpiredMsg{seq: seq}
-	})
-}
-
-// renderFastToast styles the toast as a filled brand pill so it reads as a
-// transient popup rather than a permanent status line.
-func renderFastToast(text string) string {
-	return zeroTheme.badge.Render(" " + strings.TrimSpace(text) + " ")
-}

internal/tui/fast_marker_test.go

@@ -1,151 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/charmbracelet/x/ansi"
-
-	"github.com/Gitlawb/zero/internal/modelregistry"
-)
-
-// hasFastBadge reports whether a rendered (styled) line ends with the " f"
-// fast-mode badge, ignoring trailing layout padding. Labels used in these tests
-// deliberately contain no trailing " f" so the badge is unambiguous.
-func hasFastBadge(rendered string) bool {
-	return strings.HasSuffix(strings.TrimRight(ansi.Strip(rendered), " "), " "+fastMarkerGlyph)
-}
-
-func TestFastVariantHint(t *testing.T) {
-	if got := fastVariantHint("Claude Haiku 4.5"); got != "⚡ fast: Claude Haiku 4.5 · /fast on" {
-		t.Errorf("fastVariantHint = %q", got)
-	}
-	if got := fastVariantHint("   "); got != "" {
-		t.Errorf("fastVariantHint(blank) = %q, want empty", got)
-	}
-}
-
-func TestRenderFastBadge(t *testing.T) {
-	if got := ansi.Strip(renderFastBadge(zeroTheme.accent)); got != " "+fastMarkerGlyph {
-		t.Errorf("renderFastBadge visible text = %q, want %q", got, " "+fastMarkerGlyph)
-	}
-}
-
-// The active-model chip carries the "f" badge only when the current model has a
-// fast variant — base models yes, fast models and unpaired top-tier models no.
-func TestTitleModelSegmentFastBadge(t *testing.T) {
-	cases := []struct {
-		model string
-		want  bool
-	}{
-		{"gpt-4.1", true},          // base with a fast variant
-		{"gpt-4.1-mini", false},    // the fast variant itself has none
-		{"claude-opus-4.1", false}, // top-tier, intentionally unpaired
-		{"definitely-not-real", false},
-		{"", false},
-	}
-	for _, tc := range cases {
-		seg := model{modelName: tc.model}.titleModelSegment()
-		if got := hasFastBadge(seg); got != tc.want {
-			t.Errorf("titleModelSegment(%q) badge = %v, want %v (visible %q)", tc.model, got, tc.want, ansi.Strip(seg))
-		}
-	}
-}
-
-// A /model picker row shows the badge iff its FastVariant field is populated,
-// and the field is populated only for base models by decorateFastVariantItems.
-func TestRenderModelPickerRowFastBadge(t *testing.T) {
-	withFast := renderModelPickerRow(60, false, pickerItem{Label: "gpt-4.1", Value: "gpt-4.1", FastVariant: "GPT-4.1 mini"})
-	if !hasFastBadge(withFast) {
-		t.Errorf("fast-capable row missing badge: %q", ansi.Strip(withFast))
-	}
-	withoutFast := renderModelPickerRow(60, false, pickerItem{Label: "gpt-4.1", Value: "gpt-4.1"})
-	if hasFastBadge(withoutFast) {
-		t.Errorf("row without FastVariant should have no badge: %q", ansi.Strip(withoutFast))
-	}
-}
-
-func TestModelPickerItemDetailIncludesFastHint(t *testing.T) {
-	detail := modelPickerItemDetail(pickerItem{Label: "GPT-4.1", Value: "gpt-4.1", FastVariant: "GPT-4.1 mini"})
-	if !strings.Contains(detail, "⚡ fast: GPT-4.1 mini · /fast on") {
-		t.Errorf("detail missing fast hint: %q", detail)
-	}
-	plain := modelPickerItemDetail(pickerItem{Label: "Claude Opus 4.1", Value: "claude-opus-4.1"})
-	if strings.Contains(plain, "fast:") {
-		t.Errorf("non-fast detail should have no hint: %q", plain)
-	}
-}
-
-// decorateFastVariantItems stamps the fast variant's display name onto base-model
-// rows only, using the real registry — the single source of truth for the badge.
-func TestDecorateFastVariantItems(t *testing.T) {
-	registry, err := modelregistry.DefaultRegistry()
-	if err != nil {
-		t.Fatalf("DefaultRegistry: %v", err)
-	}
-	items := []pickerItem{
-		{Value: "gpt-4.1"},           // base -> GPT-4.1 mini
-		{Value: "gpt-4.1-mini"},      // fast, no variant
-		{Value: "claude-opus-4.1"},   // unpaired
-		{Value: "some-custom-model"}, // not in registry
-		{Value: ""},
-	}
-	decorateFastVariantItems(registry, items)
-	if items[0].FastVariant != "GPT-4.1 mini" {
-		t.Errorf("gpt-4.1 FastVariant = %q, want %q", items[0].FastVariant, "GPT-4.1 mini")
-	}
-	for _, i := range []int{1, 2, 3, 4} {
-		if items[i].FastVariant != "" {
-			t.Errorf("items[%d].FastVariant = %q, want empty", i, items[i].FastVariant)
-		}
-	}
-}
-
-func TestShowFastToast(t *testing.T) {
-	// A non-empty message raises the toast, bumps the seq, and schedules dismissal.
-	m, cmd := model{}.showFastToast("⚡ Fast lane on · GPT-4.1 mini")
-	if m.fastToast != "⚡ Fast lane on · GPT-4.1 mini" {
-		t.Fatalf("fastToast = %q", m.fastToast)
-	}
-	if m.fastToastSeq != 1 {
-		t.Fatalf("fastToastSeq = %d, want 1", m.fastToastSeq)
-	}
-	if cmd == nil {
-		t.Fatal("showFastToast must return a dismissal tick cmd")
-	}
-
-	// A multi-line switch-guard message is flattened so the toast stays one line
-	// (the footer slot is fixed-height).
-	m2, _ := model{}.showFastToast("Model\nCannot switch while a run is active.")
-	if strings.Contains(m2.fastToast, "\n") {
-		t.Fatalf("toast must be flattened to one line, got %q", m2.fastToast)
-	}
-
-	// Blank text is a no-op: no toast, no timer.
-	m3, cmd3 := model{}.showFastToast("   ")
-	if m3.fastToast != "" || cmd3 != nil {
-		t.Fatalf("blank text should not raise a toast, got %q / cmd!=nil=%v", m3.fastToast, cmd3 != nil)
-	}
-}
-
-func TestRenderFastToastShowsMessage(t *testing.T) {
-	got := ansi.Strip(renderFastToast("⚡ No fast lane for gpt-5.5"))
-	if !strings.Contains(got, "⚡ No fast lane for gpt-5.5") {
-		t.Fatalf("rendered toast = %q, want it to contain the message", got)
-	}
-}
-
-func TestProviderWizardModelFastBadgeAndHint(t *testing.T) {
-	wizard := &providerWizardState{selectedModel: 0}
-	withFast := wizard.renderSelectableModel(60, 0, providerWizardModel{ID: "gpt-4.1"})
-	if !hasFastBadge(withFast) {
-		t.Errorf("provider wizard base-model row missing badge: %q", ansi.Strip(withFast))
-	}
-	plain := wizard.renderSelectableModel(60, 1, providerWizardModel{ID: "claude-opus-4.1"})
-	if hasFastBadge(plain) {
-		t.Errorf("provider wizard unpaired-model row should have no badge: %q", ansi.Strip(plain))
-	}
-	if detail := providerWizardModelDetail(providerWizardModel{ID: "gpt-4.1"}); !strings.Contains(detail, "⚡ fast:") {
-		t.Errorf("provider wizard detail missing fast hint: %q", detail)
-	}
-}

internal/tui/image_attach.go

@@ -98,16 +98,9 @@ func (m model) modelSupportsVisionTUI() bool {
 	if trimmed == "" {
 		return false
 	}
-	// Check the curated registry first.
-	registry, err := modelregistry.DefaultRegistry()
-	if err == nil {
-		if modelregistry.SupportsVision(registry, trimmed) {
-			return true
-		}
-		// Catalog knows this model and it lacks vision — trust that.
-		if _, known := registry.Get(trimmed); known {
-			return false
-		}
+	// The curated catalog is authoritative only when it knows the model.
+	if entry, known := m.modelCatalog.Resolve(trimmed); known {
+		return entry.Supports(modelregistry.ModelCapabilityVision)
 	}
 	// Check the discovered model list (from models.dev) for InputModalities
 	// containing "image". This covers custom/ollama/cloud models not in the

internal/tui/keybinding_help.go

@@ -36,7 +36,7 @@ func (m model) buildKeybindingGroups() []keybindingGroup {
 			title: "Chat",
 			bindings: []keybinding{
 				{"Enter", "send the message"},
-				{"Alt+Enter", "insert a newline (multi-line compose)"},
+				{"Shift+Enter / Alt+Enter", "insert a newline (multi-line compose)"},
 				{"Esc (\u00d72)", "cancel the run / dismiss a popup / clear the input"},
 				{"Ctrl+C", "cancel the run, then quit"},
 				{"?", "show this help (on an empty input)"},

internal/tui/model.go

@@ -67,6 +67,7 @@ type model struct {
 	gitBranch                   string
 	providerName                string
 	modelName                   string
+	modelCatalog                modelregistry.Registry
 	providerProfile             config.ProviderProfile
 	savedProviders              []config.ProviderProfile
 	provider                    zeroruntime.Provider
@@ -326,14 +327,9 @@ type model struct {
 	// mouse cursor with no button pressed, so it renders in a distinct style —
 	// the visual cue that it's clickable. Requires AllMotion mouse reporting
 	// (see wantsMouseCapture) since idle cursor movement carries no button.
-	hover         hoverTarget
-	copyStatus    string
-	copyStatusSeq int
-	// fastToast is a transient /fast notice shown in the row above the composer for
-	// fastToastDuration, then auto-cleared (seq-gated). It keeps ephemeral fast-lane
-	// feedback out of the persistent transcript.
-	fastToast         string
-	fastToastSeq      int
+	hover             hoverTarget
+	copyStatus        string
+	copyStatusSeq     int
 	exitConfirmActive bool
 	exitConfirmSeq    int
 	// cancelConfirmActive/cancelConfirmSeq mirror exitConfirmActive/exitConfirmSeq
@@ -666,9 +662,13 @@ func newModel(ctx context.Context, options Options) model {
 		sessionStore = sessions.NewStore(sessions.StoreOptions{})
 	}
 	sandboxStore := options.SandboxStore
+	modelCatalog, err := modelregistry.DefaultRegistry()
+	if err != nil {
+		panic(err)
+	}
 	usageTracker := options.UsageTracker
 	if usageTracker == nil {
-		usageTracker = usage.NewTracker(usage.TrackerOptions{})
+		usageTracker = usage.NewTracker(usage.TrackerOptions{Registry: &modelCatalog})
 	}
 	prService := options.PrService
 	if prService == nil {
@@ -720,6 +720,7 @@ func newModel(ctx context.Context, options Options) model {
 		gitBranch:                   gitBranch(cwd),
 		providerName:                options.ProviderName,
 		modelName:                   options.ModelName,
+		modelCatalog:                modelCatalog,
 		providerProfile:             options.ProviderProfile,
 		favoriteModels:              favoriteModelSet(options.FavoriteModels),
 		recapsEnabled:               options.RecapsEnabled,
@@ -1020,11 +1021,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.copyStatus = ""
 		}
 		return m, nil
-	case fastToastExpiredMsg:
-		if msg.seq == m.fastToastSeq {
-			m.fastToast = ""
-		}
-		return m, nil
 	case exitConfirmExpiredMsg:
 		if msg.seq == m.exitConfirmSeq {
 			m.exitConfirmActive = false
@@ -1259,7 +1255,7 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.picker != nil {
 				return m.choosePicker()
 			}
-			if keyAlt(msg) {
+			if keyAlt(msg) || keyShift(msg) {
 				if next, ok := m.applyComposerKey(msg); ok {
 					return next, nil
 				}
@@ -2357,9 +2353,7 @@ func (m model) footerView(width int) string {
 	// a faint idle affordance — discoverable key hints on the left, a jump-to-bottom
 	// cue on the right when scrolled up. Always one line (blank when nothing shows),
 	// so the footer height is unchanged.
-	if toast := strings.TrimSpace(m.fastToast); toast != "" {
-		footer.WriteString(rightAlignedLine(renderFastToast(toast), width))
-	} else if copyStatus := strings.TrimSpace(m.copyStatus); copyStatus != "" {
+	if copyStatus := strings.TrimSpace(m.copyStatus); copyStatus != "" {
 		footer.WriteString(rightAlignedLine(zeroTheme.ink.Render(copyStatus), width))
 	} else if left, right := m.composerIdleHint(), m.jumpToBottomHint(); left != "" || right != "" {
 		footer.WriteString(fitStyledLine(joinHeaderLine("  "+left, right, width), width))
@@ -3826,12 +3820,6 @@ func (m model) handleSubmit() (tea.Model, tea.Cmd) {
 		m, text = m.handleEffortCommand(command.text)
 		m.transcript = reduceTranscript(m.transcript, transcriptAction{kind: actionAppendSystem, text: text})
 		return m, nil
-	case commandFast:
-		var text string
-		m, text = m.handleFastCommand(command.text)
-		// Fast-lane feedback is ephemeral: show it as a transient toast above the
-		// composer (auto-dismissed) instead of a permanent transcript line.
-		return m.showFastToast(text)
 	case commandStyle:
 		text := ""
 		m, text = m.handleStyleCommand(command.text)
@@ -4220,6 +4208,10 @@ func (m model) runAgentWithOptions(runID int, runCtx context.Context, prompt str
 				IncludeLSP:   true,
 				Autonomy:     selfCorrectAutonomyForMode(options.PermissionMode),
 			})
+			// Inline post-edit diagnostics: edit_file/write_file append error
+			// diagnostics for the file they just wrote to their own output, so the
+			// model sees a break in the same turn. Shares the run's lazy manager.
+			options.FileDiagnostics = agent.NewFileDiagnostics(lspManager)
 		}
 
 		// Some providers synthesize tool-call ids that repeat within a run (e.g.

internal/tui/model_catalog.go

@@ -66,10 +66,8 @@ func (m model) modelContextWindow(modelName string) int {
 	if trimmed == "" {
 		return 0
 	}
-	if registry, err := modelregistry.DefaultRegistry(); err == nil {
-		if entry, ok := registry.Resolve(trimmed); ok && entry.ContextLimits.ContextWindow > 0 {
-			return entry.ContextLimits.ContextWindow
-		}
+	if entry, ok := m.modelCatalog.Resolve(trimmed); ok && entry.ContextLimits.ContextWindow > 0 {
+		return entry.ContextLimits.ContextWindow
 	}
 	// Live-discovered window, preferring the ACTIVE provider's models so a model ID
 	// shared across providers resolves to the provider actually in use; only then

internal/tui/model_catalog_test.go

@@ -0,0 +1,109 @@
+package tui
+
+import (
+	"testing"
+
+	"github.com/Gitlawb/zero/internal/modelregistry"
+	"github.com/Gitlawb/zero/internal/providermodeldiscovery"
+)
+
+func TestModelContextWindowUsesCachedCatalog(t *testing.T) {
+	registry := mustTestModelRegistry(t, testModelEntry("custom-long-context", 12345, []modelregistry.ModelCapability{
+		modelregistry.ModelCapabilityChat,
+	}))
+	m := model{modelCatalog: registry}
+
+	if got := m.modelContextWindow("custom-long-context"); got != 12345 {
+		t.Fatalf("modelContextWindow = %d, want 12345", got)
+	}
+}
+
+func TestModelSupportsVisionTUITrustsCachedCatalog(t *testing.T) {
+	registry := mustTestModelRegistry(t, testModelEntry("gpt-5-text-only", 12345, []modelregistry.ModelCapability{
+		modelregistry.ModelCapabilityChat,
+	}))
+	m := model{modelName: "gpt-5-text-only", modelCatalog: registry}
+
+	if m.modelSupportsVisionTUI() {
+		t.Fatal("catalog-known text-only model must not fall through to vision name heuristic")
+	}
+}
+
+func TestModelSupportsVisionTUIChecksDiscoveredBeforeHeuristic(t *testing.T) {
+	registry := mustTestModelRegistry(t, testModelEntry("custom-known", 12345, []modelregistry.ModelCapability{
+		modelregistry.ModelCapabilityChat,
+	}))
+	m := model{
+		modelName:    "gpt-5-text-only",
+		modelCatalog: registry,
+		modelPickerLiveByProvider: map[string][]providermodeldiscovery.Model{
+			"custom": {{ID: "gpt-5-text-only", InputModalities: []string{"text"}}},
+		},
+	}
+
+	if m.modelSupportsVisionTUI() {
+		t.Fatal("discovered text-only model must not fall through to vision name heuristic")
+	}
+}
+
+func BenchmarkModelContextWindowLookup(b *testing.B) {
+	cachedRegistry, err := modelregistry.DefaultRegistry()
+	if err != nil {
+		b.Fatalf("load default registry: %v", err)
+	}
+
+	b.Run("default_registry_each_call", func(b *testing.B) {
+		b.ReportAllocs()
+		for b.Loop() {
+			registry, err := modelregistry.DefaultRegistry()
+			if err != nil {
+				b.Fatalf("load default registry: %v", err)
+			}
+			entry, ok := registry.Resolve("gpt-4.1")
+			if !ok || entry.ContextLimits.ContextWindow <= 0 {
+				b.Fatal("expected gpt-4.1 context window")
+			}
+		}
+	})
+
+	b.Run("cached_registry", func(b *testing.B) {
+		m := model{modelName: "gpt-4.1", modelCatalog: cachedRegistry}
+		b.ReportAllocs()
+		for b.Loop() {
+			if got := m.modelContextWindow(m.modelName); got <= 0 {
+				b.Fatal("expected gpt-4.1 context window")
+			}
+		}
+	})
+}
+
+func mustTestModelRegistry(t *testing.T, entries ...modelregistry.ModelEntry) modelregistry.Registry {
+	t.Helper()
+	registry, err := modelregistry.NewRegistry(entries)
+	if err != nil {
+		t.Fatalf("create test model registry: %v", err)
+	}
+	return registry
+}
+
+func testModelEntry(id string, contextWindow int, capabilities []modelregistry.ModelCapability) modelregistry.ModelEntry {
+	return modelregistry.ModelEntry{
+		ID:            id,
+		DisplayName:   id,
+		APIModel:      id,
+		Provider:      modelregistry.ProviderOpenAI,
+		APIProviders:  []modelregistry.ProviderKind{modelregistry.ProviderOpenAI},
+		ContextLimits: modelregistry.ContextLimits{ContextWindow: contextWindow, MaxOutputTokens: 1024},
+		Capabilities:  capabilities,
+		Cost: modelregistry.ModelCost{
+			Currency:           "USD",
+			Unit:               "per_1m_tokens",
+			InputPerMillion:    1,
+			OutputPerMillion:   1,
+			Source:             "test",
+			SourceLastVerified: "2026-01-01",
+		},
+		Status:  modelregistry.ModelStatusActive,
+		Aliases: []string{id},
+	}
+}

internal/tui/picker.go

@@ -43,10 +43,6 @@ type pickerItem struct {
 	Remote        bool
 	Local         bool
 	Favorite      bool
-	// FastVariant is the display name of this model's faster same-family variant
-	// (empty when it has none). Set only for /model rows; drives the "f" fast-mode
-	// badge and the focused-row "⚡ fast: … · /fast on" hint.
-	FastVariant string
 }
 
 // commandPicker is a generic single-select overlay reused by /model and /effort
@@ -159,35 +155,9 @@ func (m model) newModelPicker() *commandPicker {
 	if len(items) == 0 {
 		return nil
 	}
-	decorateFastVariantItems(registry, items)
 	return &commandPicker{kind: pickerModel, title: "Choose a model", items: items, allItems: append([]pickerItem{}, items...), selected: 0}
 }
 
-// decorateFastVariantItems stamps each /model row with the display name of its
-// fast variant (if any), in one pass over the assembled list rather than in every
-// item builder. Rows whose model id is not in the curated registry (custom or
-// live-discovered) simply keep an empty FastVariant and show no badge.
-func decorateFastVariantItems(registry modelregistry.Registry, items []pickerItem) {
-	for index := range items {
-		id := strings.TrimSpace(items[index].Value)
-		if id == "" {
-			continue
-		}
-		if fast, ok := registry.FastVariant(id); ok {
-			items[index].FastVariant = fastVariantDisplayName(fast)
-		}
-	}
-}
-
-// fastVariantDisplayName is the user-facing name of a fast variant, preferring
-// its display name and falling back to the id.
-func fastVariantDisplayName(entry modelregistry.ModelEntry) string {
-	if name := strings.TrimSpace(entry.DisplayName); name != "" {
-		return name
-	}
-	return strings.TrimSpace(entry.ID)
-}
-
 // modelPickerProviders returns the providers to list in /model: all saved
 // providers, falling back to the active profile when none were threaded in.
 func (m model) modelPickerProviders() []config.ProviderProfile {

internal/tui/picker_test.go

@@ -846,13 +846,13 @@ func TestEffortPickerAutoSelectionKeepsEffortUnset(t *testing.T) {
 }
 
 func TestModelContextWindowResolution(t *testing.T) {
-	m := model{}
 	// Registered model → the exact registry window (compare to the registry value so
 	// this doesn't break on a benign catalog update).
 	registry, err := modelregistry.DefaultRegistry()
 	if err != nil {
 		t.Fatalf("load default registry: %v", err)
 	}
+	m := model{modelCatalog: registry}
 	entry, ok := registry.Resolve("gpt-4.1")
 	if !ok || entry.ContextLimits.ContextWindow <= 0 {
 		t.Fatalf("gpt-4.1 should resolve a positive window in the registry")

internal/tui/provider_wizard.go

@@ -1567,9 +1567,6 @@ func (wizard *providerWizardState) renderSelectableModel(width int, index int, m
 		marker = surface(zeroTheme.accent).Render("❯ ")
 	}
 	left := marker + surface(zeroTheme.ink).Render(model.displayLabel())
-	if _, ok := fastVariantEntryFor(model.ID); ok {
-		left += renderFastBadge(surface(zeroTheme.accent))
-	}
 	return fitStyledLine(left, width)
 }
 
@@ -1581,9 +1578,6 @@ func providerWizardModelDetail(model providerWizardModel) string {
 	if meta := strings.TrimSpace(model.Meta); meta != "" {
 		parts = append(parts, meta)
 	}
-	if fast, ok := fastVariantEntryFor(model.ID); ok {
-		parts = append(parts, fastVariantHint(fastVariantDisplayName(fast)))
-	}
 	return strings.Join(parts, " · ")
 }
 

internal/tui/view.go

@@ -153,23 +153,16 @@ func (m model) titlePRSegment() string {
 func (m model) titleModelSegment() string {
 	provider := strings.TrimSpace(m.providerDisplayName())
 	model := strings.TrimSpace(m.modelName)
-	var segment string
 	switch {
 	case provider == "" && model == "":
 		return zeroTheme.muted.Render("no provider")
 	case model == "":
 		return zeroTheme.ink.Render(provider)
 	case provider == "":
-		segment = zeroTheme.ink.Render(model)
+		return zeroTheme.ink.Render(model)
 	default:
-		segment = zeroTheme.ink.Render(provider + "/" + model)
+		return zeroTheme.ink.Render(provider + "/" + model)
 	}
-	// Mark the active model with a quiet "f" when a fast variant is available, so
-	// the user knows /fast is on offer here without opening a picker.
-	if _, ok := m.currentModelFastVariant(); ok {
-		segment += renderFastBadge(zeroTheme.accent)
-	}
-	return segment
 }
 
 func (m model) composerDividerLine(width int) string {
@@ -873,9 +866,6 @@ func modelPickerOverlayWidth(terminalWidth int, picker *commandPicker) int {
 			if item.Favorite {
 				labelWidth += lipgloss.Width("* ")
 			}
-			if strings.TrimSpace(item.FastVariant) != "" {
-				labelWidth += lipgloss.Width(renderFastBadge(zeroTheme.accent))
-			}
 			target = maxInt(target, lipgloss.Width("❯ ")+labelWidth)
 			if detail := modelPickerItemDetail(item); detail != "" {
 				target = maxInt(target, lipgloss.Width("  "+detail))
@@ -912,11 +902,6 @@ func renderModelPickerRow(width int, selected bool, item pickerItem) string {
 		prefix = "* "
 	}
 	left := marker + surface(zeroTheme.ink).Render(prefix+label)
-	// A quiet "f" badge marks rows whose model has a fast variant; the focused-row
-	// detail line spells out the target and command.
-	if strings.TrimSpace(item.FastVariant) != "" {
-		left += renderFastBadge(surface(zeroTheme.accent))
-	}
 	// The provider is shown as a section header above each group, so rows no longer
 	// repeat it as a right-aligned tag (matches a grouped provider+model list).
 	return fillPaletteLine(left, width, surface)
@@ -932,9 +917,6 @@ func modelPickerItemDetail(item pickerItem) string {
 	if meta := strings.TrimSpace(item.Meta); meta != "" {
 		parts = append(parts, meta)
 	}
-	if hint := fastVariantHint(item.FastVariant); hint != "" {
-		parts = append(parts, hint)
-	}
 	return strings.Join(parts, " · ")
 }