test: isolate OAuth/config test storage and fix the flaky MCP response-id test

Review + CI fixes, all test-only:

- factory/cli OAuth tests: pin ZERO_OAUTH_STORAGE=file next to the temp
  ZERO_OAUTH_TOKENS_PATH — an inherited "keyring" value sends NewStore to
  the OS keychain and ignores the temp path entirely, so the tests could
  read (or clobber) the developer's real logins. newOAuthStoreForTest now
  owns both pins so a future call site can't forget them.
- TestApplyProviderWizardExportsActiveProviderEnv: point m.userConfigPath
  at a temp config and stub newProvider, so the SUCCESS path exercises the
  full build+persist+commit sequence in isolation (the default empty path
  silently skipped persist; a changed default must never reach the real
  user config).
- TestClientRequestWaitsForMatchingResponseID (ubuntu smoke flake): the
  responses were pre-loaded into a bytes.Buffer, so the client's reader
  goroutine could consume the matching response — and hit EOF — before
  request() registered its pending id, failing with "request() error =
  EOF" on fast runners. The fake server now sits on pipes and responds
  only after reading the outgoing request, matching production ordering;
  survives -race -count=50.

.github/workflows/release-artifacts.yml

@@ -54,10 +54,8 @@ jobs:
       # is published under the pushed git tag. If they disagree, install.sh/install.ps1
       # and the npm postinstall all build a download URL that 404s. Fail fast so a
       # forgotten version bump can never publish mis-versioned, un-installable assets.
-      # Matches on the ref (not event_name) because release-please dispatches this
-      # workflow at the tag ref — its GITHUB_TOKEN-created tag cannot fire `push`.
       - name: Check tag matches package.json version
-        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }}
         shell: bash
         run: |
           pkg_version="$(node -p "require('./package.json').version")"
@@ -80,15 +78,13 @@ jobs:
           path: dist/release/*
           if-no-files-found: error
 
-      # On a `v*` tag ref (pushed manually, or dispatched at the tag by the
-      # release-please workflow), publish the packaged archive + .sha256 as GitHub
-      # Release assets so the documented `scripts/install.sh` / `install.ps1` path
-      # (which reads /releases/latest) works. Uses the preinstalled `gh` (no new
-      # action dependency); each matrix OS creates the release if absent
-      # (best-effort — release-please normally creates it first) then uploads its
-      # own assets with --clobber. Tags come from merging the release-please PR.
+      # On a `v*` tag push, publish the packaged archive + .sha256 as GitHub Release
+      # assets so the documented `scripts/install.sh` / `install.ps1` path (which reads
+      # /releases/latest) works. Uses the preinstalled `gh` (no new action dependency);
+      # each matrix OS creates the release if absent (best-effort) then uploads its own
+      # assets with --clobber. NOTE: maintainers must push the tag — this never tags.
       - name: Publish to GitHub Release
-        if: ${{ startsWith(github.ref, 'refs/tags/v') }}
+        if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }}
         shell: bash
         env:
           GH_TOKEN: ${{ github.token }}
@@ -96,89 +92,3 @@ jobs:
           tag="${GITHUB_REF_NAME}"
           gh release create "$tag" --repo "$GITHUB_REPOSITORY" --title "$tag" --generate-notes 2>/dev/null || true
           gh release upload "$tag" dist/release/* --repo "$GITHUB_REPOSITORY" --clobber
-
-  # Publishes the npm wrapper (@gitlawb/zero) once every platform's release
-  # assets are live — the package's postinstall downloads its binary from the
-  # GitHub Release, so publishing before the assets exist would ship a package
-  # that fails to install.
-  #
-  # Auth is npm OIDC trusted publishing: no NPM_TOKEN secret. The package's
-  # npmjs.com settings must list this repo + workflow file as a trusted
-  # publisher, and provenance is then generated automatically. Note npm only
-  # allows configuring a trusted publisher on an EXISTING package, so the very
-  # first @gitlawb/zero publish is a one-time manual `npm publish` bootstrap.
-  publish-npm:
-    name: Publish npm package
-    needs: package
-    if: ${{ startsWith(github.ref, 'refs/tags/v') }}
-    runs-on: ubuntu-latest
-    # Manual approval gate: this environment carries a required-reviewer rule
-    # (Settings -> Environments -> npm-publish), so the job pauses until a
-    # maintainer approves it in the Actions UI before anything reaches npm.
-    environment:
-      name: npm-publish
-      url: https://www.npmjs.com/package/@gitlawb/zero
-    permissions:
-      contents: read
-      id-token: write # OIDC token exchange for npm trusted publishing + provenance
-    steps:
-      - name: Checkout
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-
-      # No registry-url here on purpose: setup-node's registry-url writes an
-      # .npmrc line referencing $NODE_AUTH_TOKEN, and npm hard-fails on the
-      # unset env var. Trusted publishing needs no token at all.
-      - name: Setup Node
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
-        with:
-          node-version: 24
-
-      # OIDC trusted publishing needs npm >= 11.5.1. Use the npm bundled with
-      # the pinned Node toolchain (Node 24 ships >= 11.5.1) rather than pulling
-      # npm@latest from the registry inside the publish path — an unpinned
-      # install there would be avoidable supply-chain exposure. Fail fast if a
-      # future runner/toolchain change ever regresses the bundled npm.
-      - name: Check npm supports trusted publishing
-        run: |
-          npm --version | node -e '
-            const version = require("fs").readFileSync(0, "utf8").trim();
-            const [major, minor, patch] = version.split(".").map(Number);
-            const ok =
-              major > 11 ||
-              (major === 11 && (minor > 5 || (minor === 5 && patch >= 1)));
-            if (!ok) {
-              console.error(
-                `::error::bundled npm ${version} is too old for OIDC trusted ` +
-                  `publishing (needs >= 11.5.1) — bump node-version in this job.`,
-              );
-              process.exit(1);
-            }
-            console.log(`npm ${version} supports trusted publishing.`);
-          '
-
-      # Probe the exact URLs postinstall will build (internal/release/release.go
-      # asset-name scheme) as an anonymous client. This also blocks publishing
-      # while the repo is still private — private release assets 404 without
-      # auth, exactly as they would for an installing user.
-      - name: Verify release assets are downloadable
-        shell: bash
-        run: |
-          version="$(node -p "require('./package.json').version")"
-          base="https://github.com/${GITHUB_REPOSITORY}/releases/download/v${version}"
-          for asset in \
-            "zero-v${version}-linux-x64.tar.gz" \
-            "zero-v${version}-linux-arm64.tar.gz" \
-            "zero-v${version}-macos-x64.tar.gz" \
-            "zero-v${version}-macos-arm64.tar.gz" \
-            "zero-v${version}-windows-x64.zip"; do
-            for url in "${base}/${asset}" "${base}/${asset}.sha256"; do
-              if ! curl -fsSLI -o /dev/null "$url"; then
-                echo "::error::${url} is not publicly downloadable — npm postinstall would fail. Is the repo public and are all assets uploaded?" >&2
-                exit 1
-              fi
-            done
-          done
-          echo "all release assets for v${version} are publicly downloadable."
-
-      - name: Publish to npm
-        run: npm publish --access public

.github/workflows/release-please.yml

@@ -1,35 +0,0 @@
-name: Release Please
-
-on:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: write # push the release-PR branch, create the tag + GitHub Release
-  pull-requests: write # open/update the release PR
-  issues: write # create/apply release-tracking labels on the release PR
-  actions: write # dispatch release-artifacts.yml once a release is cut
-
-jobs:
-  release-please:
-    name: Release PR / tag
-    runs-on: ubuntu-latest
-    steps:
-      - name: Run release-please
-        id: release
-        uses: googleapis/release-please-action@a02a34c4d625f9be7cb89156071d8567266a2445 # v4.2.0
-
-      # Tags created with the default GITHUB_TOKEN never fire `on: push: tags`
-      # workflows (GitHub suppresses workflows triggered by workflow-created
-      # events), so release-artifacts.yml would not run for a release-please
-      # tag. workflow_dispatch invoked through the API is exempt from that
-      # suppression — dispatch the artifacts build at the new tag explicitly.
-      - name: Build and publish release artifacts
-        if: ${{ steps.release.outputs.release_created }}
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          gh workflow run release-artifacts.yml \
-            --repo "$GITHUB_REPOSITORY" \
-            --ref "${{ steps.release.outputs.tag_name }}"

.release-please-manifest.json

@@ -1 +0,0 @@
-{".":"0.1.0"}

CHANGELOG.md

@@ -6,19 +6,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 aims to follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html) once the first release is
 tagged. Until then, source builds report the version `dev`.
 
-## 0.1.0 (2026-07-02)
-
-
-### Features
-
-* publish zero to npm via release-please ([#367](https://github.com/Gitlawb/zero/issues/367)) ([8eccc26](https://github.com/Gitlawb/zero/commit/8eccc2669887bc38d35bc16a315c888e4d9ec43a))
-* **tui:** FILES sidebar panel with click-to-select and file drill-in ([#365](https://github.com/Gitlawb/zero/issues/365)) ([142c548](https://github.com/Gitlawb/zero/commit/142c548c89a8652ce300e64ddf1228ee36df7606))
-
-
-### Bug Fixes
-
-* **auth:** propagate credentials to every provider-build surface and pin children to the live provider ([#366](https://github.com/Gitlawb/zero/issues/366)) ([6e0a665](https://github.com/Gitlawb/zero/commit/6e0a665118fe0e09c4b07d482dd18f86045acd2b))
-
 ## [Unreleased]
 
 ### Added

internal/cli/app.go

@@ -402,14 +402,6 @@ func runWithDeps(args []string, stdout io.Writer, stderr io.Writer, deps appDeps
 		if _, err := fmt.Fprintf(stderr, "unknown command %q\n", args[0]); err != nil {
 			return 1
 		}
-		// First-run users reach for `zero login`/`zero logout` (reported in the
-		// wild); point them at the real command instead of a bare usage pointer.
-		switch strings.ToLower(args[0]) {
-		case "login", "logout":
-			if _, err := fmt.Fprintf(stderr, "did you mean %q?\n", "zero auth "+strings.ToLower(args[0])); err != nil {
-				return 1
-			}
-		}
 		if _, err := fmt.Fprintln(stderr, "Run zero --help for usage."); err != nil {
 			return 1
 		}
@@ -538,21 +530,7 @@ func runInteractiveTUIWithSetup(stderr io.Writer, deps appDeps, permissionMode a
 
 	resolved, err := deps.resolveConfig(workspaceRoot, config.Overrides{})
 	if err != nil {
-		// A resolve failure the setup wizard can FIX is not fatal for the
-		// interactive TUI: drop into the wizard with an empty config so the user
-		// can onboard/repair, instead of exiting with an error they can only fix
-		// by hand-editing config.json. That covers a missing/unresolvable active
-		// provider and an active provider without a model (custom endpoints have
-		// no catalog default) — previously the second shape bricked bare `zero`
-		// and `zero setup`, the exact commands that could have fixed it. Any
-		// other error (malformed JSON, directory conflict, etc.) is still fatal,
-		// and headless commands (zero config / zero exec) still fail with the
-		// actionable message.
-		if !errors.Is(err, config.ErrNoActiveProvider) && !errors.Is(err, config.ErrProviderRequiresModel) {
-			return writeAppError(stderr, err.Error(), 1)
-		}
-		resolved = config.ResolvedConfig{}
-		forceSetup = true
+		return writeAppError(stderr, err.Error(), 1)
 	}
 	userConfigPath, err := deps.userConfigPath()
 	if err != nil {

internal/cli/app_test.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/json"
 	"errors"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
@@ -158,80 +157,6 @@ func TestRunNoArgsLaunchesSetupTUIWithNilProviderWhenNoProviderConfigured(t *tes
 	assertAgentOptions(t, launchedOptions, 12, agent.PermissionModeAsk)
 }
 
-func TestRunNoArgsEntersSetupWhenResolveReportsNoActiveProvider(t *testing.T) {
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cwd := t.TempDir()
-	setCLIUserConfigRoot(t)
-	userConfigPath := filepath.Join(t.TempDir(), "zero", "config.json")
-	var launchedOptions tui.Options
-	launched := false
-
-	exitCode := runWithDeps([]string{}, &stdout, &stderr, appDeps{
-		getwd: func() (string, error) {
-			return cwd, nil
-		},
-		resolveConfig: func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
-			return config.ResolvedConfig{}, fmt.Errorf("%w: active provider %q not found", config.ErrNoActiveProvider, "ghost")
-		},
-		newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
-			t.Fatal("newProvider should not be called without a resolved provider")
-			return nil, nil
-		},
-		userConfigPath: func() (string, error) {
-			return userConfigPath, nil
-		},
-		registerMCPTools: func(context.Context, *tools.Registry, config.MCPConfig, mcp.RegisterOptions) (mcpToolRuntime, error) {
-			return noopMCPRuntime{}, nil
-		},
-		runTUI: func(ctx context.Context, options tui.Options) int {
-			launched = true
-			launchedOptions = options
-			return 0
-		},
-	})
-
-	if exitCode != 0 {
-		t.Fatalf("exit code = %d, want 0 (setup TUI launched), stderr=%q", exitCode, stderr.String())
-	}
-	if !launched {
-		t.Fatal("TUI was not launched; expected fallback into setup instead of a fatal error")
-	}
-	if !launchedOptions.Setup.Visible || !launchedOptions.Setup.Required {
-		t.Fatalf("Setup = %#v, want visible required setup", launchedOptions.Setup)
-	}
-	if launchedOptions.Provider != nil {
-		t.Fatalf("Provider = %#v, want nil for no-provider fallback", launchedOptions.Provider)
-	}
-}
-
-func TestRunNoArgsFailsWhenResolveErrorIsNotProviderRelated(t *testing.T) {
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cwd := t.TempDir()
-	setCLIUserConfigRoot(t)
-
-	exitCode := runWithDeps([]string{}, &stdout, &stderr, appDeps{
-		getwd: func() (string, error) {
-			return cwd, nil
-		},
-		resolveConfig: func(workspaceRoot string, overrides config.Overrides) (config.ResolvedConfig, error) {
-			return config.ResolvedConfig{}, fmt.Errorf("invalid config JSON")
-		},
-		runTUI: func(ctx context.Context, options tui.Options) int {
-			t.Fatal("TUI must not launch on a non-provider resolve error")
-			return 0
-		},
-	})
-
-	if exitCode == 0 {
-		t.Fatal("exit code = 0, want non-zero for fatal config error")
-	}
-	if !strings.Contains(stderr.String(), "invalid config JSON") {
-		t.Fatalf("stderr = %q, want the underlying config error", stderr.String())
-	}
-}
-
 func TestRunNoArgsLaunchesTUIWithMCPState(t *testing.T) {
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
@@ -1476,75 +1401,3 @@ func TestRunThemeFlagRejectsBadValue(t *testing.T) {
 		t.Fatalf("expected a clear --theme error, got %q", stderr.String())
 	}
 }
-
-// A custom endpoint saved without a model previously bricked bare `zero` and
-// `zero setup` — the exact commands that could have fixed it (the resolve
-// error escaped before the wizard could open). The interactive TUI now treats
-// the requires-model failure as "needs onboarding", same as a missing active
-// provider. The error comes from a REAL Resolve over a real config file, so
-// this exercises the production sentinel wrapping, not a hand-built error.
-func TestRunNoArgsEntersSetupWhenActiveProviderMissesModel(t *testing.T) {
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	cwd := t.TempDir()
-	setCLIUserConfigRoot(t)
-	brokenConfig := filepath.Join(t.TempDir(), "config.json")
-	if err := os.WriteFile(brokenConfig, []byte(`{
-		"activeProvider": "gw",
-		"providers": [{"name": "gw", "provider_kind": "openai-compatible", "baseURL": "https://gw.example/v1", "apiKey": "sk-x"}]
-	}`), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	launched := false
-	var launchedOptions tui.Options
-
-	exitCode := runWithDeps([]string{}, &stdout, &stderr, appDeps{
-		getwd: func() (string, error) { return cwd, nil },
-		resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
-			return config.Resolve(config.ResolveOptions{UserConfigPath: brokenConfig, Env: map[string]string{}})
-		},
-		newProvider: func(config.ProviderProfile) (zeroruntime.Provider, error) {
-			t.Fatal("newProvider must not be called without a resolved provider")
-			return nil, nil
-		},
-		userConfigPath: func() (string, error) { return filepath.Join(t.TempDir(), "zero", "config.json"), nil },
-		registerMCPTools: func(context.Context, *tools.Registry, config.MCPConfig, mcp.RegisterOptions) (mcpToolRuntime, error) {
-			return noopMCPRuntime{}, nil
-		},
-		runTUI: func(_ context.Context, options tui.Options) int {
-			launched = true
-			launchedOptions = options
-			return 0
-		},
-	})
-
-	if exitCode != 0 {
-		t.Fatalf("exit code = %d, want 0 (setup TUI launched), stderr=%q", exitCode, stderr.String())
-	}
-	if !launched {
-		t.Fatal("TUI was not launched; a fixable requires-model config must fall into setup, not exit fatally")
-	}
-	if !launchedOptions.Setup.Visible || !launchedOptions.Setup.Required {
-		t.Fatalf("Setup = %#v, want visible required setup", launchedOptions.Setup)
-	}
-}
-
-// `zero login`/`zero logout` don't exist (it's `zero auth login`); first-run
-// users try them (reported in the wild), so the unknown-command error points at
-// the real command.
-func TestRunUnknownLoginSuggestsAuthLogin(t *testing.T) {
-	var stdout, stderr bytes.Buffer
-	exitCode := runWithDeps([]string{"login"}, &stdout, &stderr, appDeps{})
-	if exitCode != 2 {
-		t.Fatalf("exit = %d, want 2 (unknown command)", exitCode)
-	}
-	if !strings.Contains(stderr.String(), `"zero auth login"`) {
-		t.Fatalf("stderr = %q, want a zero auth login suggestion", stderr.String())
-	}
-	// An unrelated unknown command gets no misleading suggestion.
-	stderr.Reset()
-	runWithDeps([]string{"frobnicate"}, &stdout, &stderr, appDeps{})
-	if strings.Contains(stderr.String(), "did you mean") {
-		t.Fatalf("stderr = %q, unrelated commands must not get the auth hint", stderr.String())
-	}
-}

internal/cli/specialist_test.go

@@ -8,8 +8,6 @@ import (
 	"runtime"
 	"strings"
 	"testing"
-
-	"github.com/Gitlawb/zero/internal/config"
 )
 
 func TestRunSpecialistListShowAndPath(t *testing.T) {
@@ -328,7 +326,7 @@ func setSpecialistConfigRoot(t *testing.T) string {
 	default:
 		t.Setenv("XDG_CONFIG_HOME", root)
 	}
-	configRoot, err := config.UserConfigDir()
+	configRoot, err := os.UserConfigDir()
 	if err != nil {
 		t.Fatalf("UserConfigDir() error = %v", err)
 	}

internal/config/paths.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 )
 
@@ -34,32 +33,13 @@ func DefaultResolveOptions(workspaceRoot string) (ResolveOptions, error) {
 }
 
 func DefaultUserConfigPath() (string, error) {
-	userConfigDir, err := UserConfigDir()
+	userConfigDir, err := os.UserConfigDir()
 	if err != nil {
 		return "", fmt.Errorf("resolve user config directory: %w", err)
 	}
 	return filepath.Join(userConfigDir, "zero", "config.json"), nil
 }
 
-// UserConfigDir returns the base directory Zero stores per-user config under.
-// It mirrors os.UserConfigDir everywhere except macOS: there Go defaults to
-// ~/Library/Application Support, but Zero deliberately uses ~/.config (XDG-style,
-// matching Linux and Claude Code) so a single config path works cross-platform.
-// $XDG_CONFIG_HOME still wins on macOS when set.
-func UserConfigDir() (string, error) {
-	if runtime.GOOS == "darwin" {
-		if xdg := strings.TrimSpace(os.Getenv("XDG_CONFIG_HOME")); xdg != "" {
-			return xdg, nil
-		}
-		home, err := os.UserHomeDir()
-		if err != nil {
-			return "", fmt.Errorf("resolve home directory: %w", err)
-		}
-		return filepath.Join(home, ".config"), nil
-	}
-	return os.UserConfigDir()
-}
-
 func existingConfigFile(path string) (string, error) {
 	info, err := os.Stat(path)
 	if err != nil {

internal/config/paths_test.go

@@ -105,7 +105,7 @@ func setUserConfigRoot(t *testing.T) string {
 		t.Setenv("XDG_CONFIG_HOME", root)
 	}
 
-	configRoot, err := UserConfigDir()
+	configRoot, err := os.UserConfigDir()
 	if err != nil {
 		t.Fatalf("UserConfigDir() error = %v", err)
 	}
@@ -130,21 +130,3 @@ func mkdirAll(t *testing.T, path string) {
 		t.Fatalf("create directory %s: %v", path, err)
 	}
 }
-
-func TestDefaultUserConfigPathUsesXDGConfigOnMacOS(t *testing.T) {
-	if runtime.GOOS != "darwin" {
-		t.Skip("macOS-specific config path behavior")
-	}
-	home := t.TempDir()
-	t.Setenv("HOME", home)
-	t.Setenv("XDG_CONFIG_HOME", "")
-
-	path, err := DefaultUserConfigPath()
-	if err != nil {
-		t.Fatalf("DefaultUserConfigPath() error = %v", err)
-	}
-	want := filepath.Join(home, ".config", "zero", "config.json")
-	if path != want {
-		t.Fatalf("DefaultUserConfigPath() = %q, want %q", path, want)
-	}
-}

internal/config/resolver.go

@@ -2,7 +2,6 @@ package config
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net/url"
 	"os"
@@ -15,31 +14,6 @@ import (
 	"github.com/Gitlawb/zero/internal/sandbox"
 )
 
-// ErrNoActiveProvider marks a resolve failure caused solely by a missing or
-// unresolvable active provider. The interactive TUI treats this as "needs
-// onboarding" (drop into the setup wizard) rather than a fatal config error.
-var ErrNoActiveProvider = errors.New("no active provider configured")
-
-// ErrProviderRequiresModel marks a resolve failure caused solely by the active
-// provider missing a model with no catalog default to fall back on (custom
-// openai-/anthropic-compatible endpoints — Zero cannot guess a gateway's model).
-// Like ErrNoActiveProvider, the interactive TUI treats it as "needs onboarding"
-// and drops into the setup wizard so the user can fix it; headless commands
-// (zero config, zero exec) still fail with the actionable message.
-var ErrProviderRequiresModel = errors.New("provider requires model")
-
-// setupFixableError tags an error with a sentinel for errors.Is WITHOUT
-// changing its message: the sentinel's own text must not prefix what the user
-// sees (the wrapped message is already complete and actionable).
-type setupFixableError struct {
-	err      error
-	sentinel error
-}
-
-func (e *setupFixableError) Error() string { return e.err.Error() }
-
-func (e *setupFixableError) Unwrap() []error { return []error{e.err, e.sentinel} }
-
 // defaultMaxTurns is the per-run tool-turn budget when none is configured. 30 was
 // too low for real multi-step agentic work (agents ran out mid-task before reaching
 // later steps); 50 matches the old "deep" preset. Raise per-session with /turns.
@@ -396,18 +370,6 @@ func effectiveProviderKind(profile ProviderProfile) ProviderKind {
 	return ""
 }
 
-// catalogDefaultModel returns the default model of a catalog provider ("" when
-// the id is unknown), used to fill a missing profile.Model for the official-API
-// kinds so a hand-written profile without a model resolves instead of bricking
-// every command that resolves config up front (zero config, bare zero setup).
-func catalogDefaultModel(catalogID string) string {
-	descriptor, ok := providercatalog.Get(catalogID)
-	if !ok {
-		return ""
-	}
-	return strings.TrimSpace(descriptor.DefaultModel)
-}
-
 func catalogDescriptorForProfile(profile ProviderProfile) (providercatalog.Descriptor, bool) {
 	catalogID := providercatalog.NormalizeID(profile.CatalogID)
 	if catalogID == "" {
@@ -769,16 +731,11 @@ func unionStrings(base []string, extra []string) []string {
 }
 
 type normalizeOptions struct {
-	// defaultModels fills a missing profile.Model for the official-API provider
-	// kinds (openai from the model registry; anthropic/google from their catalog
-	// descriptors). Off for provider-command configs (command.go), which must
-	// surface exactly what the external command returned rather than inventing
-	// a model behind its back.
-	defaultModels bool
+	defaultOpenAIModel bool
 }
 
 func normalizeProviders(providers []ProviderProfile, activeName string, envMaps ...map[string]string) ([]ProviderProfile, ProviderProfile, error) {
-	return normalizeProvidersWithOptions(providers, activeName, normalizeOptions{defaultModels: true}, envMaps...)
+	return normalizeProvidersWithOptions(providers, activeName, normalizeOptions{defaultOpenAIModel: true}, envMaps...)
 }
 
 func normalizeProvidersWithoutModelDefaults(providers []ProviderProfile, activeName string, envMaps ...map[string]string) ([]ProviderProfile, ProviderProfile, error) {
@@ -793,7 +750,7 @@ func normalizeProvidersWithOptions(providers []ProviderProfile, activeName strin
 	}
 	if len(providers) == 0 {
 		if activeName != "" {
-			return nil, ProviderProfile{}, fmt.Errorf("%w: active provider %q not found", ErrNoActiveProvider, activeName)
+			return nil, ProviderProfile{}, fmt.Errorf("active provider %q not found", activeName)
 		}
 		return []ProviderProfile{}, ProviderProfile{}, nil
 	}
@@ -825,13 +782,10 @@ func normalizeProvidersWithOptions(providers []ProviderProfile, activeName strin
 	}
 
 	if !activeFound {
-		return nil, ProviderProfile{}, fmt.Errorf("%w: active provider %q not found", ErrNoActiveProvider, activeName)
+		return nil, ProviderProfile{}, fmt.Errorf("active provider %q not found", activeName)
 	}
 	if active.Model == "" {
-		return nil, ProviderProfile{}, &setupFixableError{
-			err:      providerError(active, "provider %s requires model — add \"model\" to its entry in config.json, or re-run: zero setup <catalog-id> --model <model>", active.Name),
-			sentinel: ErrProviderRequiresModel,
-		}
+		return nil, ProviderProfile{}, providerError(active, "provider %s requires model", active.Name)
 	}
 
 	return normalized, active, nil
@@ -878,7 +832,7 @@ func normalizeProvider(profile ProviderProfile, env map[string]string, options n
 	case ProviderKindOpenAI:
 		if profile.BaseURL == "" || isOfficialOpenAIBaseURL(profile.BaseURL) {
 			profile.BaseURL = OpenAIBaseURL
-			if options.defaultModels && profile.Model == "" {
+			if options.defaultOpenAIModel && profile.Model == "" {
 				profile.Model = modelregistry.DefaultModelID
 			}
 			return profile, nil
@@ -895,9 +849,6 @@ func normalizeProvider(profile ProviderProfile, env map[string]string, options n
 	case ProviderKindAnthropic:
 		if profile.BaseURL == "" || isOfficialAnthropicBaseURL(profile.BaseURL) {
 			profile.BaseURL = AnthropicBaseURL
-			if options.defaultModels && profile.Model == "" {
-				profile.Model = catalogDefaultModel("anthropic")
-			}
 			return profile, nil
 		}
 		return ProviderProfile{}, providerError(profile, "anthropic provider %s requires official baseURL %s", profile.Name, AnthropicBaseURL)
@@ -912,9 +863,6 @@ func normalizeProvider(profile ProviderProfile, env map[string]string, options n
 	case ProviderKindGoogle:
 		if profile.BaseURL == "" || isOfficialGoogleBaseURL(profile.BaseURL) {
 			profile.BaseURL = GoogleBaseURL
-			if options.defaultModels && profile.Model == "" {
-				profile.Model = catalogDefaultModel("google")
-			}
 			return profile, nil
 		}
 		return ProviderProfile{}, providerError(profile, "google provider %s requires official baseURL %s", profile.Name, GoogleBaseURL)

internal/config/resolver_test.go

@@ -1,7 +1,6 @@
 package config
 
 import (
-	"errors"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -899,9 +898,6 @@ func TestResolveRejectsActiveProviderWithoutConfiguredProfiles(t *testing.T) {
 	if !strings.Contains(err.Error(), `active provider "ghost" not found`) {
 		t.Fatalf("error = %q, want active provider missing message", err.Error())
 	}
-	if !errors.Is(err, ErrNoActiveProvider) {
-		t.Fatalf("error = %v, want errors.Is(err, ErrNoActiveProvider)", err)
-	}
 	if resolved.ActiveProvider != "" {
 		t.Fatalf("ActiveProvider = %q, want empty", resolved.ActiveProvider)
 	}
@@ -1555,97 +1551,3 @@ func TestResolveMaxTurnsZeroFallsBackToDefault(t *testing.T) {
 		t.Fatalf("MaxTurns = %d, want default %d", resolved.MaxTurns, defaultMaxTurns)
 	}
 }
-
-// The reported brick: a hand-written google profile with an apiKey but no
-// model made EVERY resolving command fail ("provider google requires model"),
-// including zero config and bare zero setup — the only commands that could
-// have fixed it. Official-API kinds now fall back to their catalog default
-// model, exactly like the openai kind always has.
-func TestResolveDefaultsGoogleModelFromCatalog(t *testing.T) {
-	path := writeConfig(t, `{
-		"activeProvider": "google",
-		"providers": [{"name": "google", "provider_kind": "google", "apiKey": "AIza-x"}]
-	}`)
-	resolved, err := Resolve(ResolveOptions{UserConfigPath: path, Env: map[string]string{}})
-	if err != nil {
-		t.Fatalf("Resolve() error = %v, want model defaulted from the google catalog", err)
-	}
-	if resolved.Provider.Model != "gemini-2.5-pro" {
-		t.Fatalf("Model = %q, want the google catalog default gemini-2.5-pro", resolved.Provider.Model)
-	}
-	if resolved.Provider.BaseURL != GoogleBaseURL {
-		t.Fatalf("BaseURL = %q, want %q", resolved.Provider.BaseURL, GoogleBaseURL)
-	}
-}
-
-func TestResolveDefaultsAnthropicModelFromCatalog(t *testing.T) {
-	path := writeConfig(t, `{
-		"activeProvider": "anthropic",
-		"providers": [{"name": "anthropic", "provider_kind": "anthropic", "apiKey": "sk-ant-x"}]
-	}`)
-	resolved, err := Resolve(ResolveOptions{UserConfigPath: path, Env: map[string]string{}})
-	if err != nil {
-		t.Fatalf("Resolve() error = %v, want model defaulted from the anthropic catalog", err)
-	}
-	if resolved.Provider.Model != "claude-sonnet-4.5" {
-		t.Fatalf("Model = %q, want the anthropic catalog default claude-sonnet-4.5", resolved.Provider.Model)
-	}
-}
-
-// An explicitly configured model must always win over the catalog default.
-func TestResolveKeepsExplicitGoogleModel(t *testing.T) {
-	path := writeConfig(t, `{
-		"activeProvider": "google",
-		"providers": [{"name": "google", "provider_kind": "google", "apiKey": "AIza-x", "model": "gemini-2.5-flash"}]
-	}`)
-	resolved, err := Resolve(ResolveOptions{UserConfigPath: path, Env: map[string]string{}})
-	if err != nil {
-		t.Fatalf("Resolve() error = %v", err)
-	}
-	if resolved.Provider.Model != "gemini-2.5-flash" {
-		t.Fatalf("Model = %q, want the explicitly configured gemini-2.5-flash", resolved.Provider.Model)
-	}
-}
-
-// Provider-command configs must NOT get invented models: the without-defaults
-// path surfaces exactly what the external command returned.
-func TestNormalizeWithoutModelDefaultsStillRequiresGoogleModel(t *testing.T) {
-	_, _, err := normalizeProvidersWithoutModelDefaults(
-		[]ProviderProfile{{Name: "google", ProviderKind: ProviderKindGoogle, APIKey: "AIza-x"}},
-		"google", map[string]string{})
-	if err == nil {
-		t.Fatal("provider-command path must still require an explicit model")
-	}
-	if !strings.Contains(err.Error(), "requires model") {
-		t.Fatalf("error = %q, want requires-model", err.Error())
-	}
-	// The residual error must tell the user how to fix it.
-	if !strings.Contains(err.Error(), "config.json") {
-		t.Fatalf("error = %q, want an actionable config.json hint", err.Error())
-	}
-}
-
-// The residual requires-model failure (custom endpoint, no catalog default)
-// must be tagged setup-fixable WITHOUT changing its message: the interactive
-// TUI matches the sentinel to drop into the wizard, while headless commands
-// print the exact actionable text.
-func TestResolveRequiresModelErrorIsSetupFixable(t *testing.T) {
-	path := writeConfig(t, `{
-		"activeProvider": "gw",
-		"providers": [{"name": "gw", "provider_kind": "openai-compatible", "baseURL": "https://gw.example/v1", "apiKey": "sk-x"}]
-	}`)
-	_, err := Resolve(ResolveOptions{UserConfigPath: path, Env: map[string]string{}})
-	if err == nil {
-		t.Fatal("expected requires-model error for a custom endpoint without model")
-	}
-	if !errors.Is(err, ErrProviderRequiresModel) {
-		t.Fatalf("error = %v, want errors.Is(err, ErrProviderRequiresModel)", err)
-	}
-	// The sentinel must NOT prefix the user-facing message.
-	if !strings.HasPrefix(err.Error(), "provider gw requires model") {
-		t.Fatalf("message = %q, want it to start with the provider error, not the sentinel text", err.Error())
-	}
-	if strings.Contains(err.Error(), "sk-x") {
-		t.Fatalf("error leaked API key: %q", err.Error())
-	}
-}

internal/config/validate_test.go

@@ -66,13 +66,10 @@ func TestValidateFileRedactsSecretInIssue(t *testing.T) {
 }
 
 func TestValidateFileMissingModelWarns(t *testing.T) {
-	// An openai-compatible CUSTOM endpoint has no catalog default to fall back
-	// on, so a missing model is still a real issue — and the message must tell
-	// the user how to fix it.
 	path := writeValidateFixture(t, `{
 		"activeProvider": "main",
 		"providers": [
-			{"name": "main", "provider_kind": "openai-compatible", "baseURL": "https://gateway.example/v1"}
+			{"name": "main", "provider_kind": "anthropic"}
 		]
 	}`)
 
@@ -83,30 +80,6 @@ func TestValidateFileMissingModelWarns(t *testing.T) {
 	if !strings.Contains(issues[0].Message, "requires model") {
 		t.Fatalf("expected requires-model issue, got %#v", issues)
 	}
-	if !strings.Contains(issues[0].Message, "config.json") {
-		t.Fatalf("requires-model issue should carry an actionable hint, got %#v", issues)
-	}
-}
-
-func TestValidateFileDefaultsOfficialKindModels(t *testing.T) {
-	// Official-API kinds (anthropic/google) fall back to their catalog default
-	// model, so a hand-written model-less profile validates clean instead of
-	// bricking zero config / bare zero setup — the only commands that could
-	// have fixed it (the reported google case).
-	path := writeValidateFixture(t, `{
-		"activeProvider": "google",
-		"providers": [
-			{"name": "google", "provider_kind": "google", "apiKey": "AIza-x"},
-			{"name": "anthropic", "provider_kind": "anthropic", "apiKey": "sk-ant-x"}
-		]
-	}`)
-
-	_, issues := ValidateFile(path)
-	for _, issue := range issues {
-		if strings.Contains(issue.Message, "requires model") {
-			t.Fatalf("official-kind profiles must default their model, got issue %#v", issue)
-		}
-	}
 }
 
 func TestValidateFileValidConfigHasNoIssues(t *testing.T) {

internal/providers/gemini/provider.go

@@ -342,7 +342,7 @@ func (provider *Provider) geminiRequest(request zeroruntime.CompletionRequest) (
 			declarations = append(declarations, geminiFunctionDeclaration{
 				Name:        tool.Name,
 				Description: tool.Description,
-				Parameters:  sanitizeGeminiSchema(tool.Parameters),
+				Parameters:  tool.Parameters,
 			})
 		}
 		mapped.Tools = []geminiToolGroup{{FunctionDeclarations: declarations}}
@@ -350,71 +350,6 @@ func (provider *Provider) geminiRequest(request zeroruntime.CompletionRequest) (
 	return mapped, nil
 }
 
-// geminiSchemaFields is the subset of JSON Schema keywords Google's
-// functionDeclarations[].parameters accepts (the Generative AI Schema type).
-// Anything outside it — most notably OpenAI's `additionalProperties`, which Zero
-// emits on every tool's parameters and which Gemini 400s on ("Unknown name
-// \"additionalProperties\" … Cannot find field") — must be dropped before the
-// request goes out. Kept as an allowlist rather than a denylist so a schema
-// keyword Zero (or an MCP server) adds later can't silently leak an unsupported
-// field into the Gemini payload.
-var geminiSchemaFields = map[string]bool{
-	"type": true, "format": true, "title": true, "description": true,
-	"nullable": true, "enum": true, "items": true, "properties": true,
-	"required": true, "anyOf": true, "propertyOrdering": true, "default": true,
-	"minimum": true, "maximum": true, "minItems": true, "maxItems": true,
-	"minLength": true, "maxLength": true, "minProperties": true,
-	"maxProperties": true, "pattern": true, "example": true,
-}
-
-// sanitizeGeminiSchema returns a copy of a JSON-Schema map keeping only the
-// keywords Gemini supports (geminiSchemaFields), recursing through the nested
-// schemas under `properties`, `items`, and `anyOf`. Returns nil for a nil input
-// so a parameterless tool stays parameterless.
-func sanitizeGeminiSchema(schema map[string]any) map[string]any {
-	if schema == nil {
-		return nil
-	}
-	out := make(map[string]any, len(schema))
-	for key, value := range schema {
-		if !geminiSchemaFields[key] {
-			continue
-		}
-		switch key {
-		case "properties":
-			if props, ok := value.(map[string]any); ok {
-				cleaned := make(map[string]any, len(props))
-				for name, sub := range props {
-					if subMap, ok := sub.(map[string]any); ok {
-						cleaned[name] = sanitizeGeminiSchema(subMap)
-					} else {
-						cleaned[name] = sub
-					}
-				}
-				value = cleaned
-			}
-		case "items":
-			if subMap, ok := value.(map[string]any); ok {
-				value = sanitizeGeminiSchema(subMap)
-			}
-		case "anyOf":
-			if variants, ok := value.([]any); ok {
-				cleaned := make([]any, len(variants))
-				for i, variant := range variants {
-					if subMap, ok := variant.(map[string]any); ok {
-						cleaned[i] = sanitizeGeminiSchema(subMap)
-					} else {
-						cleaned[i] = variant
-					}
-				}
-				value = cleaned
-			}
-		}
-		out[key] = value
-	}
-	return out
-}
-
 func mapMessages(messages []zeroruntime.Message) (*geminiContent, []geminiContent, error) {
 	systemParts := []geminiPart{}
 	contents := []geminiContent{}

internal/providers/gemini/provider_test.go

@@ -3,7 +3,6 @@ package gemini
 import (
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"reflect"
@@ -505,129 +504,3 @@ func eventsOfType(events []zeroruntime.StreamEvent, eventType zeroruntime.Stream
 	}
 	return matching
 }
-
-// TestSanitizeGeminiSchemaStripsUnsupportedFields: the sanitizer keeps only
-// Gemini-supported keywords and recurses into properties/items/anyOf, so no
-// OpenAI-ism (additionalProperties, $schema, patternProperties) survives at any
-// depth while legitimate fields (type/description/enum/required/default) stay.
-func TestSanitizeGeminiSchemaStripsUnsupportedFields(t *testing.T) {
-	in := map[string]any{
-		"type":                 "object",
-		"additionalProperties": false,
-		"$schema":              "https://json-schema.org/draft/2020-12/schema",
-		"required":             []string{"path"},
-		"properties": map[string]any{
-			"path": map[string]any{
-				"type":        "string",
-				"description": "a path",
-				"default":     ".",
-			},
-			"nested": map[string]any{
-				"type":                 "object",
-				"additionalProperties": false, // must be stripped at depth too
-				"properties": map[string]any{
-					"tags": map[string]any{
-						"type":  "array",
-						"items": map[string]any{"type": "string", "additionalProperties": true},
-					},
-				},
-			},
-		},
-	}
-	out := sanitizeGeminiSchema(in)
-
-	assertNoAdditionalProps(t, out, "root")
-	if out["additionalProperties"] != nil {
-		t.Fatal("top-level additionalProperties must be stripped")
-	}
-	if out["$schema"] != nil {
-		t.Fatal("$schema must be stripped")
-	}
-	// Legitimate fields survive.
-	if out["type"] != "object" {
-		t.Fatalf("type should survive, got %v", out["type"])
-	}
-	props := out["properties"].(map[string]any)
-	pathProp := props["path"].(map[string]any)
-	if pathProp["description"] != "a path" || pathProp["default"] != "." {
-		t.Fatalf("legitimate property fields must survive: %#v", pathProp)
-	}
-	// nil input stays nil (parameterless tool).
-	if sanitizeGeminiSchema(nil) != nil {
-		t.Fatal("nil schema should map to nil")
-	}
-}
-
-// assertNoAdditionalProps fails if additionalProperties appears anywhere in the
-// (recursively walked) schema.
-func assertNoAdditionalProps(t *testing.T, node any, path string) {
-	t.Helper()
-	switch v := node.(type) {
-	case map[string]any:
-		if _, ok := v["additionalProperties"]; ok {
-			t.Fatalf("additionalProperties leaked at %s", path)
-		}
-		for k, sub := range v {
-			assertNoAdditionalProps(t, sub, path+"."+k)
-		}
-	case []any:
-		for i, sub := range v {
-			assertNoAdditionalProps(t, sub, fmt.Sprintf("%s[%d]", path, i))
-		}
-	}
-}
-
-// TestGeminiRequestOmitsAdditionalPropertiesInToolSchema: end-to-end, the tool
-// parameters Zero emits (schemaToRuntimeMap always writes additionalProperties)
-// must not reach Gemini — otherwise every functionDeclaration is 400-rejected
-// ("Unknown name additionalProperties"), which broke all tool-using exec calls
-// against Google (issue #373).
-func TestGeminiRequestOmitsAdditionalPropertiesInToolSchema(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)
-		}
-		writeSSE(w, `{"usageMetadata":{"promptTokenCount":1}}`)
-	}))
-	defer server.Close()
-
-	provider, err := New(Options{APIKey: "k", BaseURL: server.URL + "/", Model: "models/gemini-2.5-flash"})
-	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: "hi"}},
-		Tools: []zeroruntime.ToolDefinition{{
-			Name:        "grep",
-			Description: "search",
-			Parameters: map[string]any{ // exactly what schemaToRuntimeMap produces
-				"type":                 "object",
-				"additionalProperties": false,
-				"required":             []string{"pattern"},
-				"properties": map[string]any{
-					"pattern": map[string]any{"type": "string", "description": "regex"},
-				},
-			},
-		}},
-	})
-	if err != nil {
-		t.Fatalf("StreamCompletion returned error: %v", err)
-	}
-	drain(stream)
-
-	tools := gotBody["tools"].([]any)
-	decls := tools[0].(map[string]any)["functionDeclarations"].([]any)
-	params := decls[0].(map[string]any)["parameters"].(map[string]any)
-	if _, ok := params["additionalProperties"]; ok {
-		t.Fatalf("additionalProperties must not be sent to Gemini: %#v", params)
-	}
-	// The tool is still usable: its real schema survived.
-	if params["type"] != "object" {
-		t.Fatalf("tool parameters type should survive, got %v", params["type"])
-	}
-	props := params["properties"].(map[string]any)
-	if _, ok := props["pattern"]; !ok {
-		t.Fatalf("tool property must survive sanitization: %#v", props)
-	}
-}

internal/specialist/manifest.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Gitlawb/zero/internal/config"
 	"github.com/Gitlawb/zero/internal/modelregistry"
 )
 
@@ -121,7 +120,7 @@ var knownToolNames = map[string]bool{
 }
 
 func DefaultPaths(workspaceRoot string) (Paths, error) {
-	userConfigDir, err := config.UserConfigDir()
+	userConfigDir, err := os.UserConfigDir()
 	if err != nil {
 		return Paths{}, fmt.Errorf("resolve user config directory: %w", err)
 	}

internal/tui/file_view.go

@@ -1,251 +0,0 @@
-// file_view.go is the drill-in view for a touched file, opened from the FILES
-// sidebar section (files_panel.go). It reuses the subchat pattern: while
-// active, the chat column's body swaps to this file's content — the sidebar,
-// composer, and scroll engine keep working unchanged (transcriptBodyItems is
-// the single source the viewport, renderer, and hit-testers all read, so
-// swapping there keeps every consumer consistent). Two modes:
-//
-//	diff (default) — the file's edit cards from this session, full-depth
-//	full           — the file as it stands on disk, syntax highlighted, with
-//	                 gutter markers on the lines this session's diffs added
-//
-// d/f switch modes (with an empty composer), Esc returns to the chat at the
-// scroll position it was left at.
-package tui
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-// fileViewMaxLines caps the full-file mode so a giant generated file can't
-// freeze a render; the tail collapses into a "… N more lines" trailer.
-const fileViewMaxLines = 4000
-
-const (
-	fileViewDiff = iota
-	fileViewFull
-)
-
-// fileViewState manages the drill-in view for a touched file. When active, the
-// transcript body swaps to the file's diff/content instead of the chat rows.
-type fileViewState struct {
-	active bool
-	path   string // workspace-relative, as carried by changedFiles
-	mode   int    // fileViewDiff | fileViewFull
-	// parentScrollOffset preserves the chat scroll position so closing the view
-	// returns to the same spot (mirrors subchatState).
-	parentScrollOffset int
-}
-
-// openFileView activates the drill-in for path in diff mode. Opening from an
-// already-open view (clicking another FILES row) keeps the original saved chat
-// scroll position rather than saving the file view's own offset as "parent".
-// Re-opening the file that is ALREADY being viewed is a no-op: a stray
-// re-click must not bounce the user from full mode back to diff or reset
-// their scroll position.
-func (m model) openFileView(path string) model {
-	if m.fileView.active && m.fileView.path == path {
-		return m
-	}
-	if !m.fileView.active {
-		m.fileView.parentScrollOffset = m.chatScrollOffset
-	}
-	m.fileView.active = true
-	m.fileView.path = path
-	m.fileView.mode = fileViewDiff
-	// A file only the git sweep knows about (bash/subagent mutation) has no edit
-	// cards to stack — open straight on the full file instead of a placeholder.
-	if len(m.fileViewResultRows()) == 0 {
-		m.fileView.mode = fileViewFull
-	}
-	m.chatScrollOffset = 0
-	m = m.clearHover() // bodyY numbering differs between the file body and the chat
-	return m
-}
-
-// exitFileView deactivates the view and restores the chat scroll position.
-func (m model) exitFileView() model {
-	if !m.fileView.active {
-		return m
-	}
-	m.chatScrollOffset = m.fileView.parentScrollOffset
-	m.fileView = fileViewState{}
-	m = m.clearHover()
-	return m
-}
-
-// setFileViewMode switches diff/full, resetting the scroll to the bottom-anchored
-// start since the two bodies have unrelated heights.
-func (m model) setFileViewMode(mode int) model {
-	if !m.fileView.active || m.fileView.mode == mode {
-		return m
-	}
-	m.fileView.mode = mode
-	m.chatScrollOffset = 0
-	return m
-}
-
-// fileViewNavBar renders the single-line header shown in place of the pinned
-// title bar while the view is active: the path plus the key hints. One line
-// exactly, so every scrollableTranscriptFrame computed against it agrees with
-// the title bar's geometry.
-func (m model) fileViewNavBar(width int) string {
-	mode := "diff"
-	other := "f full"
-	if m.fileView.mode == fileViewFull {
-		mode = "full"
-		other = "d diff"
-	}
-	left := zeroTheme.accent.Render("← "+truncatePathLeft(m.fileView.path, maxInt(8, width/2))) +
-		zeroTheme.faint.Render("  ·  "+mode)
-	right := zeroTheme.faint.Render(other + " · esc back")
-	return fitStyledLine(joinHeaderLine(left, right, width), width)
-}
-
-// fileViewBodyItems builds the body items the transcript machinery renders
-// while the view is active — one pre-rendered block, so scrolling and height
-// accounting flow through the exact same path as chat rows.
-func (m model) fileViewBodyItems(width int) []transcriptBodyItem {
-	var block string
-	if m.fileView.mode == fileViewFull {
-		block = m.renderFileViewFull(width)
-	} else {
-		block = m.renderFileViewDiff(width)
-	}
-	return []transcriptBodyItem{transcriptBlockBodyItem(transcriptBodyItemRow, -1, block)}
-}
-
-// fileViewResultRows returns the transcript's tool-result rows that touched the
-// viewed file, in chronological order.
-func (m model) fileViewResultRows() []transcriptRow {
-	var rows []transcriptRow
-	for _, row := range m.transcript {
-		if row.kind != rowToolResult {
-			continue
-		}
-		for _, p := range row.changedFiles {
-			if p == m.fileView.path {
-				rows = append(rows, row)
-				break
-			}
-		}
-	}
-	return rows
-}
-
-// renderFileViewDiff renders the session's edits to the file as its full-depth
-// tool cards (bodyCap 0, the detailed-view depth), stacked chronologically —
-// the same cards the chat shows, so the diffs read identically in both places.
-func (m model) renderFileViewDiff(width int) string {
-	rows := m.fileViewResultRows()
-	if len(rows) == 0 {
-		return zeroTheme.faint.Render("No recorded edits for this file in this session.")
-	}
-	rc := buildRowContext(m.transcript)
-	opts := cardRenderOptions{bodyCap: 0, cwd: m.cwd}
-	var b strings.Builder
-	for i, row := range rows {
-		if i > 0 {
-			b.WriteString("\n\n")
-		}
-		if len(rows) > 1 {
-			b.WriteString(zeroTheme.faint.Render(fmt.Sprintf("edit %d of %d", i+1, len(rows))))
-			b.WriteString("\n")
-		}
-		b.WriteString(m.renderRowModeUncached(row, width, rc, opts))
-	}
-	return b.String()
-}
-
-// renderFileViewFull renders the file as it currently stands on disk, syntax
-// highlighted, with a line-number gutter and an accent ▎ marker on the lines
-// this session's diffs added (matched by exact text — an approximation that
-// tolerates later drift; a stale marker just doesn't highlight).
-func (m model) renderFileViewFull(width int) string {
-	target := m.fileView.path
-	if !filepath.IsAbs(target) {
-		target = filepath.Join(m.cwd, target)
-	}
-	// Stream the read and stop at the cap: os.ReadFile would load a multi-GB
-	// file wholesale before any truncation, which is the exact render freeze
-	// fileViewMaxLines exists to prevent.
-	file, err := os.Open(target)
-	if err != nil {
-		return zeroTheme.faint.Render("Could not read file: " + err.Error())
-	}
-	defer file.Close()
-	var lines []string
-	truncated := false
-	scanner := bufio.NewScanner(file)
-	scanner.Buffer(make([]byte, 0, 64*1024), 16*1024*1024)
-	for scanner.Scan() {
-		if len(lines) == fileViewMaxLines {
-			truncated = true
-			break
-		}
-		lines = append(lines, scanner.Text())
-	}
-	if err := scanner.Err(); err != nil {
-		if len(lines) == 0 {
-			return zeroTheme.faint.Render("Could not read file: " + err.Error())
-		}
-		truncated = true // e.g. a single over-long line mid-file: show what we have
-	}
-
-	changed := m.fileViewChangedLines()
-	gutterW := len(fmt.Sprintf("%d", len(lines)))
-	textBudget := maxInt(8, width-gutterW-3) // gutter + space + marker column
-	// Highlight with an effectively-infinite measure so the highlighter never
-	// wraps — output lines stay 1:1 with file lines and the gutter numbering
-	// can't desync. Each line is then truncated to the column budget below.
-	display, ok := highlightCodeForPath(lines, m.fileView.path, 1<<20, nil)
-	if !ok || len(display) != len(lines) {
-		display = lines // no lexer for this path: render plain
-	}
-
-	var b strings.Builder
-	for i, line := range display {
-		line = fitStyledLine(line, textBudget)
-		if i > 0 {
-			b.WriteString("\n")
-		}
-		marker := " "
-		if changed[strings.TrimSpace(lines[i])] {
-			marker = zeroTheme.accent.Render("▎")
-		}
-		b.WriteString(zeroTheme.faintest.Render(fmt.Sprintf("%*d ", gutterW, i+1)))
-		b.WriteString(marker)
-		b.WriteString(line)
-	}
-	if truncated {
-		// No exact remaining-line count: computing one would require reading the
-		// rest of the file, defeating the bounded read above.
-		b.WriteString("\n")
-		b.WriteString(zeroTheme.faint.Render(fmt.Sprintf("… more lines (file truncated at %d for display)", len(lines))))
-	}
-	return b.String()
-}
-
-// fileViewChangedLines collects the trimmed text of every line the session's
-// diffs ADDED to the viewed file, for the full-mode gutter markers. Very short
-// lines ("}", "return", ")") are skipped: text-matching them would mark every
-// unrelated occurrence across the file, which misleads far more than a missing
-// marker on a brace line ever could.
-func (m model) fileViewChangedLines() map[string]bool {
-	changed := map[string]bool{}
-	for _, row := range m.fileViewResultRows() {
-		for _, line := range strings.Split(row.detail, "\n") {
-			if !strings.HasPrefix(line, "+") || strings.HasPrefix(line, "+++") {
-				continue
-			}
-			if text := strings.TrimSpace(strings.TrimPrefix(line, "+")); len(text) >= 4 {
-				changed[text] = true
-			}
-		}
-	}
-	return changed
-}

internal/tui/file_view_test.go

@@ -1,288 +0,0 @@
-package tui
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	tea "charm.land/bubbletea/v2"
-
-	"github.com/Gitlawb/zero/internal/agent"
-	"github.com/Gitlawb/zero/internal/sessions"
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// TestFileViewOpenExitRestoresScroll: opening saves the chat scroll position,
-// resets it for the file body, and Esc restores it; switching files while open
-// keeps the ORIGINAL saved position (not the file view's own).
-func TestFileViewOpenExitRestoresScroll(t *testing.T) {
-	m := filesPanelTestModel()
-	m.chatScrollOffset = 12
-
-	m = m.openFileView("web/app.js")
-	if !m.fileView.active || m.fileView.mode != fileViewDiff {
-		t.Fatalf("open should activate in diff mode: %+v", m.fileView)
-	}
-	if m.chatScrollOffset != 0 || m.fileView.parentScrollOffset != 12 {
-		t.Fatalf("open should reset scroll and save the parent offset: offset=%d saved=%d", m.chatScrollOffset, m.fileView.parentScrollOffset)
-	}
-
-	m.chatScrollOffset = 5 // scrolled within the file body
-	m = m.openFileView("internal/tui/sidebar.go")
-	if m.fileView.parentScrollOffset != 12 {
-		t.Fatalf("switching files must keep the original parent offset, got %d", m.fileView.parentScrollOffset)
-	}
-
-	m = m.exitFileView()
-	if m.fileView.active || m.chatScrollOffset != 12 {
-		t.Fatalf("exit should restore the chat scroll: active=%v offset=%d", m.fileView.active, m.chatScrollOffset)
-	}
-}
-
-// TestFileViewEscAndModeKeys: Esc exits the view via the model's key handler;
-// d/f switch modes while the composer is empty and never while typing.
-func TestFileViewEscAndModeKeys(t *testing.T) {
-	m := filesPanelTestModel()
-	m = m.openFileView("web/app.js")
-
-	updated, _ := m.Update(tea.KeyPressMsg{Code: 'f', Text: "f"})
-	m = updated.(model)
-	if m.fileView.mode != fileViewFull {
-		t.Fatal("f should switch to full mode")
-	}
-	updated, _ = m.Update(tea.KeyPressMsg{Code: 'd', Text: "d"})
-	m = updated.(model)
-	if m.fileView.mode != fileViewDiff {
-		t.Fatal("d should switch back to diff mode")
-	}
-
-	// With text in the composer, d/f type as normal characters.
-	m.input.SetValue("say")
-	updated, _ = m.Update(tea.KeyPressMsg{Code: 'f', Text: "f"})
-	m = updated.(model)
-	if m.fileView.mode != fileViewDiff {
-		t.Fatal("f while typing must not hijack the composer")
-	}
-	m.input.SetValue("")
-
-	updated, _ = m.Update(tea.KeyPressMsg{Code: tea.KeyEsc})
-	m = updated.(model)
-	if m.fileView.active {
-		t.Fatal("Esc should exit the file view")
-	}
-}
-
-// TestFileViewDiffBody: diff mode stacks the file's edit cards chronologically
-// with "edit N of M" labels; a file with no recorded edits shows the quiet
-// placeholder.
-func TestFileViewDiffBody(t *testing.T) {
-	m := filesPanelTestModel()
-	m = m.openFileView("internal/tui/sidebar.go")
-	body := plainRender(t, m.renderFileViewDiff(78))
-	if !strings.Contains(body, "edit 1 of 2") || !strings.Contains(body, "edit 2 of 2") {
-		t.Fatalf("expected chronological edit labels:\n%s", body)
-	}
-	if !strings.Contains(body, "added one") || !strings.Contains(body, "three") {
-		t.Errorf("expected both diffs' content:\n%s", body)
-	}
-
-	m.fileView.path = "never/touched.go"
-	if got := plainRender(t, m.renderFileViewDiff(78)); !strings.Contains(got, "No recorded edits") {
-		t.Errorf("untouched file should show the placeholder, got:\n%s", got)
-	}
-}
-
-// TestFileViewFullBody: full mode shows the on-disk content with line numbers
-// and marks session-added lines with the gutter marker; a missing file degrades
-// to a readable error line.
-func TestFileViewFullBody(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(filepath.Join(dir, "app.js"), []byte("let a = 1\nlet untouched = 0\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	m := filesPanelTestModel()
-	m.cwd = dir
-	m.transcript = append(m.transcript, transcriptRow{
-		kind: rowToolResult, tool: "write_file", id: "w9", status: tools.StatusOK,
-		detail:       "+let a = 1",
-		changedFiles: []string{"app.js"},
-	})
-	m = m.openFileView("app.js")
-	m = m.setFileViewMode(fileViewFull)
-
-	body := m.renderFileViewFull(78)
-	plain := plainRender(t, body)
-	if !strings.Contains(plain, "1 ") || !strings.Contains(plain, "let untouched = 0") {
-		t.Fatalf("full view should show numbered file content:\n%s", plain)
-	}
-	lines := strings.Split(plain, "\n")
-	if len(lines) != 2 {
-		t.Fatalf("one rendered line per file line, got %d:\n%s", len(lines), plain)
-	}
-	if !strings.Contains(lines[0], "▎") {
-		t.Errorf("session-added line should carry the gutter marker: %q", lines[0])
-	}
-	if strings.Contains(lines[1], "▎") {
-		t.Errorf("untouched line must not carry the marker: %q", lines[1])
-	}
-
-	m.fileView.path = "gone.js"
-	if got := plainRender(t, m.renderFileViewFull(78)); !strings.Contains(got, "Could not read file") {
-		t.Errorf("missing file should degrade to an error line, got:\n%s", got)
-	}
-}
-
-// TestFileViewSwapsTranscriptBody: while active, transcriptBodyItems returns
-// the file body (a single block) instead of the chat rows, and the pinned
-// title bar swaps to the one-line nav bar — the geometry every frame consumer
-// relies on.
-func TestFileViewSwapsTranscriptBody(t *testing.T) {
-	m := filesPanelTestModel()
-	m = m.openFileView("internal/tui/sidebar.go")
-
-	items := m.transcriptBodyItems(m.chatColumnWidth(), "")
-	if len(items) != 1 {
-		t.Fatalf("file view should swap the body to a single block item, got %d items", len(items))
-	}
-	nav := plainRender(t, m.pinnedTitleBar(m.chatColumnWidth()))
-	if !strings.Contains(nav, "sidebar.go") || !strings.Contains(nav, "esc back") {
-		t.Fatalf("nav bar should show the path and key hints: %q", nav)
-	}
-	if lines := len(viewLines(m.fileViewNavBar(m.chatColumnWidth()))); lines != 1 {
-		t.Fatalf("nav bar must be exactly one line (title-bar geometry), got %d", lines)
-	}
-
-	// The whole view renders without panicking in both modes and shows the nav.
-	if view := plainRender(t, m.transcriptView()); !strings.Contains(view, "esc back") {
-		t.Fatal("transcript view should carry the file nav bar")
-	}
-}
-
-// TestSubchatEntryClosesFileView: drilling into an AGENTS row while a file view
-// is open closes the file view first (the subchat owns the single-column view).
-func TestSubchatEntryClosesFileView(t *testing.T) {
-	store := sessions.NewStore(sessions.StoreOptions{RootDir: t.TempDir()})
-	if _, err := store.Create(sessions.CreateInput{SessionID: "sess-1"}); err != nil {
-		t.Fatal(err)
-	}
-	m := filesPanelTestModel()
-	m.sessionStore = store
-	m.swarmSessionMap = map[string]string{"subagent-1": "sess-1"}
-	m.transcript = append(m.transcript,
-		transcriptRow{kind: rowToolCall, tool: "swarm_spawn", detail: "build it", runID: 1},
-		transcriptRow{kind: rowToolResult, tool: "swarm_spawn", detail: "Spawned subagent as task subagent-1 on team default.", runID: 1},
-	)
-	m.activeRunID = 1
-	m = m.openFileView("web/app.js")
-
-	width := sidebarWidth(m.width)
-	agents := m.sidebarAgentSelectables(width)
-	if len(agents) == 0 {
-		t.Fatal("expected a clickable agent row")
-	}
-	click := testMouseClick(tea.MouseLeft, m.chatColumnWidth()+3, agents[0].lineOffset)
-	updated, _, handled := m.handleTranscriptSelectionMouse(click)
-	if !handled {
-		t.Fatal("agent row click should be handled")
-	}
-	if updated.fileView.active {
-		t.Fatal("entering the subchat should close the file view")
-	}
-	if !updated.subchat.active {
-		t.Fatal("subchat should be active")
-	}
-}
-
-// TestChangedFilesRehydration: a persisted tool-result payload's changedFiles
-// restores onto the rehydrated transcript row, so the FILES panel survives
-// /resume.
-func TestChangedFilesRehydration(t *testing.T) {
-	events := []sessions.Event{{
-		Type:    sessions.EventToolResult,
-		Payload: json.RawMessage(`{"toolCallId":"t1","name":"edit_file","status":"ok","output":"+x","changedFiles":["pkg/a.go","pkg/b.go"]}`),
-	}}
-	rows := transcriptRowsFromSessionEvents(events)
-	if len(rows) != 1 {
-		t.Fatalf("expected 1 row, got %d", len(rows))
-	}
-	got := rows[0].changedFiles
-	if len(got) != 2 || got[0] != "pkg/a.go" || got[1] != "pkg/b.go" {
-		t.Fatalf("changedFiles not rehydrated: %v", got)
-	}
-}
-
-// TestOpenFileViewSamePathIsNoOp: re-clicking the FILES row of the file already
-// being viewed must not clobber the user's mode or scroll — the old
-// unconditional openFileView bounced full mode back to diff and reset scroll.
-func TestOpenFileViewSamePathIsNoOp(t *testing.T) {
-	m := filesPanelTestModel()
-	m = m.openFileView("web/app.js")
-	m = m.setFileViewMode(fileViewFull)
-	m.chatScrollOffset = 7 // scrolled within the file body
-
-	m = m.openFileView("web/app.js")
-	if m.fileView.mode != fileViewFull {
-		t.Fatal("re-opening the same file must keep full mode")
-	}
-	if m.chatScrollOffset != 7 {
-		t.Fatalf("re-opening the same file must keep the scroll, got %d", m.chatScrollOffset)
-	}
-	// A DIFFERENT file still switches (and resets to diff mode as documented).
-	m = m.openFileView("internal/tui/sidebar.go")
-	if m.fileView.path != "internal/tui/sidebar.go" || m.fileView.mode != fileViewDiff {
-		t.Fatalf("opening another file should switch views: %+v", m.fileView)
-	}
-}
-
-// TestFileViewFullBodyTruncatesLongFile: the full view stops reading at
-// fileViewMaxLines (bounded read — a giant file must not be loaded wholesale)
-// and appends the truncation trailer.
-func TestFileViewFullBodyTruncatesLongFile(t *testing.T) {
-	dir := t.TempDir()
-	var b strings.Builder
-	for i := 0; i < fileViewMaxLines+50; i++ {
-		fmt.Fprintf(&b, "line %d\n", i)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "big.txt"), []byte(b.String()), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	m := filesPanelTestModel()
-	m.cwd = dir
-	m.gitTouched = []gitSweepFile{{path: "big.txt"}}
-	m = m.openFileView("big.txt")
-
-	plain := plainRender(t, m.renderFileViewFull(80))
-	lines := strings.Split(plain, "\n")
-	if len(lines) != fileViewMaxLines+1 { // capped content + the trailer line
-		t.Fatalf("rendered %d lines, want %d content lines + 1 trailer", len(lines), fileViewMaxLines)
-	}
-	if !strings.Contains(lines[len(lines)-1], "truncated") {
-		t.Fatalf("expected the truncation trailer, got %q", lines[len(lines)-1])
-	}
-}
-
-// TestFileViewKeysDeferToBlockingModal: with a permission prompt up, Esc and
-// the d/f shortcuts belong to the prompt — the drill-in must not swallow them
-// (Esc exiting the view instead of reaching the prompt's deny handling).
-func TestFileViewKeysDeferToBlockingModal(t *testing.T) {
-	m := filesPanelTestModel()
-	m = m.openFileView("web/app.js")
-	m.pendingPermission = &pendingPermissionPrompt{
-		request: agent.PermissionRequest{ToolName: "write_file"},
-		decide:  func(agent.PermissionDecision) {},
-	}
-
-	updated, _ := m.Update(tea.KeyPressMsg{Code: 'f', Text: "f"})
-	m = updated.(model)
-	if m.fileView.mode != fileViewDiff {
-		t.Fatal("f with a permission prompt up must not switch file-view modes")
-	}
-	updated, _ = m.Update(tea.KeyPressMsg{Code: tea.KeyEsc})
-	m = updated.(model)
-	if !m.fileView.active {
-		t.Fatal("Esc with a permission prompt up must not exit the file view")
-	}
-}

internal/tui/files_git_sweep.go

@@ -1,237 +0,0 @@
-// files_git_sweep.go fills the FILES sidebar's blind spot: mutations that
-// bypass the file tools entirely — bash/exec_command scaffolding (npm create,
-// go generate, heredoc writes) and subagents editing the shared workspace. None
-// of those produce a changedFiles-carrying tool result, so the transcript-derived
-// roster (files_panel.go) never sees them. The sweep asks git instead: a
-// baseline `git status --porcelain` snapshot is taken at startup (Init), and a
-// re-run after each command tool result / turn end reports any NEWLY dirty
-// paths, which merge into the roster with a diffstat from `git diff --numstat`.
-// Pre-existing dirty state stays in the baseline and never shows; a non-git
-// workspace fails the first command and the sweep silently stays off.
-package tui
-
-import (
-	"context"
-	"strconv"
-	"strings"
-	"time"
-
-	tea "charm.land/bubbletea/v2"
-)
-
-// gitSweepTimeout bounds each background git invocation so a hung index lock
-// can never stall message delivery (the command runs off the update goroutine).
-const gitSweepTimeout = 3 * time.Second
-
-// gitSweepFile is one workspace file git reports as dirty: workspace-relative
-// path (git's own output convention, matching changedFiles), whether it is new
-// (untracked/added), and the tracked diffstat when known (0/0 for untracked).
-type gitSweepFile struct {
-	path    string
-	created bool
-	adds    int
-	dels    int
-}
-
-// gitSweepMsg carries one sweep's result. baseline marks the startup snapshot
-// (recorded as "pre-existing, never show") vs a live re-check (merged into the
-// roster). ok is false when git failed (not a repo, no git binary) — the
-// handler then marks the sweep unavailable rather than retrying every turn.
-type gitSweepMsg struct {
-	baseline bool
-	ok       bool
-	files    []gitSweepFile
-}
-
-// gitSweepCmd runs the status+numstat pair off the update goroutine. cwd is the
-// workspace root the TUI resolves paths against.
-func gitSweepCmd(parent context.Context, cwd string, baseline bool) tea.Cmd {
-	return func() tea.Msg {
-		if parent == nil {
-			parent = context.Background()
-		}
-		ctx, cancel := context.WithTimeout(parent, gitSweepTimeout)
-		defer cancel()
-		// --untracked-files=all enumerates files inside new directories; plain
-		// porcelain collapses them to "dir/", which is useless as a FILES row.
-		status, err := defaultPRCommandRunner(ctx, cwd, "git", "status", "--porcelain", "--untracked-files=all")
-		if err != nil {
-			return gitSweepMsg{baseline: baseline, ok: false}
-		}
-		files := parseGitPorcelain(status)
-		// Diffstat for tracked modifications; untracked files have no diff to
-		// stat. -z makes the output machine-parseable: NUL-terminated records, no
-		// path quoting, and renames as explicit preimage/postimage fields instead
-		// of the brace-mangled "src/{old => new}" a plain --numstat emits (which
-		// would never match a porcelain path). Best-effort: a failure (e.g. unborn
-		// HEAD in a fresh repo) keeps the file list with zero counts rather than
-		// dropping the sweep.
-		if numstat, err := defaultPRCommandRunner(ctx, cwd, "git", "diff", "HEAD", "--numstat", "-z"); err == nil {
-			stats := parseGitNumstat(numstat)
-			for i := range files {
-				if counts, ok := stats[files[i].path]; ok {
-					files[i].adds, files[i].dels = counts[0], counts[1]
-				}
-			}
-		}
-		return gitSweepMsg{baseline: baseline, ok: true, files: files}
-	}
-}
-
-// parseGitPorcelain parses `git status --porcelain` v1 output into sweep files.
-// Format: two status columns, a space, then the path ("XY path"); renames show
-// "old -> new" (keep the new side); untracked entries are "?? path".
-func parseGitPorcelain(out string) []gitSweepFile {
-	var files []gitSweepFile
-	for _, line := range strings.Split(out, "\n") {
-		if len(line) < 4 {
-			continue
-		}
-		code, path := line[:2], strings.TrimSpace(line[3:])
-		if to, _, found := cutRename(path); found {
-			path = to
-		}
-		path = unquoteGitPath(path)
-		if path == "" {
-			continue
-		}
-		files = append(files, gitSweepFile{
-			path:    path,
-			created: code == "??" || strings.Contains(code, "A"),
-		})
-	}
-	return files
-}
-
-// cutRename splits a porcelain rename value "old -> new", returning the new
-// path. found is false for ordinary (non-rename) paths.
-func cutRename(path string) (string, string, bool) {
-	if idx := strings.Index(path, " -> "); idx >= 0 {
-		return path[idx+4:], path[:idx], true
-	}
-	return "", "", false
-}
-
-// unquoteGitPath strips the quotes git wraps around paths with special
-// characters ("web/my file.js"). Escapes inside are left as-is — such a path
-// still identifies the file well enough for a sidebar row.
-func unquoteGitPath(path string) string {
-	if len(path) >= 2 && strings.HasPrefix(path, `"`) && strings.HasSuffix(path, `"`) {
-		return path[1 : len(path)-1]
-	}
-	return path
-}
-
-// parseGitNumstat parses `git diff --numstat -z` output into path → [added,
-// deleted]. -z records are NUL-terminated "added\tdeleted\tpath"; a rename/copy
-// instead ends the counts record with an EMPTY path ("added\tdeleted\t") and
-// appends two more NUL-terminated fields, preimage then postimage — the stats
-// key is the postimage (the path porcelain/changedFiles report). Paths are
-// never quoted or brace-mangled in -z mode. Binary files report "-" counts and
-// are skipped.
-func parseGitNumstat(out string) map[string][2]int {
-	stats := map[string][2]int{}
-	fields := strings.Split(out, "\x00")
-	for i := 0; i < len(fields); i++ {
-		parts := strings.SplitN(fields[i], "\t", 3)
-		if len(parts) != 3 {
-			continue
-		}
-		adds, errA := strconv.Atoi(parts[0])
-		dels, errD := strconv.Atoi(parts[1])
-		if errA != nil || errD != nil {
-			continue
-		}
-		path := parts[2]
-		if path == "" {
-			// Rename/copy record: the next two fields are preimage, postimage.
-			if i+2 >= len(fields) {
-				break // truncated output — drop the partial record
-			}
-			path = fields[i+2]
-			i += 2
-		}
-		if path != "" {
-			stats[path] = [2]int{adds, dels}
-		}
-	}
-	return stats
-}
-
-// handleGitSweepMsg folds a sweep result into the model: the baseline snapshot
-// records what was already dirty before this TUI session (those paths never
-// show), a live sweep upserts newly dirty paths into gitTouched in first-seen
-// order. A failed sweep marks git unavailable so no further sweeps are issued.
-func (m model) handleGitSweepMsg(msg gitSweepMsg) model {
-	m.gitSweepInFlight = false
-	if !msg.ok {
-		m.gitSweepUnavailable = true
-		if m.gitFileBaseline == nil {
-			m.gitFileBaseline = map[string]bool{}
-		}
-		return m
-	}
-	if msg.baseline {
-		baseline := make(map[string]bool, len(msg.files))
-		for _, f := range msg.files {
-			baseline[f.path] = true
-		}
-		m.gitFileBaseline = baseline
-		return m
-	}
-	for _, f := range msg.files {
-		if m.gitFileBaseline[f.path] {
-			continue
-		}
-		found := false
-		for i := range m.gitTouched {
-			if m.gitTouched[i].path == f.path {
-				m.gitTouched[i] = f
-				found = true
-				break
-			}
-		}
-		if !found {
-			// Copy-on-append: model copies share the backing array, so an in-place
-			// append from two update branches could alias. Rebuilding is cheap at
-			// sidebar scale.
-			m.gitTouched = append(append([]gitSweepFile(nil), m.gitTouched...), f)
-		}
-	}
-	return m
-}
-
-// maybeGitSweep issues a live sweep when one is useful and none is running:
-// the baseline exists (Init's snapshot answered), git works here, and the
-// workspace is known. Returns the (possibly nil) command to batch.
-func (m model) maybeGitSweep() (model, tea.Cmd) {
-	if m.gitSweepInFlight || m.gitSweepUnavailable || m.gitFileBaseline == nil || strings.TrimSpace(m.cwd) == "" {
-		return m, nil
-	}
-	m.gitSweepInFlight = true
-	return m, gitSweepCmd(m.ctx, m.cwd, false)
-}
-
-// gitTouchedFiles adapts the sweep results to the roster's touchedFile shape,
-// for merging under the transcript-derived entries (files_panel.go), newest
-// detection first — gitTouched upserts in first-seen order, so iterating it in
-// reverse keeps the merged FILES tail consistent with the roster's
-// newest-first ordering. No transcript row backs them (lastRowIndex -1), so
-// selecting one skips the scroll/tint and the drill-in opens on the full file.
-func (m model) gitTouchedFiles() []touchedFile {
-	if len(m.gitTouched) == 0 {
-		return nil
-	}
-	files := make([]touchedFile, 0, len(m.gitTouched))
-	for i := len(m.gitTouched) - 1; i >= 0; i-- {
-		f := m.gitTouched[i]
-		files = append(files, touchedFile{
-			path:         f.path,
-			created:      f.created,
-			adds:         f.adds,
-			dels:         f.dels,
-			lastRowIndex: -1,
-		})
-	}
-	return files
-}

internal/tui/files_git_sweep_test.go

@@ -1,243 +0,0 @@
-package tui
-
-import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"testing"
-)
-
-func TestParseGitPorcelain(t *testing.T) {
-	out := " M web/app.js\n?? web/new.css\nA  docs/added.md\nR  old.go -> pkg/new.go\n?? \"web/my file.js\"\n\n"
-	files := parseGitPorcelain(out)
-	if len(files) != 5 {
-		t.Fatalf("expected 5 entries, got %d: %+v", len(files), files)
-	}
-	byPath := map[string]gitSweepFile{}
-	for _, f := range files {
-		byPath[f.path] = f
-	}
-	if f := byPath["web/app.js"]; f.created {
-		t.Error("modified file must not read as created")
-	}
-	if f := byPath["web/new.css"]; !f.created {
-		t.Error("untracked file should read as created")
-	}
-	if f := byPath["docs/added.md"]; !f.created {
-		t.Error("index-added file should read as created")
-	}
-	if _, ok := byPath["pkg/new.go"]; !ok {
-		t.Errorf("rename should keep the new path: %+v", files)
-	}
-	if _, ok := byPath["web/my file.js"]; !ok {
-		t.Errorf("quoted path should unquote: %+v", files)
-	}
-}
-
-// TestParseGitNumstat feeds the exact `git diff --numstat -z` record shapes:
-// plain "added\tdeleted\tpath\0", binary "-\t-\tpath\0", and the rename form
-// "added\tdeleted\t\0preimage\0postimage\0" — the stats must key the postimage
-// (the path porcelain/changedFiles report), which the old newline parser lost
-// (plain --numstat brace-mangles renames, so they never matched a roster path).
-func TestParseGitNumstat(t *testing.T) {
-	out := "12\t3\tweb/app.js\x00" +
-		"-\t-\tassets/logo.png\x00" +
-		"4\t0\t\x00old.go\x00pkg/new.go\x00" +
-		"1\t1\tweb/my file.js\x00" // -z paths are never quoted
-	stats := parseGitNumstat(out)
-	if got := stats["web/app.js"]; got != [2]int{12, 3} {
-		t.Errorf("web/app.js = %v, want [12 3]", got)
-	}
-	if _, ok := stats["assets/logo.png"]; ok {
-		t.Error("binary '-' entries must be skipped")
-	}
-	if got := stats["pkg/new.go"]; got != [2]int{4, 0} {
-		t.Errorf("renamed file must key the postimage path = %v, want [4 0]", got)
-	}
-	if _, ok := stats["old.go"]; ok {
-		t.Error("the rename preimage must not appear as its own entry")
-	}
-	if got := stats["web/my file.js"]; got != [2]int{1, 1} {
-		t.Errorf("path with spaces = %v, want [1 1] (no quoting in -z mode)", got)
-	}
-	// Truncated rename record (missing postimage) must not panic or mis-key.
-	if got := parseGitNumstat("4\t0\t\x00old.go"); len(got) != 0 {
-		t.Errorf("truncated rename record should be dropped, got %v", got)
-	}
-}
-
-// TestGitSweepMergeAndBaseline: the baseline snapshot hides pre-existing dirty
-// paths; live sweeps upsert only new ones; a failed sweep latches unavailable.
-func TestGitSweepMergeAndBaseline(t *testing.T) {
-	m := model{}
-	m = m.handleGitSweepMsg(gitSweepMsg{baseline: true, ok: true, files: []gitSweepFile{{path: "dirty-before.go"}}})
-	if !m.gitFileBaseline["dirty-before.go"] {
-		t.Fatal("baseline should record pre-existing dirty paths")
-	}
-
-	m = m.handleGitSweepMsg(gitSweepMsg{ok: true, files: []gitSweepFile{
-		{path: "dirty-before.go", adds: 9},
-		{path: "kanban/board.tsx", created: true, adds: 120},
-	}})
-	if len(m.gitTouched) != 1 || m.gitTouched[0].path != "kanban/board.tsx" {
-		t.Fatalf("only newly dirty paths should merge: %+v", m.gitTouched)
-	}
-
-	// Re-sweep updates stats in place, no duplicate.
-	m = m.handleGitSweepMsg(gitSweepMsg{ok: true, files: []gitSweepFile{{path: "kanban/board.tsx", created: true, adds: 150, dels: 2}}})
-	if len(m.gitTouched) != 1 || m.gitTouched[0].adds != 150 {
-		t.Fatalf("re-sweep should upsert stats: %+v", m.gitTouched)
-	}
-
-	failed := model{}
-	failed = failed.handleGitSweepMsg(gitSweepMsg{baseline: true, ok: false})
-	if !failed.gitSweepUnavailable {
-		t.Fatal("a failed sweep should latch unavailable")
-	}
-	if _, cmd := failed.maybeGitSweep(); cmd != nil {
-		t.Fatal("no further sweeps once unavailable")
-	}
-}
-
-// TestMaybeGitSweepGating: no sweep before the baseline answers, none while one
-// is in flight, and the in-flight flag sets when one is issued.
-func TestMaybeGitSweepGating(t *testing.T) {
-	m := model{cwd: "/tmp"}
-	if _, cmd := m.maybeGitSweep(); cmd != nil {
-		t.Fatal("no baseline yet: sweep must not run")
-	}
-	m.gitFileBaseline = map[string]bool{}
-	next, cmd := m.maybeGitSweep()
-	if cmd == nil || !next.gitSweepInFlight {
-		t.Fatal("with a baseline, a sweep should be issued and marked in flight")
-	}
-	if _, again := next.maybeGitSweep(); again != nil {
-		t.Fatal("single-flight: no second sweep while one runs")
-	}
-}
-
-// TestTouchedFilesMergesGitSweep: git-discovered files append below the
-// transcript-derived entries, deduped by path (a tool-result entry wins).
-func TestTouchedFilesMergesGitSweep(t *testing.T) {
-	m := filesPanelTestModel()
-	m.gitTouched = []gitSweepFile{
-		{path: "kanban/board.tsx", created: true, adds: 120},
-		{path: "web/app.js", adds: 999}, // duplicate of a transcript entry
-	}
-	files := m.touchedFiles()
-	var kanban *touchedFile
-	appCount := 0
-	for i := range files {
-		if files[i].path == "kanban/board.tsx" {
-			kanban = &files[i]
-		}
-		if files[i].path == "web/app.js" {
-			appCount++
-			if files[i].adds == 999 {
-				t.Error("transcript-derived entry should win over the git duplicate")
-			}
-		}
-	}
-	if kanban == nil || !kanban.created || kanban.lastRowIndex != -1 {
-		t.Fatalf("git-only file should merge with created badge and no row anchor: %+v", files)
-	}
-	if appCount != 1 {
-		t.Fatalf("web/app.js should appear exactly once, got %d", appCount)
-	}
-}
-
-// TestOpenFileViewGitOnlyFallsBackToFull: a file with no edit cards (git sweep
-// discovery) opens straight on the full-file view instead of an empty diff.
-func TestOpenFileViewGitOnlyFallsBackToFull(t *testing.T) {
-	m := filesPanelTestModel()
-	m.gitTouched = []gitSweepFile{{path: "kanban/board.tsx", created: true}}
-	m = m.openFileView("kanban/board.tsx")
-	if m.fileView.mode != fileViewFull {
-		t.Fatal("git-only file should open in full mode")
-	}
-	m = m.exitFileView()
-	m = m.openFileView("web/app.js")
-	if m.fileView.mode != fileViewDiff {
-		t.Fatal("a file with edit cards still opens in diff mode")
-	}
-}
-
-// TestGitSweepCmdAgainstRealRepo: end-to-end against a real git repo — the
-// baseline sees pre-existing dirt, a post-mutation sweep reports the new file
-// as created and the modified file with its numstat.
-func TestGitSweepCmdAgainstRealRepo(t *testing.T) {
-	if _, err := exec.LookPath("git"); err != nil {
-		t.Skip("git not installed")
-	}
-	dir := t.TempDir()
-	run := func(args ...string) {
-		t.Helper()
-		cmd := exec.Command("git", args...)
-		cmd.Dir = dir
-		cmd.Env = append(os.Environ(),
-			"GIT_AUTHOR_NAME=t", "GIT_AUTHOR_EMAIL=t@t", "GIT_COMMITTER_NAME=t", "GIT_COMMITTER_EMAIL=t@t")
-		if out, err := cmd.CombinedOutput(); err != nil {
-			t.Fatalf("git %v: %v\n%s", args, err, out)
-		}
-	}
-	write := func(name, content string) {
-		t.Helper()
-		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	run("init", "-q")
-	write("tracked.txt", "one\ntwo\n")
-	run("add", ".")
-	run("commit", "-q", "-m", "seed")
-	write("pre-existing.txt", "dirt\n") // dirty BEFORE the TUI "opens"
-
-	baseline := gitSweepCmd(nil, dir, true)().(gitSweepMsg)
-	if !baseline.ok || len(baseline.files) != 1 || baseline.files[0].path != "pre-existing.txt" {
-		t.Fatalf("baseline should see only the pre-existing dirt: %+v", baseline)
-	}
-
-	// The "agent" now scaffolds via the shell.
-	write("scaffolded.txt", "hello\n")
-	write("tracked.txt", "one\ntwo\nthree\nfour\n")
-
-	sweep := gitSweepCmd(nil, dir, false)().(gitSweepMsg)
-	if !sweep.ok {
-		t.Fatal("sweep failed")
-	}
-	byPath := map[string]gitSweepFile{}
-	for _, f := range sweep.files {
-		byPath[f.path] = f
-	}
-	if f, ok := byPath["scaffolded.txt"]; !ok || !f.created {
-		t.Fatalf("scaffolded file should report created: %+v", sweep.files)
-	}
-	if f := byPath["tracked.txt"]; f.adds != 2 || f.dels != 0 {
-		t.Fatalf("tracked.txt numstat = +%d −%d, want +2 −0", f.adds, f.dels)
-	}
-
-	// A rename WITH edits: porcelain reports the new path, and the -z numstat
-	// rename record must resolve to the same (postimage) path so the diffstat
-	// actually attaches — the plain --numstat form brace-mangles the path and
-	// the counts were silently lost.
-	run("add", ".")
-	run("commit", "-q", "-m", "second")
-	run("mv", "tracked.txt", "renamed.txt")
-	write("renamed.txt", "one\ntwo\nthree\nfour\nfive\n")
-	renameSweep := gitSweepCmd(nil, dir, false)().(gitSweepMsg)
-	if !renameSweep.ok {
-		t.Fatal("rename sweep failed")
-	}
-	renamed := map[string]gitSweepFile{}
-	for _, f := range renameSweep.files {
-		renamed[f.path] = f
-	}
-	if f, ok := renamed["renamed.txt"]; !ok || f.adds != 1 {
-		t.Fatalf("renamed file should carry its numstat under the new path, got %+v", renameSweep.files)
-	}
-
-	// Not-a-repo → ok=false (the sweep latches off).
-	if msg := gitSweepCmd(nil, t.TempDir(), false)().(gitSweepMsg); msg.ok {
-		t.Fatal("a non-repo should report ok=false")
-	}
-}

internal/tui/files_panel.go

@@ -1,416 +0,0 @@
-// files_panel.go renders the FILES section of the right context sidebar: the
-// workspace files this session has touched, newest first, with an A/M badge and
-// a +added/−removed diffstat per file, plus a pulsing row for the file whose
-// write is streaming right now. Like the swarm roster (sidebar.go), the touched
-// set is not separate model state — it is recovered on demand from the
-// transcript's tool-result rows (their changedFiles), so it survives resume for
-// free and can never drift from what the chat shows.
-//
-// Interaction (see handleTranscriptSelectionMouse): the first click on a row
-// SELECTS the file — its edit cards tint in the chat and the transcript scrolls
-// to the most recent one; a second click (or a click while the drill-in is
-// already open) opens the file view (file_view.go). Esc clears the selection.
-package tui
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	tea "charm.land/bubbletea/v2"
-
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// maxSidebarFiles caps the FILES rows so the section stays a glanceable set,
-// not a scrolling log; older files collapse into a "+N more" trailer.
-const maxSidebarFiles = 6
-
-// touchedFile is one workspace file the session has mutated, aggregated across
-// every tool-result row that touched it.
-type touchedFile struct {
-	path         string
-	adds         int  // total added lines across its diffs
-	dels         int  // total removed lines across its diffs
-	edits        int  // number of mutations
-	created      bool // first touch created the file (write_file "Created …")
-	failed       bool // the latest touch errored
-	lastRowIndex int  // transcript index of the most recent result touching it
-}
-
-// touchedFiles recovers the session's touched-file roster from the transcript,
-// most recently touched first. Recomputed on demand (the value-receiver model
-// can't persist a registry from View), mirroring swarmSpawnedAgents; the scan is
-// a single pass over the transcript per render, same order as the sidebar's
-// other sections.
-func (m model) touchedFiles() []touchedFile {
-	var files []touchedFile
-	index := map[string]int{}
-	for i, row := range m.transcript {
-		if row.kind != rowToolResult || len(row.changedFiles) == 0 {
-			continue
-		}
-		adds, dels := planDiffStat(row.detail)
-		// A multi-file result (apply_patch spanning several files) must not charge
-		// the WHOLE patch's totals to every file it touched — split the diff by its
-		// per-file headers and attribute each file its own counts.
-		var perFile map[string][2]int
-		if len(row.changedFiles) > 1 {
-			perFile = perFileDiffStats(row.detail)
-		}
-		for _, path := range row.changedFiles {
-			if path == "" {
-				continue
-			}
-			at, seen := index[path]
-			if !seen {
-				index[path] = len(files)
-				files = append(files, touchedFile{
-					path:         path,
-					created:      resultRowCreatedFile(row),
-					lastRowIndex: i,
-				})
-				at = len(files) - 1
-			}
-			fileAdds, fileDels := adds, dels
-			if perFile != nil {
-				// Headers were found: use this file's own counts. A path the split
-				// couldn't attribute shows 0/0 rather than the inflated patch totals.
-				counts := perFile[path]
-				fileAdds, fileDels = counts[0], counts[1]
-			}
-			files[at].adds += fileAdds
-			files[at].dels += fileDels
-			files[at].edits++
-			files[at].failed = row.status == tools.StatusError
-			files[at].lastRowIndex = i
-		}
-	}
-	// Most recently touched first: the file being worked on now belongs at the
-	// top, like the sidebar's ACTIVITY feed. Sorted by last touch (not reversed
-	// first-seen order): a file touched early and touched again last must list
-	// first. Stable, so same-row files keep their changedFiles order.
-	sort.SliceStable(files, func(i, j int) bool {
-		return files[i].lastRowIndex > files[j].lastRowIndex
-	})
-	// Merge the git sweep's discoveries (bash/subagent mutations that carry no
-	// changedFiles — files_git_sweep.go) below the transcript-derived entries,
-	// skipping paths a tool result already reported.
-	for _, f := range m.gitTouchedFiles() {
-		if _, seen := index[f.path]; seen {
-			continue
-		}
-		files = append(files, f)
-	}
-	return files
-}
-
-// perFileDiffStats splits a (possibly multi-file) unified diff into per-path
-// +added/−removed counts, keyed by the workspace-relative path from each
-// section's "+++ b/…" header (the "--- a/…" old side when the new side is
-// /dev/null, i.e. a deletion). Returns nil when the detail carries no file
-// headers at all (write_file/edit_file previews may be bare hunks) — the caller
-// then falls back to whole-detail totals, which are correct for a single file.
-func perFileDiffStats(detail string) map[string][2]int {
-	stats := map[string][2]int{}
-	current, oldPath := "", ""
-	normalize := func(line string, prefix string) string {
-		path := strings.TrimSpace(line[4:])
-		if tab := strings.IndexByte(path, '\t'); tab >= 0 {
-			path = path[:tab] // unified-diff convention: optional timestamp after a tab
-		}
-		path = unquoteGitPath(path)
-		if path == "/dev/null" {
-			return ""
-		}
-		return strings.TrimPrefix(path, prefix)
-	}
-	for _, line := range strings.Split(detail, "\n") {
-		switch {
-		case strings.HasPrefix(line, "--- "):
-			oldPath = normalize(line, "a/")
-		case strings.HasPrefix(line, "+++ "):
-			current = normalize(line, "b/")
-			if current == "" {
-				current = oldPath // deletion: charge the removed lines to the old path
-			}
-		case current == "":
-			// Lines before the first header (or in an unattributable section).
-		case strings.HasPrefix(line, "+"):
-			counts := stats[current]
-			counts[0]++
-			stats[current] = counts
-		case strings.HasPrefix(line, "-"):
-			counts := stats[current]
-			counts[1]++
-			stats[current] = counts
-		}
-	}
-	if len(stats) == 0 {
-		return nil
-	}
-	return stats
-}
-
-// resultRowCreatedFile reports whether a tool-result row reads as a file
-// creation ("tool result: write_file ok Created x (…)"), so the FILES row can
-// badge it A rather than M. Heuristic on the confirmation text write_file
-// already emits; a miss just shows M, never breaks anything.
-func resultRowCreatedFile(row transcriptRow) bool {
-	return strings.Contains(row.text, " Created ")
-}
-
-// liveEditingPath is the path of the file whose mutating tool call is streaming
-// its arguments RIGHT NOW (the same live write streamingToolCallView previews),
-// or "" when no mutation is in flight. It renders as a pulsing row pinned atop
-// the FILES section.
-func (m model) liveEditingPath() string {
-	if m.streamCallDecoder == nil {
-		return ""
-	}
-	switch m.streamCallName {
-	case "write_file", "edit_file", "apply_patch":
-		return m.streamCallDecoder.path
-	}
-	return ""
-}
-
-// fileHit marks a rendered FILES row (by its ABSOLUTE index inside the rendered
-// sidebar) that is clickable, carrying the file it refers to.
-type fileHit struct {
-	lineOffset int
-	path       string
-}
-
-// sidebarFilesHeader renders the FILES section header with the touched count.
-func (m model) sidebarFilesHeader(width int) string {
-	n := len(m.touchedFiles())
-	if n == 0 {
-		return sidebarHeader("FILES", width)
-	}
-	return sidebarHeaderWithCount("FILES", fmt.Sprintf("%d", n), zeroTheme.muted, width)
-}
-
-// sidebarFileLines renders the FILES section body: the live "writing" pulse row
-// first, then the touched files newest-first, capped at maxSidebarFiles with a
-// "+N more" trailer. Returns nil when the session has touched nothing (the
-// caller shows a placeholder). The paired hits slice records each clickable
-// row's index WITHIN the returned lines.
-func (m model) sidebarFileLines(width int) ([]string, []fileHit) {
-	files := m.touchedFiles()
-	live := m.liveEditingPath()
-	if len(files) == 0 && live == "" {
-		return nil, nil
-	}
-	room := maxInt(4, width-3)
-	var lines []string
-	var hits []fileHit
-
-	// The file being written this instant: an accent pulse, not yet clickable
-	// (its result row — the diff — doesn't exist until the call completes).
-	if live != "" {
-		lines = append(lines, " "+zeroTheme.accent.Render("●")+" "+
-			zeroTheme.ink.Render(truncatePathLeft(live, room)))
-	}
-
-	// Filter the live row out FIRST so the "+N more" trailer counts only rows
-	// that could actually render — counting the skipped live entry would inflate
-	// the overflow by one.
-	visible := files[:0:0]
-	for _, f := range files {
-		if f.path != live {
-			visible = append(visible, f)
-		}
-	}
-	shown := 0
-	for _, f := range visible {
-		if shown >= maxSidebarFiles {
-			lines = append(lines, "   "+zeroTheme.faint.Render(fmt.Sprintf("+%d more", len(visible)-shown)))
-			break
-		}
-		shown++
-		hits = append(hits, fileHit{lineOffset: len(lines), path: f.path})
-		lines = append(lines, m.renderFileRow(f, room))
-	}
-	return lines, hits
-}
-
-// renderFileRow renders one touched file: status badge, left-truncated path,
-// and the +/− diffstat, with the selected file carrying an accent marker so the
-// selection reads in the sidebar as well as in the chat tint.
-func (m model) renderFileRow(f touchedFile, room int) string {
-	badge := zeroTheme.muted.Render("M")
-	switch {
-	case f.failed:
-		badge = zeroTheme.red.Render("✗")
-	case f.created:
-		badge = zeroTheme.green.Render("A")
-	}
-	// Reserve the diffstat's width so the path truncates around it.
-	stat := ""
-	if f.adds > 0 || f.dels > 0 {
-		stat = fmt.Sprintf(" +%d −%d", f.adds, f.dels)
-	}
-	pathRoom := maxInt(4, room-len(stat))
-	pathStyle := zeroTheme.muted
-	lead := " "
-	if m.selectedFile == f.path {
-		lead = zeroTheme.accent.Render("▸")
-		pathStyle = zeroTheme.ink
-	}
-	line := lead + badge + " " + pathStyle.Render(truncatePathLeft(f.path, pathRoom))
-	if stat != "" {
-		line += zeroTheme.faintest.Render(stat)
-	}
-	return line
-}
-
-// sidebarFileSelectables returns the clickable FILES rows with their ABSOLUTE
-// index inside the rendered sidebar. The FILES section renders after PLAN in
-// renderContextSidebar: AGENTS header + body, blank + PLAN header + body, then
-// blank + FILES header, then the file rows. The offset accounting mirrors
-// sidebarPlanSelectables exactly, extended one section down.
-func (m model) sidebarFileSelectables(width int) []fileHit {
-	lines, hits := m.sidebarFileLines(width)
-	if len(lines) == 0 {
-		return nil
-	}
-	agentBody := len(m.sidebarAgentLines(width))
-	if agentBody == 0 {
-		agentBody = 1 // the "no agents spawned" placeholder occupies one line
-	}
-	planBody := len(m.sidebarPlanLines(width))
-	if planBody == 0 {
-		planBody = 1 // the "no active plan" placeholder occupies one line
-	}
-	base := 1 + agentBody + 2 + planBody + 2 // sections above + (blank + FILES header)
-	for i := range hits {
-		hits[i].lineOffset += base
-	}
-	return hits
-}
-
-// fileRowAtMouse maps a left-click in the context sidebar to a touched file,
-// mirroring planStepAtMouse's column/x gate. Rows truncated away by the
-// sidebar's height budget (or colliding with the token floor line) never match.
-func (m model) fileRowAtMouse(msg tea.MouseMsg) (string, bool) {
-	if !m.sidebarActive() {
-		return "", false
-	}
-	if m.setup.visible || m.providerWizard != nil || m.mcpAddWizard != nil || m.mcpManager != nil || m.picker != nil || m.suggestionsActive() {
-		return "", false
-	}
-	sidebarW := sidebarWidth(m.width)
-	if sidebarW <= 0 {
-		return "", false
-	}
-	x0 := m.chatColumnWidth() + 3 // " │ " divider between the columns
-	x, y := mouseX(msg), mouseY(msg)
-	if x < x0 || x >= x0+sidebarW {
-		return "", false
-	}
-	for _, hit := range m.sidebarFileSelectables(sidebarW) {
-		if hit.lineOffset == y && hit.lineOffset < m.height-1 && hit.path != "" {
-			return hit.path, true
-		}
-	}
-	return "", false
-}
-
-// rowTouchesSelectedFile reports whether a transcript row's mutation touched
-// the currently selected file, so its card renders with the selection tint.
-func (m model) rowTouchesSelectedFile(row transcriptRow) bool {
-	if m.selectedFile == "" || row.kind != rowToolResult {
-		return false
-	}
-	for _, path := range row.changedFiles {
-		if path == m.selectedFile {
-			return true
-		}
-	}
-	return false
-}
-
-// lastRowIndexForFile returns the transcript index of the most recent
-// tool-result row that touched path, or -1.
-func (m model) lastRowIndexForFile(path string) int {
-	for i := len(m.transcript) - 1; i >= 0; i-- {
-		row := m.transcript[i]
-		if row.kind != rowToolResult {
-			continue
-		}
-		for _, p := range row.changedFiles {
-			if p == path {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
-// selectFile marks path as the selected file and scrolls the transcript so its
-// most recent edit card is in view; the card tint comes from the renderers
-// reading selectedFile (rowTouchesSelectedFile).
-func (m model) selectFile(path string) model {
-	m.selectedFile = path
-	if offset, ok := m.scrollOffsetForTranscriptRow(m.lastRowIndexForFile(path)); ok {
-		m.chatScrollOffset = offset
-		if offset == 0 {
-			m.chatBodyLines = 0
-		}
-	}
-	return m
-}
-
-// scrollOffsetForTranscriptRow computes the chatScrollOffset that places the
-// given transcript row's first rendered line at the top of the viewport (with
-// one line of breathing room), using the same layout metrics the scroll engine
-// itself uses. ok is false outside alt-screen or when the row isn't rendered
-// (e.g. skipped/collapsed).
-func (m model) scrollOffsetForTranscriptRow(rowIndex int) (int, bool) {
-	if rowIndex < 0 || !m.altScreen || m.height <= 0 {
-		return 0, false
-	}
-	width := m.chatColumnWidth()
-	items := m.transcriptBodyItems(width, "")
-	metrics := measureTranscriptBodyItems(items, m.transcriptBodyHeights)
-	startY := -1
-	for _, span := range metrics.spans {
-		if span.kind == transcriptBodyItemRow && span.rowIndex == rowIndex {
-			startY = span.startY
-			break
-		}
-	}
-	if startY < 0 {
-		return 0, false
-	}
-	frame := m.scrollableTranscriptFrame(m.pinnedTitleBar(width), m.footerView(width))
-	viewport := transcriptViewportForLayout(metrics, frame, m.chatScrollOffset)
-	// The offset counts lines below the fold: window.start == total-height-offset,
-	// so placing startY at the window top (minus one context line) means
-	// offset = total - height - (startY - 1), clamped to the scroll range.
-	offset := metrics.totalLines() - frame.bodyRect.height - (startY - 1)
-	return clampInt(offset, 0, viewport.maxOffset()), true
-}
-
-// truncatePathLeft fits a path into room cells by dropping leading components
-// ("internal/tui/sidebar.go" → "…/tui/sidebar.go"), keeping the filename — the
-// part that identifies the file — intact for as long as possible.
-func truncatePathLeft(path string, room int) string {
-	if room <= 0 {
-		return ""
-	}
-	if len(path) <= room {
-		return path
-	}
-	const ellipsis = "…/"
-	parts := strings.Split(path, "/")
-	for start := 1; start < len(parts); start++ {
-		candidate := ellipsis + strings.Join(parts[start:], "/")
-		if len(candidate) <= room {
-			return candidate
-		}
-	}
-	// Even "…/name" overflows: fall back to a right-truncated basename.
-	return truncateRunes(ellipsis+parts[len(parts)-1], room)
-}

internal/tui/files_panel_test.go

@@ -1,317 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-
-	tea "charm.land/bubbletea/v2"
-
-	"github.com/Gitlawb/zero/internal/tools"
-)
-
-// filesPanelTestModel is sidebarTestModel plus a couple of touched files: one
-// created, one edited twice (the second touch most recent).
-func filesPanelTestModel() model {
-	m := sidebarTestModel()
-	m.transcript = append(m.transcript,
-		transcriptRow{kind: rowToolResult, tool: "write_file", id: "f1", status: tools.StatusOK,
-			text:         "tool result: write_file ok Created web/app.js (10 lines).",
-			detail:       "+let a = 1\n+let b = 2",
-			changedFiles: []string{"web/app.js"}},
-		transcriptRow{kind: rowToolResult, tool: "edit_file", id: "f2", status: tools.StatusOK,
-			text:         "tool result: edit_file ok Edited internal/tui/sidebar.go.",
-			detail:       "+added one\n-removed one",
-			changedFiles: []string{"internal/tui/sidebar.go"}},
-		transcriptRow{kind: rowToolResult, tool: "edit_file", id: "f3", status: tools.StatusOK,
-			text:         "tool result: edit_file ok Edited internal/tui/sidebar.go.",
-			detail:       "+two\n+three\n-gone",
-			changedFiles: []string{"internal/tui/sidebar.go"}},
-	)
-	return m
-}
-
-// TestTouchedFilesAggregates: the roster is recovered from tool-result rows,
-// newest-touch first, with per-file diffstat totals, edit counts, and the
-// created badge from write_file's confirmation text.
-func TestTouchedFilesAggregates(t *testing.T) {
-	m := filesPanelTestModel()
-	files := m.touchedFiles()
-	if len(files) != 2 {
-		t.Fatalf("expected 2 touched files, got %d: %+v", len(files), files)
-	}
-	// sidebar.go was touched last, so it lists first.
-	if files[0].path != "internal/tui/sidebar.go" {
-		t.Fatalf("most recently touched file should list first, got %q", files[0].path)
-	}
-	if files[0].adds != 3 || files[0].dels != 2 || files[0].edits != 2 {
-		t.Errorf("sidebar.go diffstat = +%d −%d over %d edits, want +3 −2 over 2", files[0].adds, files[0].dels, files[0].edits)
-	}
-	if files[0].created {
-		t.Error("edited file must not read as created")
-	}
-	if !files[1].created {
-		t.Error("write_file 'Created …' result should mark the file created")
-	}
-	if files[0].lastRowIndex != len(m.transcript)-1 {
-		t.Errorf("lastRowIndex = %d, want the final transcript row", files[0].lastRowIndex)
-	}
-}
-
-// TestSidebarFileLinesRenderAndOverflow: rows carry the badge + left-truncated
-// path + diffstat; beyond maxSidebarFiles the tail collapses into "+N more";
-// hits index only real file rows.
-func TestSidebarFileLinesRenderAndOverflow(t *testing.T) {
-	m := filesPanelTestModel()
-	lines, hits := m.sidebarFileLines(34)
-	joined := plainRender(t, strings.Join(lines, "\n"))
-	if !strings.Contains(joined, "sidebar.go") || !strings.Contains(joined, "app.js") {
-		t.Fatalf("file rows missing paths:\n%s", joined)
-	}
-	if !strings.Contains(joined, "+3 −2") {
-		t.Errorf("expected aggregated diffstat +3 −2:\n%s", joined)
-	}
-	if !strings.Contains(joined, "A") || !strings.Contains(joined, "M") {
-		t.Errorf("expected A and M badges:\n%s", joined)
-	}
-	if len(hits) != 2 {
-		t.Fatalf("expected 2 clickable hits, got %d", len(hits))
-	}
-	if hits[0].path != "internal/tui/sidebar.go" {
-		t.Errorf("first hit should be the newest file, got %q", hits[0].path)
-	}
-
-	// Overflow: 8 distinct files -> maxSidebarFiles rows + a "+2 more" trailer.
-	over := sidebarTestModel()
-	for _, name := range []string{"a", "b", "c", "d", "e", "f", "g", "h"} {
-		over.transcript = append(over.transcript, transcriptRow{
-			kind: rowToolResult, tool: "edit_file", id: name, status: tools.StatusOK,
-			changedFiles: []string{name + ".go"},
-		})
-	}
-	overLines, overHits := over.sidebarFileLines(34)
-	if len(overHits) != maxSidebarFiles {
-		t.Fatalf("expected %d clickable rows, got %d", maxSidebarFiles, len(overHits))
-	}
-	if got := plainRender(t, overLines[len(overLines)-1]); !strings.Contains(got, "+2 more") {
-		t.Errorf("expected '+2 more' trailer, got %q", got)
-	}
-}
-
-// TestSidebarFilesLivePulseRow: while a mutating tool call streams its args,
-// the file it is writing shows as a pinned (unclickable) pulse row.
-func TestSidebarFilesLivePulseRow(t *testing.T) {
-	m := filesPanelTestModel()
-	m.streamCallName = "write_file"
-	m.streamCallDecoder = newStreamingDecoder()
-	m.streamCallDecoder.feed(`{"path":"web/new.css","content":"body{}`)
-
-	lines, hits := m.sidebarFileLines(34)
-	if got := plainRender(t, lines[0]); !strings.Contains(got, "web/new.css") {
-		t.Fatalf("live write should pin its path atop FILES, got %q", got)
-	}
-	for _, hit := range hits {
-		if hit.path == "web/new.css" {
-			t.Error("the live row must not be clickable (no result exists yet)")
-		}
-	}
-	// A non-mutating streaming call shows no pulse row.
-	m.streamCallName = "read_file"
-	if m.liveEditingPath() != "" {
-		t.Error("read_file must not read as a live edit")
-	}
-}
-
-// TestSidebarFileSelectablesMatchRenderedRows: the hit offsets computed by
-// sidebarFileSelectables must land exactly on the rendered FILES rows in
-// renderContextSidebar's output — the same invariant the mouse hit-test relies
-// on. Asserted against the real render, not a re-derivation of the math.
-func TestSidebarFileSelectablesMatchRenderedRows(t *testing.T) {
-	m := filesPanelTestModel()
-	width := sidebarWidth(m.width)
-	rendered := m.renderContextSidebar(width, m.height)
-	hits := m.sidebarFileSelectables(width)
-	if len(hits) == 0 {
-		t.Fatal("expected clickable FILES rows")
-	}
-	for _, hit := range hits {
-		if hit.lineOffset >= len(rendered) {
-			t.Fatalf("hit offset %d beyond rendered sidebar (%d lines)", hit.lineOffset, len(rendered))
-		}
-		line := plainRender(t, rendered[hit.lineOffset])
-		base := hit.path[strings.LastIndex(hit.path, "/")+1:]
-		if !strings.Contains(line, base) {
-			t.Errorf("hit for %q points at line %d which reads %q", hit.path, hit.lineOffset, line)
-		}
-	}
-}
-
-// TestFileRowClickSelectsThenOpens: the first sidebar click on a file selects
-// it (tint + scroll state, no view swap); the second click on the same file
-// opens the drill-in; clicking another file while the view is open switches it.
-func TestFileRowClickSelectsThenOpens(t *testing.T) {
-	m := filesPanelTestModel()
-	width := sidebarWidth(m.width)
-	hits := m.sidebarFileSelectables(width)
-	if len(hits) < 2 {
-		t.Fatal("expected two clickable FILES rows")
-	}
-	x := m.chatColumnWidth() + 3
-	click := func(hit fileHit) tea.MouseMsg { return testMouseClick(tea.MouseLeft, x, hit.lineOffset) }
-
-	m1, _, handled := m.handleTranscriptSelectionMouse(click(hits[0]))
-	if !handled {
-		t.Fatal("FILES row click should be handled")
-	}
-	if m1.selectedFile != hits[0].path || m1.fileView.active {
-		t.Fatalf("first click should select (not open): selected=%q active=%v", m1.selectedFile, m1.fileView.active)
-	}
-
-	m2, _, _ := m1.handleTranscriptSelectionMouse(click(hits[0]))
-	if !m2.fileView.active || m2.fileView.path != hits[0].path {
-		t.Fatalf("second click should open the file view: %+v", m2.fileView)
-	}
-
-	m3, _, _ := m2.handleTranscriptSelectionMouse(click(hits[1]))
-	if !m3.fileView.active || m3.fileView.path != hits[1].path {
-		t.Fatalf("clicking another file with the view open should switch it: %+v", m3.fileView)
-	}
-	if m3.selectedFile != hits[1].path {
-		t.Errorf("switching the view should move the selection too, got %q", m3.selectedFile)
-	}
-}
-
-// TestRowTouchesSelectedFileTint: only tool-result rows whose changedFiles
-// carry the selected path tint, and the render cache key differs across
-// selection states so the tint can't be served stale.
-func TestRowTouchesSelectedFileTint(t *testing.T) {
-	m := filesPanelTestModel()
-	row := m.transcript[len(m.transcript)-1]
-	if m.rowTouchesSelectedFile(row) {
-		t.Fatal("nothing selected: no row should tint")
-	}
-	m.selectedFile = "internal/tui/sidebar.go"
-	if !m.rowTouchesSelectedFile(row) {
-		t.Fatal("selected file's edit row should tint")
-	}
-	other := m.transcript[len(m.transcript)-3] // web/app.js
-	if m.rowTouchesSelectedFile(other) {
-		t.Fatal("an unrelated file's row must not tint")
-	}
-
-	rc := buildRowContext(m.transcript)
-	opts := cardRenderOptions{bodyCap: cardBodyMaxLines, cwd: m.cwd}
-	selectedKey, _ := m.renderRowCacheKey(row, 80, rc, opts, false)
-	m.selectedFile = ""
-	plainKey, _ := m.renderRowCacheKey(row, 80, rc, opts, false)
-	if selectedKey == plainKey {
-		t.Error("render cache key must change with the selection state")
-	}
-}
-
-// TestEscClearsFileSelectionThenNothing: Esc drops an active file selection
-// (before any run-level action) and is consumed doing so.
-func TestEscClearsFileSelectionThenNothing(t *testing.T) {
-	m := filesPanelTestModel()
-	m.selectedFile = "web/app.js"
-	updated, _ := m.Update(tea.KeyPressMsg{Code: tea.KeyEsc})
-	if got := updated.(model).selectedFile; got != "" {
-		t.Fatalf("Esc should clear the file selection, still %q", got)
-	}
-}
-
-func TestTruncatePathLeft(t *testing.T) {
-	if got := truncatePathLeft("internal/tui/sidebar.go", 40); got != "internal/tui/sidebar.go" {
-		t.Errorf("short path should pass through, got %q", got)
-	}
-	if got := truncatePathLeft("internal/tui/sidebar.go", 18); got != "…/tui/sidebar.go" {
-		t.Errorf("want …/tui/sidebar.go, got %q", got)
-	}
-	if got := truncatePathLeft("internal/tui/sidebar.go", 14); got != "…/sidebar.go" {
-		t.Errorf("want …/sidebar.go, got %q", got)
-	}
-}
-
-// TestTouchedFilesPerFileDiffStat: a multi-file result (apply_patch spanning
-// several files) must charge each file its OWN +/- counts from the per-file
-// diff sections — not the whole patch's totals to every file it touched.
-func TestTouchedFilesPerFileDiffStat(t *testing.T) {
-	m := sidebarTestModel()
-	patch := "diff --git a/web/one.js b/web/one.js\n" +
-		"--- a/web/one.js\n+++ b/web/one.js\n@@ -1,1 +1,2 @@\n+added one\n+added two\n" +
-		"diff --git a/web/two.js b/web/two.js\n" +
-		"--- a/web/two.js\n+++ b/web/two.js\n@@ -1,2 +1,1 @@\n-gone one\n-gone two\n-gone three\n"
-	m.transcript = append(m.transcript, transcriptRow{
-		kind: rowToolResult, tool: "apply_patch", id: "p1", status: tools.StatusOK,
-		detail:       patch,
-		changedFiles: []string{"web/one.js", "web/two.js"},
-	})
-	byPath := map[string]touchedFile{}
-	for _, f := range m.touchedFiles() {
-		byPath[f.path] = f
-	}
-	if f := byPath["web/one.js"]; f.adds != 2 || f.dels != 0 {
-		t.Errorf("web/one.js = +%d −%d, want its own +2 −0 (not the patch totals)", f.adds, f.dels)
-	}
-	if f := byPath["web/two.js"]; f.adds != 0 || f.dels != 3 {
-		t.Errorf("web/two.js = +%d −%d, want its own +0 −3 (not the patch totals)", f.adds, f.dels)
-	}
-}
-
-// TestTouchedFilesRetouchOrdersByLastTouch: touch a, then b, then a again — a
-// must list first. The old "reverse first-seen order" put b first because a's
-// slot kept its original position.
-func TestTouchedFilesRetouchOrdersByLastTouch(t *testing.T) {
-	m := sidebarTestModel()
-	for _, step := range []struct{ id, path string }{
-		{"r1", "a.go"}, {"r2", "b.go"}, {"r3", "a.go"},
-	} {
-		m.transcript = append(m.transcript, transcriptRow{
-			kind: rowToolResult, tool: "edit_file", id: step.id, status: tools.StatusOK,
-			changedFiles: []string{step.path},
-		})
-	}
-	files := m.touchedFiles()
-	if len(files) != 2 || files[0].path != "a.go" {
-		t.Fatalf("the re-touched file must list first, got %+v", files)
-	}
-}
-
-// TestSidebarFileLinesOverflowExcludesLiveRow: when the live-writing file is
-// also a touched file, it renders as the pulse row and is skipped from the
-// list — the "+N more" trailer must not count that skipped entry.
-func TestSidebarFileLinesOverflowExcludesLiveRow(t *testing.T) {
-	m := sidebarTestModel()
-	for _, name := range []string{"a", "b", "c", "d", "e", "f", "g", "h"} {
-		m.transcript = append(m.transcript, transcriptRow{
-			kind: rowToolResult, tool: "edit_file", id: name, status: tools.StatusOK,
-			changedFiles: []string{name + ".go"},
-		})
-	}
-	// h.go (a touched file) is ALSO the live write: 7 listable files remain,
-	// 6 render, so the trailer is +1 — not +2 (which counted the skipped live row).
-	m.streamCallName = "edit_file"
-	m.streamCallDecoder = newStreamingDecoder()
-	m.streamCallDecoder.feed(`{"path":"h.go","content":"x`)
-
-	lines, _ := m.sidebarFileLines(34)
-	trailer := plainRender(t, lines[len(lines)-1])
-	if !strings.Contains(trailer, "+1 more") {
-		t.Fatalf("overflow must exclude the live row from the count, got %q", trailer)
-	}
-}
-
-// TestSidebarHasContentForLiveWrite: the sidebar counts an in-flight first
-// write as content, so the FILES pulse is visible before any result row lands.
-func TestSidebarHasContentForLiveWrite(t *testing.T) {
-	m := sidebarTestModel()
-	m.plan.steps = nil // drop the helper's seeded plan: no agents/plan/files now
-	if m.sidebarHasContent() {
-		t.Fatal("session without agents/plan/files should have no sidebar content")
-	}
-	m.streamCallName = "write_file"
-	m.streamCallDecoder = newStreamingDecoder()
-	m.streamCallDecoder.feed(`{"path":"web/new.css","content":"body{}`)
-	if !m.sidebarHasContent() {
-		t.Fatal("a live in-flight write must count as sidebar content")
-	}
-}

internal/tui/hover.go

@@ -15,9 +15,6 @@ const (
 	// hoverPlanStep: a plan step row in the sidebar's PLAN section, identified by
 	// step index.
 	hoverPlanStep
-	// hoverFileRow: a touched-file row in the sidebar's FILES section, identified
-	// by path.
-	hoverFileRow
 )
 
 // hoverTarget identifies the single clickable row (if any) currently under the
@@ -37,7 +34,6 @@ type hoverTarget struct {
 	bodyY     int    // hoverTranscript
 	sessionID string // hoverSidebarAgent
 	stepIndex int    // hoverPlanStep
-	filePath  string // hoverFileRow
 }
 
 // mouseHover reports whether msg is a plain cursor-movement event with NO button
@@ -63,9 +59,6 @@ func (m model) updateHoverTarget(msg tea.MouseMsg) model {
 	if stepIndex, ok := m.planStepAtMouse(msg); ok {
 		return m.withHover(hoverTarget{kind: hoverPlanStep, stepIndex: stepIndex})
 	}
-	if path, ok := m.fileRowAtMouse(msg); ok {
-		return m.withHover(hoverTarget{kind: hoverFileRow, filePath: path})
-	}
 	if line, ok := m.transcriptLineAtMouse(msg); ok {
 		// A permission option reuses its OWN existing keyboard-cursor highlight
 		// (see hoverPermissionOption) rather than the m.hover mechanism, so there's

internal/tui/model.go

@@ -211,22 +211,6 @@ type model struct {
 	// sidebar; when set, the chat reflows to full width. Distinct from the
 	// availability conditions in sidebarAvailable (geometry / mode / overlays).
 	sidebarHidden bool
-	// selectedFile is the touched file selected by clicking its FILES sidebar
-	// row: its edit cards tint in the chat (rowTouchesSelectedFile) and a second
-	// click opens the drill-in file view. "" when nothing is selected; Esc clears.
-	selectedFile string
-	// fileView is the drill-in view for a touched file (file_view.go): while
-	// active the chat column's body shows the file's diff/content instead of the
-	// transcript, mirroring the subchat drill-in.
-	fileView fileViewState
-	// Git-sweep state (files_git_sweep.go): the startup snapshot of already-dirty
-	// paths (nil until Init's sweep answers), the newly dirty files discovered by
-	// live sweeps (bash/subagent mutations that carry no changedFiles), the
-	// single-flight guard, and the "not a git repo / no git" latch.
-	gitFileBaseline     map[string]bool
-	gitTouched          []gitSweepFile
-	gitSweepInFlight    bool
-	gitSweepUnavailable bool
 	// swarmDoneAt records when each swarm member was first seen finished (done/
 	// failed) in a swarm_status report, so the sidebar can linger it briefly with a
 	// fading ✓ before dropping it (a smooth exit, not an abrupt pop). Stamped in the
@@ -635,7 +619,7 @@ func newModel(ctx context.Context, options Options) model {
 		}
 	}
 
-	userConfigDir, _ := config.UserConfigDir()
+	userConfigDir, _ := os.UserConfigDir()
 	loadedUserCommands := usercommands.Load(usercommands.DefaultPaths(cwd, userConfigDir))
 
 	registry := options.Registry
@@ -819,12 +803,6 @@ func (m model) Init() tea.Cmd {
 	// terminal's unprompted push — mirrors the RequestBackgroundColor request
 	// below for the same reason.
 	cmds = append(cmds, tea.RequestWindowSize)
-	// Baseline git snapshot for the FILES sidebar sweep: whatever is already
-	// dirty when the TUI opens is pre-existing state, not this session's work
-	// (files_git_sweep.go). Async; a non-git workspace just disables the sweep.
-	if strings.TrimSpace(m.cwd) != "" {
-		cmds = append(cmds, gitSweepCmd(m.ctx, m.cwd, true))
-	}
 	// In auto mode, ask the terminal for its background color; the reply arrives
 	// as tea.BackgroundColorMsg and selects light vs dark (see updateModel).
 	if m.themeMode == themeAuto {
@@ -1080,14 +1058,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m.handleCtrlC()
 		case keyCtrl(msg, 'o'):
 			return m.toggleDetailedTranscript(), nil
-		case m.fileView.active && m.noBlockingModal() && m.composerValue() == "" && (keyText(msg) == "d" || keyText(msg) == "f"):
-			// Mode toggle for the file drill-in, only while the composer is empty
-			// (so mid-sentence typing is never hijacked) and no modal is up (so a
-			// permission prompt / ask-user / wizard keeps its own key handling).
-			if keyText(msg) == "f" {
-				return m.setFileViewMode(fileViewFull), nil
-			}
-			return m.setFileViewMode(fileViewDiff), nil
 		case keyCtrl(msg, 'e'):
 			// Release/recapture the mouse so the user can drag-select and copy text
 			// natively (mouse capture otherwise intercepts terminal selection).
@@ -1112,14 +1082,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 				m = m.clearHover() // bodyY numbering differs between subchat and the parent transcript
 				return m, nil
 			}
-			// File drill-in exits on Esc (returns to the chat at its saved scroll
-			// position); the file stays selected so a second Esc clears that. Only
-			// with no blocking modal up: Esc on a permission prompt / ask-user /
-			// wizard must reach THAT surface's deny/cancel handling below, not
-			// silently close the drill-in behind it.
-			if m.fileView.active && m.noBlockingModal() {
-				return m.exitFileView(), nil
-			}
 			if m.mcpCommandCancel != nil {
 				m.cancelMCPCommand()
 				if m.mcpAddWizard != nil {
@@ -1176,13 +1138,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.suggestionsActive() {
 				return m.dismissSuggestions(), nil
 			}
-			// A selected FILES row clears before anything run-related: the
-			// selection is a passive highlight, so Esc dropping it is cheap and
-			// expected (mirrors how editors clear selection on Esc).
-			if m.selectedFile != "" {
-				m.selectedFile = ""
-				return m, nil
-			}
 			if m.hasQueuedMessage() {
 				return m.clearQueuedMessage(), nil
 			}
@@ -1857,13 +1812,8 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 			m, recapCmd = m.maybeRecapTurn(msg.runID, finalAnswer)
 		}
-		// End-of-turn git sweep: catch file mutations the tool stream couldn't
-		// report (bash scaffolding, subagent edits) so the FILES sidebar is
-		// complete once the turn settles.
-		var sweepCmd tea.Cmd
-		m, sweepCmd = m.maybeGitSweep()
 		next, queuedCmd := m.launchQueuedMessageIfReady()
-		return next, tea.Batch(titleCmd, recapCmd, sweepCmd, queuedCmd)
+		return next, tea.Batch(titleCmd, recapCmd, queuedCmd)
 	case sessionTitleGeneratedMsg:
 		return m.handleSessionTitleGenerated(msg)
 	case recapGeneratedMsg:
@@ -2014,14 +1964,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.transcript = collapseRepeatedStatusCard(m.transcript, msg.row)
 		m.transcript = appendTranscriptRow(m.transcript, msg.row)
 		m = m.captureStepWork(msg.row)
-		// A finished command tool may have mutated files git can see but no
-		// changedFiles reports (npm create, heredoc writes, subagent edits) —
-		// re-sweep so the FILES sidebar picks them up mid-turn.
-		if msg.row.kind == rowToolResult && isPlanCommandTool(msg.row.tool) {
-			var sweep tea.Cmd
-			m, sweep = m.maybeGitSweep()
-			return m, sweep
-		}
 		return m, nil
 	case swarmSessionsMsg:
 		// Merge completed swarm members' session ids so their AGENTS sidebar rows
@@ -2052,8 +1994,6 @@ func (m model) updateModel(msg tea.Msg) (tea.Model, tea.Cmd) {
 	case prStateMsg:
 		m.prState = msg.state
 		return m, nil
-	case gitSweepMsg:
-		return m.handleGitSweepMsg(msg), nil
 	case prWatcherStartedMsg:
 		if msg.stop == nil {
 			return m, nil
@@ -2258,12 +2198,6 @@ func (m model) pinnedTitleBar(width int) string {
 	if !m.altScreen || m.height <= 0 {
 		return ""
 	}
-	// The file drill-in replaces the title bar with its nav line (path + key
-	// hints). Both are exactly one line, and every frame computation routes
-	// through here, so the swap never desyncs the viewport geometry.
-	if m.fileView.active {
-		return m.fileViewNavBar(width)
-	}
 	return m.titleBar(width)
 }
 
@@ -4364,14 +4298,13 @@ func (m model) runAgentWithOptions(runID int, runCtx context.Context, prompt str
 				}
 			}
 			row := transcriptRow{
-				kind:         rowToolResult,
-				id:           effectiveToolRowID(result.ToolCallID, callSeq[result.ToolCallID]),
-				text:         toolResultRowText(result),
-				tool:         result.Name,
-				status:       result.Status,
-				detail:       toolResultDetail(result),
-				runID:        runID,
-				changedFiles: result.ChangedFiles,
+				kind:   rowToolResult,
+				id:     effectiveToolRowID(result.ToolCallID, callSeq[result.ToolCallID]),
+				text:   toolResultRowText(result),
+				tool:   result.Name,
+				status: result.Status,
+				detail: toolResultDetail(result),
+				runID:  runID,
 			}
 			// A Task result is shown by the specialist card, and update_plan by the
 			// plan panel/sidebar, so skip both redundant transcript rows.

internal/tui/render_cache.go

@@ -164,9 +164,6 @@ func (m model) renderRowCacheKey(row transcriptRow, width int, rc rowContext, op
 	appendRenderCacheField(&b, strconv.FormatBool(row.final))
 	appendRenderCacheField(&b, strconv.Itoa(row.turnTools))
 	appendRenderCacheField(&b, strconv.FormatInt(int64(row.turnElapsed), 10))
-	// The FILES selection tints this row's card border, so selecting/deselecting
-	// a file must miss the cache entry rendered under the other state.
-	appendRenderCacheField(&b, strconv.FormatBool(m.rowTouchesSelectedFile(row)))
 
 	key := rcKey(row.runID, row.id)
 	appendRenderCacheField(&b, rc.hints[key])

internal/tui/rendering.go

@@ -167,10 +167,6 @@ type cardRenderOptions struct {
 	bodyCap  int
 	cwd      string
 	expanded bool
-	// fileSelected marks a tool-result card whose mutation touched the file
-	// selected in the FILES sidebar; the card border tints accent so the
-	// selection reads in the transcript.
-	fileSelected bool
 }
 
 // flushCardBodyMaxLines is the body cap for cards flushed to scrollback. The
@@ -214,10 +210,6 @@ func (m model) renderRowMode(row transcriptRow, width int, rc rowContext, flush
 }
 
 func (m model) renderRowModeUncached(row transcriptRow, width int, rc rowContext, opts cardRenderOptions) string {
-	// Resolved per-row (not at the opts construction sites) so every render
-	// path — live, flush, detailed — carries the FILES selection tint; the
-	// cache key includes the same predicate (renderRowCacheKey).
-	opts.fileSelected = m.rowTouchesSelectedFile(row)
 	switch row.kind {
 	case rowUser:
 		return renderUserRow(row, width)
@@ -1398,11 +1390,6 @@ func renderToolResultCard(row transcriptRow, width int, rc rowContext, opts card
 	glyph := zeroTheme.green.Render("•")
 	nameStyle := zeroTheme.green
 	borderStyle := zeroTheme.line
-	if opts.fileSelected {
-		// The selected FILES row's edit card: accent border, same as the
-		// sidebar's ▸ marker, so click → highlight reads as one gesture.
-		borderStyle = zeroTheme.accent
-	}
 	if failed {
 		glyph = zeroTheme.red.Render("•")
 		nameStyle = zeroTheme.red

internal/tui/session.go

@@ -444,13 +444,12 @@ func transcriptRowsFromSessionEvents(events []sessions.Event) []transcriptRow {
 			}
 			output := payloadString(payload, "output")
 			rows = append(rows, transcriptRow{
-				kind:         rowToolResult,
-				id:           effectiveToolRowID(id, callSeq[id]),
-				text:         fmt.Sprintf("tool result: %s %s %s", name, status, truncateTUIOutput(output, tuiToolOutputLimit)),
-				tool:         name,
-				status:       status,
-				detail:       output,
-				changedFiles: payloadStringSlice(payload, "changedFiles"),
+				kind:   rowToolResult,
+				id:     effectiveToolRowID(id, callSeq[id]),
+				text:   fmt.Sprintf("tool result: %s %s %s", name, status, truncateTUIOutput(output, tuiToolOutputLimit)),
+				tool:   name,
+				status: status,
+				detail: output,
 			})
 		case sessions.EventError:
 			if message := payloadString(payload, "message"); message != "" {
@@ -620,28 +619,6 @@ func payloadString(payload map[string]any, key string) string {
 	}
 }
 
-// payloadStringSlice reads a []string persisted into a session payload (JSON
-// round-trips it as []any), skipping non-string entries. Nil when absent.
-func payloadStringSlice(payload map[string]any, key string) []string {
-	switch typed := payload[key].(type) {
-	case []string:
-		return typed
-	case []any:
-		out := make([]string, 0, len(typed))
-		for _, v := range typed {
-			if s, ok := v.(string); ok && s != "" {
-				out = append(out, s)
-			}
-		}
-		if len(out) == 0 {
-			return nil
-		}
-		return out
-	default:
-		return nil
-	}
-}
-
 func payloadBool(payload map[string]any, key string) bool {
 	value := payload[key]
 	switch typed := value.(type) {

internal/tui/sidebar.go

@@ -97,11 +97,6 @@ func (m model) sidebarHasContent() bool {
 	if len(m.sidebarSpecialists()) > 0 || len(m.swarmSpawnedAgents()) > 0 {
 		return true
 	}
-	if len(m.touchedFiles()) > 0 || m.liveEditingPath() != "" {
-		// A live in-flight write counts before its result row exists, so the
-		// FILES pulse for the session's first mutation isn't hidden.
-		return true
-	}
 	return !m.plan.isEmpty()
 }
 
@@ -592,19 +587,6 @@ func (m model) renderContextSidebar(width, height int) []string {
 		lines = append(lines, planLines...)
 	}
 
-	// FILES section: the files this session has touched (files_panel.go).
-	// Rendered BELOW the plan steps so it never shifts sidebarPlanSelectables'
-	// click offsets; its own hits (sidebarFileSelectables) account for the
-	// sections above it.
-	add("")
-	add(m.sidebarFilesHeader(width))
-	fileLines, _ := m.sidebarFileLines(width)
-	if len(fileLines) == 0 {
-		add(sidebarPlaceholder("no files touched", width))
-	} else {
-		lines = append(lines, fileLines...)
-	}
-
 	// ACTIVITY section: recent completed work + a live "generating…" pulse. Shown
 	// BELOW the plan steps so it never shifts sidebarPlanSelectables' click offsets,
 	// and budgeted (height-1 minus what's used) so it clips ITSELF from the bottom
@@ -669,12 +651,6 @@ func (m model) hoveredSidebarLineOffset(width int) (int, bool) {
 				return hit.lineOffset, true
 			}
 		}
-	case hoverFileRow:
-		for _, hit := range m.sidebarFileSelectables(width) {
-			if hit.path == m.hover.filePath {
-				return hit.lineOffset, true
-			}
-		}
 	}
 	return 0, false
 }

internal/tui/transcript.go

@@ -41,11 +41,6 @@ type transcriptRow struct {
 	askUser    *agent.AskUserRequest
 	expanded   bool // collapsible transcript rows, e.g. provider thoughts
 
-	// changedFiles lists the workspace-relative paths a mutating tool result
-	// wrote (from tools.Result.ChangedFiles; restored from the session payload on
-	// resume). The sidebar FILES section derives its roster from these.
-	changedFiles []string
-
 	// specialistInfo holds the specialist card data for rowSpecialist rows.
 	// Nil for all other row kinds.
 	specialistInfo *specialistInfo

internal/tui/transcript_selection.go

@@ -211,12 +211,6 @@ func (m model) renderHoverHighlight(rendered string, selectable []transcriptSele
 }
 
 func (m model) transcriptBodyItems(width int, emptyOverlay string) []transcriptBodyItem {
-	// File drill-in: the chat column's body swaps to the viewed file's
-	// diff/content. Swapping HERE (the single source every consumer reads) keeps
-	// the viewport, scroll engine, renderer, and mouse hit-tests consistent.
-	if m.fileView.active {
-		return m.fileViewBodyItems(width)
-	}
 	items := []transcriptBodyItem{}
 	// Transcript ROWS render at the full chat width; row/status glyphs provide
 	// structure without adding another body margin. Block items (title bar, empty
@@ -1248,9 +1242,6 @@ func (m model) handleTranscriptSelectionMouse(msg tea.MouseMsg) (model, tea.Cmd,
 		// session, reusing the specialist-card subchat path. Checked before the
 		// transcript hit-test since the sidebar is outside the chat column.
 		if hit, ok := m.sidebarLineAtMouse(msg); ok {
-			// The subchat drill-in owns the whole (single-column) view; a file
-			// drill-in can't meaningfully stay open behind it.
-			m = m.exitFileView()
 			if errMsg := m.subchat.enter(m.sessionStore, hit.sessionID, hit.title, m.chatScrollOffset); errMsg != "" {
 				m = m.appendSystemNotice(errMsg)
 			}
@@ -1261,24 +1252,10 @@ func (m model) handleTranscriptSelectionMouse(msg tea.MouseMsg) (model, tea.Cmd,
 		// A click on a PLAN step row drops a transcript card listing the file
 		// changes captured while that step was in progress.
 		if stepIndex, ok := m.planStepAtMouse(msg); ok {
-			// The card lands in the chat transcript; close the file drill-in so
-			// it isn't appended invisibly behind the swapped body.
-			m = m.exitFileView()
 			var cmd tea.Cmd
 			m, cmd = m.openPlanStepDetail(stepIndex)
 			return m, cmd, true
 		}
-		// A click on a FILES row: first click selects the file (its edit cards
-		// tint and the chat scrolls to the most recent one); a click on the
-		// already-selected file — or any FILES click while the drill-in is open —
-		// opens/switches the file view.
-		if path, ok := m.fileRowAtMouse(msg); ok {
-			if m.fileView.active || m.selectedFile == path {
-				m.selectedFile = path
-				return m.openFileView(path), nil, true
-			}
-			return m.selectFile(path), nil, true
-		}
 		line, ok := m.transcriptLineAtMouse(msg)
 		if !ok {
 			if m.transcriptSelection.active {

release-please-config.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json",
-  "release-type": "node",
-  "include-component-in-tag": false,
-  "bootstrap-sha": "02f0c0929bec65f5fc41bdcab3eb518d2b0b329a",
-  "packages": {
-    ".": {
-      "package-name": "@gitlawb/zero"
-    }
-  }
-}