test(cli): fail when the prewarm hold gives up

The bounded wait let the turn proceed after its guard expired, so a probe that arrived late still left the count at 1 and the test passed. That proves the probe was eventually received, not that it preceded the turn, which is the only thing this test claims. Raised by CodeRabbit. The expiry is now recorded and checked before the count, since the count cannot tell the two apart. Verified by suppressing the probe, which makes the guard expire: the assertion fires with its own message rather than the count assertion, and the run takes the full guard duration.
test(cli): order the prewarm probe against the turn
2026-11-08 09:49:34 -10:00 · 2026-07-27 09:05:15 +05:30 · 2026-07-27 01:31:52 +05:30
181 changed files with 1046 additions and 11498 deletions
@@ -1,3 +0,0 @@
-*.go text eol=lf
-*.mod text eol=lf
-*.sum text eol=lf
@@ -30,36 +30,6 @@ jobs:
          go-version-file: go.mod
          cache: true

-      - name: Install Make on Windows
-        if: matrix.os == 'windows-latest'
-        shell: pwsh
-        run: choco install make --no-progress -y
-
-      - name: Validate quality targets with stock macOS Make
-        if: matrix.os == 'macos-latest'
-        env:
-          GIT_CONFIG_COUNT: 1
-          GIT_CONFIG_KEY_0: grep.patternType
-          GIT_CONFIG_VALUE_0: fixed
-        run: make -n vulncheck
-
-      - name: Check vulnerabilities through native Windows Make
-        if: matrix.os == 'windows-latest'
-        shell: cmd
-        run: make vulncheck
-
-      - name: Check dead code through native Windows Make
-        if: matrix.os == 'windows-latest'
-        continue-on-error: true
-        shell: cmd
-        run: make deadcode
-
-      - name: Run static lint through native Windows Make
-        if: matrix.os == 'windows-latest'
-        continue-on-error: true
-        shell: cmd
-        run: make lint-static
-
      - name: Check formatting
        if: matrix.os == 'ubuntu-latest'
        shell: bash
@@ -130,18 +100,27 @@ jobs:
          go-version-file: go.mod
          cache: true

+      # govulncheck, deadcode, and golangci-lint each resolve a toolchain from
+      # their own modules, which can drop below the version go.mod requires and
+      # then fail to load our packages. Pin GOTOOLCHAIN to the go.mod toolchain
+      # so all three run under it.
+      - name: Pin toolchain from go.mod
+        run: |
+          toolchain="$(awk '/^toolchain /{print $2}' go.mod)"
+          echo "GOTOOLCHAIN=${toolchain:-auto}" >> "$GITHUB_ENV"
+
      # Hard gate: fails the build when code reaches a known vulnerability. A stdlib
      # CVE is cleared by a toolchain bump (see go.mod). May also flag a newly
      # published advisory on an unrelated PR — intentional: do not ship known vulns.
      - name: govulncheck
-        run: make vulncheck
+        run: go run golang.org/x/vuln/cmd/[email protected] ./...

      # Advisory: reports functions unreachable from any cmd/* main so dormant
      # code is visible in CI. Non-blocking while the dormant subsystems are
      # still being wired or removed.
      - name: deadcode (advisory)
        continue-on-error: true
-        run: make deadcode
+        run: go run golang.org/x/tools/cmd/[email protected] -test=false ./...

      # Advisory: catches what deadcode's whole-program reachability analysis
      # doesn't, unused private functions/assignments reachable within a
@@ -151,4 +130,4 @@ jobs:
      # the repo are cleaned up incrementally (see #527).
      - name: golangci-lint (advisory)
        continue-on-error: true
-        run: make lint-static
+        run: go run github.com/golangci/golangci-lint/v2/cmd/[email protected] run --enable-only unused,ineffassign,staticcheck ./...
@@ -1 +1 @@
-{".":"0.6.0"}
+{".":"0.5.0"}
@@ -51,8 +51,10 @@ request, or completing an implementation task:
   or run focused tests with `-race`, when concurrency is affected.
 4. **Build**: `go run ./cmd/zero-release build`.
 5. **Smoke test**: `go run ./cmd/zero-release smoke`.
-6. **Advisory lint**: `make lint-static`.
-7. **Security**: `make vulncheck`.
+6. **Advisory lint**:
+   `go run github.com/golangci/golangci-lint/v2/cmd/[email protected] run --enable-only unused,ineffassign,staticcheck ./...`.
+7. **Security**:
+   `go run golang.org/x/vuln/cmd/[email protected] ./...`.
 8. **Diff hygiene**: `git diff HEAD --check` (covers staged and unstaged
   tracked changes).

@@ -6,37 +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.6.0](https://github.com/Gitlawb/zero/compare/v0.5.0...v0.6.0) (2026-07-29)
-
-
-### Features
-
-* add persistent session goals ([#803](https://github.com/Gitlawb/zero/issues/803)) ([5d1869e](https://github.com/Gitlawb/zero/commit/5d1869e7bc193c97e07418b57b823905c1151d5d))
-* **providers:** add Fireworks AI provider preset ([#772](https://github.com/Gitlawb/zero/issues/772)) ([58daea7](https://github.com/Gitlawb/zero/commit/58daea7a482927e5ab35afaf97761c60bb35e113))
-* **skills:** report hash drift in skill info ([#795](https://github.com/Gitlawb/zero/issues/795)) ([9fbdc34](https://github.com/Gitlawb/zero/commit/9fbdc341551601c13434cf7b9b6f5e4ea4c483b1))
-
-
-### Bug Fixes
-
-* **acp:** interrupt idle reads on cancellation ([#782](https://github.com/Gitlawb/zero/issues/782)) ([15b7a54](https://github.com/Gitlawb/zero/commit/15b7a5475cfeefddbc59634551451a8872b996b7))
-* **cli:** include plugins info in shell completions ([#794](https://github.com/Gitlawb/zero/issues/794)) ([fa8734f](https://github.com/Gitlawb/zero/commit/fa8734f17927de8832dfe041e043cfb86f93d12a))
-* **config:** kill provider-command process tree via job object on Windows ([#690](https://github.com/Gitlawb/zero/issues/690)) ([5c58256](https://github.com/Gitlawb/zero/commit/5c58256abc29c185b449f8ce79647eb3fae61882))
-* **config:** make the provider-command timeout an upper bound ([#811](https://github.com/Gitlawb/zero/issues/811)) ([#813](https://github.com/Gitlawb/zero/issues/813)) ([1c38e8c](https://github.com/Gitlawb/zero/commit/1c38e8cba50db255f3cda8b7cf4298712b2933e1))
-* **config:** stop billing provider-command fixtures to the 5s timeout ([#810](https://github.com/Gitlawb/zero/issues/810)) ([f5fa4ff](https://github.com/Gitlawb/zero/commit/f5fa4ffc64537897aa78a56edca36d8f1dacd021))
-* **cron:** reserve job IDs atomically ([#686](https://github.com/Gitlawb/zero/issues/686)) ([d9b882e](https://github.com/Gitlawb/zero/commit/d9b882eb0a94f38de8447cb54b57860ccd8ed053))
-* **lint:** resolve static analysis baseline ([#769](https://github.com/Gitlawb/zero/issues/769)) ([583e653](https://github.com/Gitlawb/zero/commit/583e6530bd849a8efcb2b88bbe8c297e8592e62c))
-* **providers:** retry provably pre-send transport failures ([#447](https://github.com/Gitlawb/zero/issues/447)) ([#750](https://github.com/Gitlawb/zero/issues/750)) ([8acd42a](https://github.com/Gitlawb/zero/commit/8acd42a3bd743a35807d762f23a33fb61c171839))
-* **sandbox:** add platform-specific write lock around grant state file ([#752](https://github.com/Gitlawb/zero/issues/752)) ([#755](https://github.com/Gitlawb/zero/issues/755)) ([88fb7b6](https://github.com/Gitlawb/zero/commit/88fb7b6192c1ac8173089967d5e9119f92d7a101))
-* **sandbox:** clarify scoped permission prompts ([#798](https://github.com/Gitlawb/zero/issues/798)) ([9fe02ae](https://github.com/Gitlawb/zero/commit/9fe02ae52e3234cb9dae76e0c5594a287ccbb52a))
-* **sandbox:** deny reads of git's credential stores ([#815](https://github.com/Gitlawb/zero/issues/815)) ([#816](https://github.com/Gitlawb/zero/issues/816)) ([33c94ec](https://github.com/Gitlawb/zero/commit/33c94ec7a3e7987e6e36b5fd5e037ff4e6e84c26))
-* **sandbox:** preserve user config and retry denied writes ([#801](https://github.com/Gitlawb/zero/issues/801)) ([81a5e6c](https://github.com/Gitlawb/zero/commit/81a5e6cb716ba4b7ecf7ff3ff261dfa51fd01098))
-* **sandbox:** scrub the daemon token file pointer ([#677](https://github.com/Gitlawb/zero/issues/677)) ([#818](https://github.com/Gitlawb/zero/issues/818)) ([3e7692d](https://github.com/Gitlawb/zero/commit/3e7692d8f0885d346809869935c81a9cf055d89e))
-* **swarm:** close lifecycle admission on shutdown ([#776](https://github.com/Gitlawb/zero/issues/776)) ([bdbda89](https://github.com/Gitlawb/zero/commit/bdbda89f3e42d93e8058ab3e1e9ef402659530cd))
-* **tui:** fix rendering corruption over multipass + Windows Terminal ([#709](https://github.com/Gitlawb/zero/issues/709)) ([5bb1bc1](https://github.com/Gitlawb/zero/commit/5bb1bc11c3188dcea7709ff07c8b25dda3541de8))
-* **tui:** paste clipboard images with Ctrl+V ([#534](https://github.com/Gitlawb/zero/issues/534)) ([#807](https://github.com/Gitlawb/zero/issues/807)) ([ec3b822](https://github.com/Gitlawb/zero/commit/ec3b8225050eb62f0f41a9582ed2881d2f9dcc8e))
-* **tui:** reset quiet clock for new runs ([#799](https://github.com/Gitlawb/zero/issues/799)) ([a4a805a](https://github.com/Gitlawb/zero/commit/a4a805a6c82c51cb255e909bd87ca183c8805cf2))
-* **windows:** use PowerShell for command execution ([#804](https://github.com/Gitlawb/zero/issues/804)) ([518d2e5](https://github.com/Gitlawb/zero/commit/518d2e53ba3fa073090a9b41c278face85b59b64))
-
 ## [0.5.0](https://github.com/Gitlawb/zero/compare/v0.4.0...v0.5.0) (2026-07-22)


@@ -1,13 +1,7 @@
-# Zero build/test/lint targets. AGENTS.md says to build and run quality checks
-# with `make` — these targets back those instructions.
+# Zero build/test/lint targets. AGENTS.md says "Build with `make`" and "Run `make
+# lint` before opening a PR" — these targets back those instructions.
 .DEFAULT_GOAL := build
-GO_VERSION = $(word 2,$(shell git grep -G -h "^go[[:space:]]" -- go.mod))
-GO_TOOLCHAIN = go$(GO_VERSION)
-DEADCODE_VERSION := v0.46.0
-GOLANGCI_LINT_VERSION := v2.12.2
-GOVULNCHECK_VERSION := v1.3.0
-
-.PHONY: build build-all test test-race vet fmt fmt-check lint lint-static deadcode vulncheck tidy clean baseline help
+.PHONY: build build-all test test-race vet fmt fmt-check lint tidy clean baseline help

 # Build the main CLI binary into ./zero.
 build:
@@ -39,22 +33,6 @@ fmt-check:
 # Lint = formatting check + vet (no extra tooling required).
 lint: fmt-check vet

-# Versioned tools select the toolchain from their own modules when invoked with
-# package@version. Read this module's go directive directly, without invoking
-# the possibly stale Go toolchain or consulting a multi-module GOWORK. git grep
-# works with both POSIX shells and cmd.exe, including GNU Make 3.81 on macOS.
-# The target-specific export is shell-independent.
-lint-static deadcode vulncheck: export GOTOOLCHAIN = $(GO_TOOLCHAIN)
-
-lint-static:
-	go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION) run --enable-only unused,ineffassign,staticcheck ./...
-
-deadcode:
-	go run golang.org/x/tools/cmd/deadcode@$(DEADCODE_VERSION) -test=false ./...
-
-vulncheck:
-	go run golang.org/x/vuln/cmd/govulncheck@$(GOVULNCHECK_VERSION) ./...
-
 tidy:
 	go mod tidy

@@ -77,4 +55,4 @@ baseline: build
 		--output internal/perfbench/reports/baseline.json

 help:
-	@echo "Targets: build (default), build-all, test, test-quick, vet, fmt, fmt-check, lint, lint-static, deadcode, vulncheck, tidy, clean, baseline"
+	@echo "Targets: build (default), build-all, test, test-quick, vet, fmt, fmt-check, lint, tidy, clean, baseline"
@@ -131,7 +131,6 @@ export ANTHROPIC_API_KEY=...
 export GEMINI_API_KEY=...
 export AIMLAPI_API_KEY=...
 export LONGCAT_API_KEY=...
-export FIREWORKS_API_KEY=...
 export MINIMAX_API_KEY=...
 export MINIMAXI_API_KEY=...
 ```
@@ -148,12 +147,6 @@ To configure Meituan LongCat (LongCat-2.0) directly, run:
 zero providers setup longcat --set-active
 ```

-To configure Fireworks AI directly, run:
-
-```bash
-zero providers setup fireworks --set-active
-```
-
 MiniMax presets use the Anthropic-compatible endpoints for the global and China
 regions:

@@ -374,16 +367,22 @@ variable unset and set.

 ### Code Quality and Security Checks

-Before committing any changes, ensure all Go code quality and security checks pass. The `make` targets below pin each tool to this module's Go version, so they load correctly even when your default `go` toolchain is older — running the plain `go run ...@version` form yourself can select the tool module's own (older) toolchain and fail to load this module instead.
+Before committing any changes, ensure all Go code quality and security checks pass. Pinned `go run` commands matching CI constraints can be used directly without prior installation:

-1. **Formatting**: Run `make fmt` (or `go fmt ./...`).
-2. **Vetting**: Run `make vet` (or `go vet ./...`).
-3. **Linting**: Run `make lint-static`.
-4. **Vulnerability Scan**: Run `make vulncheck`.
+1. **Formatting**: Run `go fmt ./...` (or `make fmt`).
+2. **Vetting**: Run `go vet ./...` (or `make vet`).
+3. **Linting**: Run `go run github.com/golangci/golangci-lint/v2/cmd/[email protected] run --enable-only unused,ineffassign,staticcheck ./...`.
+4. **Vulnerability Scan**: Run `go run golang.org/x/vuln/cmd/[email protected] ./...`.

-Use the repository-managed targets rather than globally installed binaries:
-the targets apply the module's required Go toolchain as well as the reviewed,
-pinned tool versions.
+If you prefer to install these tools globally on your path, you can run:
+
+```bash
+# Install golangci-lint
+go install github.com/golangci/golangci-lint/v2/cmd/[email protected]
+
+# Install govulncheck
+go install golang.org/x/vuln/cmd/[email protected]
+```

 The installed binaries land in `$GOBIN` when it is set, otherwise in
 `$GOPATH/bin` (default `~/go/bin`). That directory must be on your `PATH` to
@@ -108,10 +108,10 @@ Discovery roots (earlier wins on name collisions):
 2. **Shared multi-agent dir** — `~/.agents/skills/` when present (read-only discovery; never an install target)
 3. **Plugin skill roots** — skills bundled by active plugins (section 6)

-A missing directory is fine — Zero just omits it. Management commands (`zero skill add` / `zero skill remove`) always write to the primary Zero dir only; `list` / `info` search primary + `~/.agents/skills`. `skill info` reports lock source/hash when present and whether the on-disk `SKILL.md` has drifted from the recorded hash.
+A missing directory is fine — Zero just omits it. Management commands (`zero skills add` / `remove` / `lock`) always write to the primary Zero dir only; `list` / `info` search primary + `~/.agents/skills`.

 ```text
-~/.local/share/zero/skills/          # primary (install/remove target)
+~/.local/share/zero/skills/          # primary (install/remove/lock target)
  run-benchmarks/
    SKILL.md
  write-changelog/
@@ -17,7 +17,6 @@ import (
 	"fmt"
 	"io"
 	"sync"
-	"sync/atomic"
 )

 // JSON-RPC 2.0 standard error codes.
@@ -81,9 +80,8 @@ type NotifyFunc func(ctx context.Context, params json.RawMessage)
 // requests/notifications — needed because ACP is bidirectional (the agent calls
 // the client for session/request_permission, fs/*, terminal/*).
 type Conn struct {
-	rawReader    io.Reader // wrapped lazily in Serve, once ctx is known — see interruptibleReader
-	readerCloser io.Closer
-	w            io.Writer
+	reader *bufio.Reader
+	w      io.Writer

 	writeMu sync.Mutex // serializes all writes to w

@@ -98,15 +96,10 @@ type Conn struct {
 	wg sync.WaitGroup // tracks in-flight inbound handlers
 }

-// NewConn builds a peer reading ndjson from r and writing ndjson to w. This
-// Conn does not own r: cancelling Serve's context cannot forcibly close it, so
-// a Read on r that's genuinely idle (never returns on its own) leaves Serve
-// blocked until r itself produces something — e.g. a test that closes r's own
-// write side to unblock it. Use NewOwnedConn when this Conn should own r's
-// lifetime.
+// NewConn builds a peer reading ndjson from r and writing ndjson to w.
 func NewConn(r io.Reader, w io.Writer) *Conn {
 	return &Conn{
-		rawReader: r,
+		reader:    bufio.NewReader(r),
 		w:         w,
 		handlers:  make(map[string]HandlerFunc),
 		notifiers: make(map[string]NotifyFunc),
@@ -114,18 +107,6 @@ func NewConn(r io.Reader, w io.Writer) *Conn {
 	}
 }

-// NewOwnedConn is like NewConn but declares that this Conn exclusively owns r:
-// if r implements io.Closer, Serve closes it on context cancellation to
-// interrupt an otherwise-idle blocking Read. Only pass a reader whose lifetime
-// this Conn should control — e.g. the process's own stdin — never a reader a
-// caller retains or shares elsewhere, since cancellation tears it down
-// permanently for every consumer, not just this Conn.
-func NewOwnedConn(r io.Reader, w io.Writer) *Conn {
-	c := NewConn(r, w)
-	c.readerCloser, _ = r.(io.Closer)
-	return c
-}
-
 // Handle registers a request handler for method.
 func (c *Conn) Handle(method string, fn HandlerFunc) { c.handlers[method] = fn }

@@ -147,36 +128,17 @@ func (c *Conn) Serve(ctx context.Context) error {
 		c.wg.Wait()
 	}()

-	interruptible := newInterruptibleReader(ctx, c.rawReader, c.readerCloser)
-	reader := bufio.NewReader(interruptible)
-
 	for {
 		// One ndjson value per line. Framing per line (rather than streaming the
 		// decoder) keeps a single malformed line from making the whole connection
 		// unrecoverable — we report -32700 and continue.
-		//
-		// generation brackets this SPECIFIC ReadBytes call: bufio may invoke
-		// interruptible.Read zero or more times underneath it (zero when the
-		// answer is already sitting in bufio's own buffer — including a
-		// previously-buffered, not-yet-surfaced error: bufio can return a
-		// complete line with a nil error while quietly caching an error it
-		// received ALONGSIDE that line's bytes, which then surfaces on the VERY
-		// NEXT call with no further contact with interruptible.Read at all). The
-		// generation only advances inside interruptible.Read's own cancellation
-		// branch, so "unchanged across this call" is proof this call's outcome
-		// didn't pass through that branch — whether because it was answered from
-		// the buffer or because it raced ctx.Done() and won. Only that proof
-		// makes it safe to call the outcome genuine.
-		before := interruptible.generation()
-		line, err := reader.ReadBytes('\n')
-		interrupted := interruptible.generation() != before
-
+		line, err := c.reader.ReadBytes('\n')
 		if len(bytes.TrimSpace(line)) > 0 {
 			c.handleLine(ctx, line)
 		}
 		if err != nil {
 			c.failAllPending(err)
-			if errors.Is(err, io.EOF) || interrupted {
+			if errors.Is(err, io.EOF) || ctx.Err() != nil {
 				return nil
 			}
 			return err
@@ -184,100 +146,6 @@ func (c *Conn) Serve(ctx context.Context) error {
 	}
 }

-// interruptibleReader wraps a reader so a context cancellation can unblock a
-// currently in-flight Read without ever discarding — or misattributing — the
-// real outcome of a call that wasn't actually blocked.
-//
-// Each Read runs the underlying call on its own goroutine and races it against
-// ctx.Done(). If the underlying call finishes first, its result is returned
-// exactly as received; ctx being cancelled a moment later has no bearing on a
-// call that already had its answer. If ctx.Done() fires first, closer (when
-// non-nil) is closed to nudge a genuinely blocked read, the generation counter
-// is bumped, and the call STILL waits for and returns the underlying call's own
-// result — never a synthesized one — since closing a reader's outcome is
-// whatever the reader itself reports for it, not ours to invent.
-//
-// The counter is what lets Serve tell a call that was actually raced against
-// cancellation apart from one merely answered while cancellation happened to be
-// pending — the distinction the read loop's own doc comment explains.
-type interruptibleReader struct {
-	inner  io.Reader
-	closer io.Closer
-	ctx    context.Context
-
-	closeOnce sync.Once
-	gen       atomic.Int64
-}
-
-func newInterruptibleReader(ctx context.Context, inner io.Reader, closer io.Closer) *interruptibleReader {
-	return &interruptibleReader{inner: inner, closer: closer, ctx: ctx}
-}
-
-func (r *interruptibleReader) generation() int64 { return r.gen.Load() }
-
-type interruptibleReadResult struct {
-	n   int
-	err error
-}
-
-// interruptibleReadDecision arbitrates whether an underlying Read completed or
-// cancellation claimed it first. Completion is recorded before the result is
-// published so cancellation cannot misclassify a finished read merely because
-// its goroutine has not sent the result yet.
-type interruptibleReadDecision struct {
-	once sync.Once
-}
-
-func (d *interruptibleReadDecision) complete() { d.once.Do(func() {}) }
-
-func (d *interruptibleReadDecision) interrupt() (claimed bool) {
-	d.once.Do(func() { claimed = true })
-	return claimed
-}
-
-// readInner records completion in the Read call's deferred epilogue. It also
-// converts a reader panic into a terminal error so the helper goroutine always
-// publishes a result for Read to join.
-func (r *interruptibleReader) readInner(p []byte, decision *interruptibleReadDecision) (res interruptibleReadResult) {
-	defer func() {
-		if recovered := recover(); recovered != nil {
-			res = interruptibleReadResult{err: fmt.Errorf("acp: reader panicked: %v", recovered)}
-		}
-		decision.complete()
-	}()
-	res.n, res.err = r.inner.Read(p)
-	return res
-}
-
-func (r *interruptibleReader) Read(p []byte) (int, error) {
-	resultCh := make(chan interruptibleReadResult, 1)
-	var decision interruptibleReadDecision
-	go func() {
-		resultCh <- r.readInner(p, &decision)
-	}()
-	select {
-	case res := <-resultCh:
-		return res.n, res.err
-	case <-r.ctx.Done():
-		// resultCh may not be readable yet even when inner.Read has returned: its
-		// goroutine can be descheduled between recording completion and publishing
-		// the result. Only interrupt a call that cancellation actually claims.
-		if decision.interrupt() {
-			r.gen.Add(1)
-			if r.closer != nil {
-				r.closeOnce.Do(func() { _ = r.closer.Close() })
-			}
-		}
-		// Wait for the real result rather than returning synthetically: p is
-		// still being written by the goroutine above until it does, so returning
-		// early would race that write, and the actual error (whatever closing
-		// the reader produced, or whatever the reader was already about to
-		// report) is what the caller should see.
-		res := <-resultCh
-		return res.n, res.err
-	}
-}
-
 // handleLine decodes and dispatches one ndjson frame. A parse failure replies
 // with -32700 (id null) and keeps the connection alive.
 func (c *Conn) handleLine(ctx context.Context, line []byte) {
@@ -3,30 +3,11 @@ package acp
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"io"
-	"sync"
-	"sync/atomic"
 	"testing"
 	"time"
 )

-type testReadCloser struct {
-	read  func([]byte) (int, error)
-	close func() error
-}
-
-func (r testReadCloser) Read(p []byte) (int, error) { return r.read(p) }
-func (r testReadCloser) Close() error               { return r.close() }
-
-type testReader func([]byte) (int, error)
-
-func (r testReader) Read(p []byte) (int, error) { return r(p) }
-
-type testWriter func([]byte) (int, error)
-
-func (w testWriter) Write(p []byte) (int, error) { return w(p) }
-
 // connPair wires two Conns together over in-memory pipes and serves both.
 func connPair(t *testing.T) (a, b *Conn, stop func()) {
 	t.Helper()
@@ -44,275 +25,6 @@ func connPair(t *testing.T) (a, b *Conn, stop func()) {
 	}
 }

-func TestConnServeCancellationInterruptsIdleRead(t *testing.T) {
-	pipeReader, writer := io.Pipe()
-	t.Cleanup(func() { _ = writer.Close() })
-	// Buffered + non-blocking send, not close: interruptibleReader retries each
-	// underlying Read on its own goroutine, so if bufio ever calls this more than
-	// once, a close() here would panic on the second call.
-	readStarted := make(chan struct{}, 1)
-	closeCalls := make(chan struct{}, 2)
-	reader := testReadCloser{
-		read: func(p []byte) (int, error) {
-			select {
-			case readStarted <- struct{}{}:
-			default:
-			}
-			return pipeReader.Read(p)
-		},
-		close: func() error {
-			closeCalls <- struct{}{}
-			return pipeReader.Close()
-		},
-	}
-	conn := NewOwnedConn(reader, io.Discard)
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan error, 1)
-	go func() { done <- conn.Serve(ctx) }()
-
-	<-readStarted
-	cancel()
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Fatalf("Serve returned %v after cancellation, want nil", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("Serve did not return after cancelling an idle connection")
-	}
-	if got := len(closeCalls); got != 1 {
-		t.Fatalf("reader Close calls = %d, want 1", got)
-	}
-}
-
-func TestConnServePreservesTerminalReadErrorDuringCancellation(t *testing.T) {
-	for _, closable := range []bool{false, true} {
-		name := "non-closable"
-		if closable {
-			name = "closable"
-		}
-		t.Run(name, func(t *testing.T) {
-			wantErr := errors.New("read failed")
-			read := testReader(func(p []byte) (int, error) {
-				return copy(p, "not json"), wantErr
-			})
-			closeCalls := make(chan struct{}, 1)
-			var reader io.Reader = read
-			if closable {
-				reader = testReadCloser{
-					read: read,
-					close: func() error {
-						closeCalls <- struct{}{}
-						return nil
-					},
-				}
-			}
-			// Buffered + non-blocking send, not close: a later change adding a
-			// second write (e.g. an additional error frame) must not panic on a
-			// repeated close of an already-closed channel.
-			writeStarted := make(chan struct{}, 1)
-			releaseWrite := make(chan struct{})
-			writer := testWriter(func(p []byte) (int, error) {
-				select {
-				case writeStarted <- struct{}{}:
-				default:
-				}
-				<-releaseWrite
-				return len(p), nil
-			})
-			newConn := NewConn
-			if closable {
-				// Ownership matters here: this case exists to prove that even a
-				// Conn entitled to close its reader on cancellation still
-				// preserves a terminal error that was already decided.
-				newConn = NewOwnedConn
-			}
-			conn := newConn(reader, writer)
-			ctx, cancel := context.WithCancel(context.Background())
-			done := make(chan error, 1)
-			go func() { done <- conn.Serve(ctx) }()
-
-			<-writeStarted
-			cancel()
-			close(releaseWrite)
-			select {
-			case err := <-done:
-				if !errors.Is(err, wantErr) {
-					t.Fatalf("Serve returned %v, want terminal read error %v", err, wantErr)
-				}
-			case <-time.After(time.Second):
-				t.Fatal("Serve did not return after terminal read error")
-			}
-			if got := len(closeCalls); got != 0 {
-				t.Fatalf("reader Close calls = %d, want 0 after terminal read", got)
-			}
-		})
-	}
-}
-
-// TestConnServePreservesReadErrorBufferedAlongsideAPriorLine is the deterministic
-// regression test for jatmn's #782 finding: a real, non-EOF ReadBytes failure can
-// be DECIDED before cancellation ever happens, yet only SURFACE afterward, and
-// must still be reported rather than swallowed as a clean shutdown.
-//
-// bufio.Reader can obtain data AND a terminal error from ONE underlying Read call
-// (io.Reader explicitly permits returning (n>0, err) together). If a delimiter is
-// found within that data, ReadBytes returns the line with a nil error for THIS
-// call, but bufio caches the error internally and returns it — WITHOUT calling the
-// underlying reader again — on the very next ReadBytes call. This test forces that
-// exact sequence: the underlying reader hands back one complete, validly-framed
-// line together with wantErr in a SINGLE call (asserted below to be its ONLY
-// call), the loop dispatches that line through a synchronous path that blocks the
-// read loop, cancellation is asserted to have happened before the loop attempts
-// its next read, and only then is the block released. By the time the read loop
-// asks for more input, cancellation is already in effect and the underlying
-// reader is never touched again — so if Serve attributed the resulting error to
-// cancellation merely because ctx was already done, it would incorrectly return
-// nil. It must instead recognize that this read was answered entirely from
-// bufio's own cache, never raced against ctx.Done(), and report wantErr.
-func TestConnServePreservesReadErrorBufferedAlongsideAPriorLine(t *testing.T) {
-	wantErr := errors.New("read failed")
-	var readCalls atomic.Int32
-	read := testReader(func(p []byte) (int, error) {
-		readCalls.Add(1)
-		// An unsupported jsonrpc version with an id takes the SYNCHRONOUS
-		// writeError path in handleLine (not a dispatched goroutine), giving this
-		// test a reliable blocking point between processing this line and the
-		// loop's next ReadBytes call.
-		return copy(p, `{"jsonrpc":"1.0","id":1}`+"\n"), wantErr
-	})
-	writeStarted := make(chan struct{}, 1)
-	releaseWrite := make(chan struct{})
-	var releaseWriteOnce sync.Once
-	release := func() { releaseWriteOnce.Do(func() { close(releaseWrite) }) }
-	t.Cleanup(release)
-	writer := testWriter(func(p []byte) (int, error) {
-		select {
-		case writeStarted <- struct{}{}:
-		default:
-		}
-		<-releaseWrite
-		return len(p), nil
-	})
-	conn := NewConn(read, writer)
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan error, 1)
-	go func() { done <- conn.Serve(ctx) }()
-
-	// The synchronous write confirms the first (and, per the panic guard above,
-	// only) read has already returned and is being processed — cancelling now
-	// lands squarely in the gap between that read and the loop's next one, never
-	// racing an in-flight interruptibleReader.Read call.
-	select {
-	case <-writeStarted:
-	case <-time.After(time.Second):
-		t.Fatal("Serve did not reach the synchronous write")
-	}
-	cancel()
-	release()
-
-	select {
-	case err := <-done:
-		if !errors.Is(err, wantErr) {
-			t.Fatalf("Serve returned %v, want the buffered terminal read error %v", err, wantErr)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("Serve did not return after the buffered terminal read error")
-	}
-	if got := readCalls.Load(); got != 1 {
-		t.Fatalf("underlying Read calls = %d, want exactly 1 (bufio must have served the second ReadBytes from its cache)", got)
-	}
-}
-
-// TestInterruptibleReaderPrefersDecidedResultOverCancellation is the regression
-// test for jatmn's second #782 finding: interruptibleReader.Read's select
-// between resultCh and ctx.Done() chooses pseudo-randomly when both are ready,
-// so a real, already-decided outcome (e.g. a terminal transport error) could be
-// misattributed to cancellation purely because ctx also happened to be done by
-// the time the select ran. Each iteration lets the underlying Read return (so
-// resultCh already holds the real outcome) before cancelling, maximizing the
-// odds of landing exactly in that ambiguous window; the generation counter must
-// never advance when the real, already-decided result is what gets returned.
-func TestInterruptibleReaderPrefersDecidedResultOverCancellation(t *testing.T) {
-	wantErr := errors.New("read failed")
-	for i := 0; i < 100; i++ {
-		resultReady := make(chan struct{})
-		read := testReader(func(p []byte) (int, error) {
-			defer close(resultReady)
-			return copy(p, "x"), wantErr
-		})
-		ctx, cancel := context.WithCancel(context.Background())
-		r := newInterruptibleReader(ctx, read, nil)
-
-		readDone := make(chan interruptibleReadResult, 1)
-		go func() {
-			n, err := r.Read(make([]byte, 8))
-			readDone <- interruptibleReadResult{n, err}
-		}()
-
-		<-resultReady
-		time.Sleep(time.Millisecond) // bias resultCh's send ahead of cancel
-		cancel()
-
-		res := <-readDone
-		if !errors.Is(res.err, wantErr) {
-			t.Fatalf("iteration %d: Read returned %v, want %v", i, res.err, wantErr)
-		}
-		if got := r.generation(); got != 0 {
-			t.Fatalf("iteration %d: generation = %d, want 0 (a decided result must never be attributed to cancellation)", i, got)
-		}
-		cancel()
-	}
-}
-
-// TestInterruptibleReadCompletionWinsBeforeResultPublication exercises the
-// actual inner-read wrapper at the handoff between the underlying Read and the
-// helper goroutine's result publication. Cancellation must not reclassify a
-// result returned by this wrapper as interrupted.
-func TestInterruptibleReadCompletionWinsBeforeResultPublication(t *testing.T) {
-	wantErr := errors.New("read failed")
-	read := testReader(func(p []byte) (int, error) {
-		return copy(p, "x"), wantErr
-	})
-	r := newInterruptibleReader(context.Background(), read, nil)
-	var decision interruptibleReadDecision
-	readComplete := make(chan struct{})
-	resultCh := make(chan interruptibleReadResult)
-	go func() {
-		res := r.readInner(make([]byte, 8), &decision)
-		close(readComplete)
-		resultCh <- res
-	}()
-
-	<-readComplete
-	if decision.interrupt() {
-		t.Fatal("cancellation claimed a read that completed before result publication")
-	}
-	res := <-resultCh
-	if res.n != 1 || !errors.Is(res.err, wantErr) {
-		t.Fatalf("inner read result = (%d, %v), want (1, %v)", res.n, res.err, wantErr)
-	}
-}
-
-func TestConnServeReportsReaderPanicAsTerminalError(t *testing.T) {
-	read := testReader(func([]byte) (int, error) {
-		panic("boom")
-	})
-	conn := NewConn(read, io.Discard)
-	done := make(chan error, 1)
-	go func() { done <- conn.Serve(context.Background()) }()
-
-	select {
-	case err := <-done:
-		const want = "acp: reader panicked: boom"
-		if err == nil || err.Error() != want {
-			t.Fatalf("Serve returned %v, want %q", err, want)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("Serve did not return after reader panic")
-	}
-}
-
 func TestConnRequestResponse(t *testing.T) {
 	a, b, stop := connPair(t)
 	defer stop()
@@ -5,29 +5,9 @@ import (
 	"strings"
 	"testing"

-	"github.com/Gitlawb/zero/internal/sandbox"
 	"github.com/Gitlawb/zero/internal/tools"
 )

-type normalizationRecordingShellTool struct {
-	calls []map[string]any
-}
-
-func (tool *normalizationRecordingShellTool) Name() string { return "bash" }
-func (tool *normalizationRecordingShellTool) Description() string {
-	return "record normalized shell arguments"
-}
-func (tool *normalizationRecordingShellTool) Parameters() tools.Schema {
-	return tools.Schema{Type: "object", AdditionalProperties: true}
-}
-func (tool *normalizationRecordingShellTool) Safety() tools.Safety {
-	return tools.Safety{SideEffect: tools.SideEffectShell, Permission: tools.PermissionAllow}
-}
-func (tool *normalizationRecordingShellTool) Run(_ context.Context, args map[string]any) tools.Result {
-	tool.calls = append(tool.calls, cloneArgs(args))
-	return tools.Result{Status: tools.StatusOK}
-}
-
 // A shell call that sets sandbox_permissions: with_additional_permissions but
 // omits (or malforms) additional_permissions can never succeed: the same
 // validation runs again at grant time regardless of the user's decision. It
@@ -164,120 +144,3 @@ func TestExecuteToolCallStillPromptsForValidAdditionalPermissions(t *testing.T)
 		t.Fatalf("OnPermissionRequest called %d times, want exactly 1 for a valid elevation request", promptCalls)
 	}
 }
-
-func TestNormalizeProviderExpandedEmptyAdditionalPermissions(t *testing.T) {
-	for _, mode := range []string{
-		string(tools.SandboxPermissionsUseDefault),
-		string(tools.SandboxPermissionsWithAdditionalPermissions),
-	} {
-		args := map[string]any{
-			"command":             "./zero --version",
-			"sandbox_permissions": mode,
-			"additional_permissions": map[string]any{
-				"file_system": map[string]any{
-					"deny_read": []any{},
-					"entries":   []any{},
-					"read":      []any{},
-					"write":     []any{},
-				},
-				"network": map[string]any{"enabled": false},
-			},
-		}
-		normalizeNoopAdditionalPermissions(args, t.TempDir(), nil)
-		if _, exists := args["additional_permissions"]; exists {
-			t.Fatalf("mode %q retained empty additional_permissions: %#v", mode, args)
-		}
-		if got := args["sandbox_permissions"]; got != string(tools.SandboxPermissionsUseDefault) {
-			t.Fatalf("mode %q normalized to %q, want use_default", mode, got)
-		}
-	}
-}
-
-func TestExecuteToolCallNormalizesProviderExpandedEmptyAdditionalPermissions(t *testing.T) {
-	tool := &normalizationRecordingShellTool{}
-	registry := tools.NewRegistry()
-	registry.Register(tool)
-
-	result, err := executeToolCall(
-		context.Background(),
-		registry,
-		ToolCall{
-			ID:   "c1",
-			Name: "bash",
-			Arguments: `{"command":"./zero --version","sandbox_permissions":"with_additional_permissions",` +
-				`"additional_permissions":{"file_system":{"deny_read":[],"entries":[],"read":[],"write":[]},"network":{"enabled":false}}}`,
-		},
-		PermissionModeAuto,
-		Options{Cwd: t.TempDir()},
-	)
-	if err != nil {
-		t.Fatalf("executeToolCall: %v", err)
-	}
-	if result.Status != tools.StatusOK {
-		t.Fatalf("provider-expanded empty permissions were rejected: %s", result.Output)
-	}
-	if len(tool.calls) != 1 {
-		t.Fatalf("shell tool calls = %d, want 1", len(tool.calls))
-	}
-	args := tool.calls[0]
-	if _, exists := args["additional_permissions"]; exists {
-		t.Fatalf("executeToolCall retained empty additional_permissions: %#v", args)
-	}
-	if got := args["sandbox_permissions"]; got != string(tools.SandboxPermissionsUseDefault) {
-		t.Fatalf("sandbox mode = %q, want use_default", got)
-	}
-}
-
-func TestNormalizeAdditionalPermissionsPreservesRealRequest(t *testing.T) {
-	args := map[string]any{
-		"sandbox_permissions": string(tools.SandboxPermissionsWithAdditionalPermissions),
-		"additional_permissions": map[string]any{
-			"network": map[string]any{"enabled": true},
-		},
-	}
-	normalizeNoopAdditionalPermissions(args, t.TempDir(), nil)
-	if _, exists := args["additional_permissions"]; !exists {
-		t.Fatal("non-empty additional_permissions was removed")
-	}
-	if got := args["sandbox_permissions"]; got != string(tools.SandboxPermissionsWithAdditionalPermissions) {
-		t.Fatalf("sandbox mode changed to %q", got)
-	}
-}
-
-func TestNormalizeAdditionalPermissionsRemovesWorkspaceReadAlreadyCoveredBySandbox(t *testing.T) {
-	root := t.TempDir()
-	engine := sandbox.NewEngine(sandbox.EngineOptions{
-		WorkspaceRoot: root,
-		Policy:        sandbox.DefaultPolicy(),
-	})
-	args := map[string]any{
-		"command":             "./zero --version",
-		"sandbox_permissions": string(tools.SandboxPermissionsWithAdditionalPermissions),
-		"additional_permissions": map[string]any{
-			"file_system": map[string]any{
-				"entries": []any{
-					map[string]any{
-						"access": "read",
-						"path": map[string]any{
-							"type": "path",
-							"path": ".",
-						},
-					},
-				},
-				"deny_read": []any{},
-				"read":      []any{},
-				"write":     []any{},
-			},
-			"network": map[string]any{"enabled": false},
-		},
-	}
-
-	normalizeNoopAdditionalPermissions(args, root, engine)
-
-	if _, exists := args["additional_permissions"]; exists {
-		t.Fatalf("already-covered additional_permissions was retained: %#v", args)
-	}
-	if got := args["sandbox_permissions"]; got != string(tools.SandboxPermissionsUseDefault) {
-		t.Fatalf("sandbox mode changed to %q", got)
-	}
-}
@@ -413,14 +413,6 @@ func (state *compactionState) maybeCompact(
 	// the bodies of old, large tool results (the model has already acted on
 	// them). If that brings us back under threshold, skip the paid summarizer
 	// entirely and preserve recent turns verbatim.
-	if pruned, reclaimed := pruneSupersededReadResults(messages); reclaimed > 0 {
-		messages = pruned
-		size = state.calibratedTokens(estimateTokens(messages) + toolTokens)
-		if size <= state.threshold {
-			state.lowWaterMark = size
-			return messages
-		}
-	}
 	if pruned, reclaimed := pruneStaleToolOutput(messages, state.preserveLast); reclaimed > 0 {
 		messages = pruned
 		size = state.calibratedTokens(estimateTokens(messages) + toolTokens)
@@ -379,43 +379,6 @@ func TestRunNoCompactionWhenContextWindowZero(t *testing.T) {
 	}
 }

-func TestMaybeCompactStopsAfterSupersededReadsReachThreshold(t *testing.T) {
-	body := strings.Repeat("same source line\n", 1000)
-	messages := []zeroruntime.Message{
-		{Role: zeroruntime.MessageRoleSystem, Content: "system"},
-		toolCallWithArgs("old", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "old", Content: body},
-		toolCallWithArgs("new", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "new", Content: body},
-	}
-	pruned, reclaimed := pruneSupersededReadResults(messages)
-	if reclaimed <= 0 {
-		t.Fatal("test setup did not reclaim superseded read output")
-	}
-	prunedSize := estimateTokens(pruned)
-	if estimateTokens(messages) <= prunedSize {
-		t.Fatal("test setup does not cross the compaction threshold")
-	}
-
-	provider := &summarizeRecordingProvider{}
-	state := &compactionState{
-		enabled:      true,
-		threshold:    prunedSize,
-		preserveLast: 2,
-	}
-	got := state.maybeCompact(context.Background(), provider, messages, nil)
-
-	if provider.summarizeCalls != 0 {
-		t.Fatalf("cheap pruning should avoid the summarizer, got %d calls", provider.summarizeCalls)
-	}
-	if state.lowWaterMark != prunedSize {
-		t.Fatalf("lowWaterMark = %d, want %d", state.lowWaterMark, prunedSize)
-	}
-	if !strings.Contains(got[2].Content, "superseded identical") || got[4].Content != body {
-		t.Fatalf("unexpected pruned messages: %#v", got)
-	}
-}
-
 // reactiveProvider builds up history with a tool call on turn 1, then errors
 // with a context-limit message on turn 2 (once the history is large enough that
 // compaction can shrink it), then succeeds on the same-turn retry. Summary
@@ -341,15 +341,15 @@ func TestPartitionToolsActiveHidesUnloadedExposesLoaded(t *testing.T) {
 	if search.Description != discovery || !strings.Contains(search.Description, "mcp") {
 		t.Fatalf("tool_search description must carry discovery source, got %q", search.Description)
 	}
-	if !strings.Contains(search.Description, "mcp__srv__alpha") {
-		t.Fatalf("stable tool_search catalog must retain already-loaded tool names, got %q", search.Description)
+	if strings.Contains(search.Description, "mcp__srv__alpha") {
+		t.Fatalf("tool_search description must not list already-loaded tool names, got %q", search.Description)
 	}
 	if !strings.Contains(search.Description, "mcp__srv__beta") {
 		t.Fatalf("tool_search description must list exact hidden tool names, got %q", search.Description)
 	}
 }

-func TestPartitionToolsActiveNothingHiddenKeepsStableCatalog(t *testing.T) {
+func TestPartitionToolsActiveNothingHiddenEmptyReminder(t *testing.T) {
 	registry := tools.NewRegistry()
 	registry.Register(fakeDeferredTool{name: "mcp__srv__alpha", desc: "alpha"})
 	registry.Register(fakeDeferredTool{name: "mcp__srv__beta", desc: "beta"})
@@ -368,8 +368,9 @@ func TestPartitionToolsActiveNothingHiddenKeepsStableCatalog(t *testing.T) {
 	if !exposedNames["tool_search"] {
 		t.Fatalf("expected tool_search exposed on active path, got %#v", exposed)
 	}
-	if !strings.Contains(reminder, "mcp__srv__alpha") || !strings.Contains(reminder, "mcp__srv__beta") {
-		t.Fatalf("stable catalog must retain all deferred names after loading, got %q", reminder)
+	// No hidden tools means no dynamic discovery text is needed.
+	if reminder != "" {
+		t.Fatalf("expected empty discovery text when nothing is hidden, got %q", reminder)
 	}
 }

@@ -1076,9 +1076,6 @@ func executeToolCall(ctx context.Context, registry *tools.Registry, call ToolCal
 			}, nil
 		}
 	}
-	if isShellCommandTool(call.Name) {
-		normalizeNoopAdditionalPermissions(args, options.Cwd, options.Sandbox)
-	}
 	// tool_search is the gateway to the allowlisted deferred tools, so a non-empty
 	// EnabledTools allowlist that omits it must NOT reject the call — otherwise the
 	// discovery tool exposed to the model rejects at dispatch time (an inescapable
@@ -1357,8 +1354,7 @@ func executeToolCall(ctx context.Context, registry *tools.Registry, call ToolCal
 		Cwd:               options.Cwd,
 		// Per-session file version tracker so write_file/edit_file refuse to clobber
 		// a file that changed on disk outside Zero since it was last read.
-		FileTracker:                options.FileTracker,
-		DeferFileObservationCommit: true,
+		FileTracker: options.FileTracker,
 		// Post-edit diagnostics are NOT forwarded to the tools: they used to run
 		// synchronously inside edit_file/write_file and block every mutating tool
 		// call on the language server (≥300ms debounce floor, 10s cap). The loop
@@ -1410,7 +1406,6 @@ func executeToolCall(ctx context.Context, registry *tools.Registry, call ToolCal
 			result = registry.RebudgetAfterHook(call.Name, args, result)
 		}
 	}
-	result = registry.CommitFileObservation(result, options.FileTracker)
 	// Stamp the sandbox risk classification for this EXECUTED call so run-policy
 	// observers can see the risk of an allowed mutation. Prefer the preflight
 	// decision's classification when the sandbox evaluated the call; otherwise
@@ -1622,15 +1617,9 @@ func sandboxRestrictedShellRetryCandidate(call ToolCall, args map[string]any, re

 func sandboxDeniedShellResult(result tools.Result) bool {
 	if result.ExecutionOutcome != nil {
-		// Only a typed platform denial that explicitly requests unrestricted
-		// recovery may enter the legacy retry path. Narrow capability denials
-		// remain on their exact capability path.
-		denial := result.ExecutionOutcome.Denial
-		return denial != nil &&
-			denial.Source == execution.DenialSourcePlatformSandbox &&
-			denial.Capability.Kind == execution.CapabilityUnrestricted &&
-			denial.Recoverable &&
-			denial.NextAction == execution.DenialNextActionRequestApproval
+		// Typed denials must be handled by their exact capability path. Never
+		// turn a structured narrow denial into the legacy unrestricted retry.
+		return false
 	}
 	return result.Status == tools.StatusError && result.Meta[tools.SandboxLikelyDeniedMeta] == "true"
 }
@@ -1695,21 +1684,20 @@ func sandboxRestrictionRetryReason(result tools.Result) string {

 func runToolForNetworkRetry(ctx context.Context, registry *tools.Registry, name string, toolCallID string, args map[string]any, permissionMode PermissionMode, options Options, progressCallback func(streamjson.Event)) tools.Result {
 	return registry.RunWithOptions(ctx, name, cloneArgs(args), tools.RunOptions{
-		PermissionGranted:          true,
-		PermissionMode:             string(permissionMode),
-		Autonomy:                   options.Autonomy,
-		Sandbox:                    options.Sandbox,
-		ToolCallID:                 toolCallID,
-		SessionID:                  options.SessionID,
-		Model:                      options.Model,
-		ReasoningEffort:            options.ReasoningEffort,
-		Depth:                      options.Depth,
-		Cwd:                        options.Cwd,
-		FileTracker:                options.FileTracker,
-		DeferFileObservationCommit: true,
-		EnabledTools:               options.EnabledTools,
-		DisabledTools:              options.DisabledTools,
-		Progress:                   progressCallback,
+		PermissionGranted: true,
+		PermissionMode:    string(permissionMode),
+		Autonomy:          options.Autonomy,
+		Sandbox:           options.Sandbox,
+		ToolCallID:        toolCallID,
+		SessionID:         options.SessionID,
+		Model:             options.Model,
+		ReasoningEffort:   options.ReasoningEffort,
+		Depth:             options.Depth,
+		Cwd:               options.Cwd,
+		FileTracker:       options.FileTracker,
+		EnabledTools:      options.EnabledTools,
+		DisabledTools:     options.DisabledTools,
+		Progress:          progressCallback,
 	})
 }

@@ -1724,21 +1712,20 @@ func unsandboxedRetryArgs(args map[string]any) map[string]any {

 func runToolForUnsandboxedRetry(ctx context.Context, registry *tools.Registry, name string, toolCallID string, args map[string]any, permissionMode PermissionMode, options Options, progressCallback func(streamjson.Event)) tools.Result {
 	return registry.RunWithOptions(ctx, name, args, tools.RunOptions{
-		PermissionGranted:          true,
-		PermissionMode:             string(permissionMode),
-		Autonomy:                   options.Autonomy,
-		Sandbox:                    options.Sandbox,
-		ToolCallID:                 toolCallID,
-		SessionID:                  options.SessionID,
-		Model:                      options.Model,
-		ReasoningEffort:            options.ReasoningEffort,
-		Depth:                      options.Depth,
-		Cwd:                        options.Cwd,
-		FileTracker:                options.FileTracker,
-		DeferFileObservationCommit: true,
-		EnabledTools:               options.EnabledTools,
-		DisabledTools:              options.DisabledTools,
-		Progress:                   progressCallback,
+		PermissionGranted: true,
+		PermissionMode:    string(permissionMode),
+		Autonomy:          options.Autonomy,
+		Sandbox:           options.Sandbox,
+		ToolCallID:        toolCallID,
+		SessionID:         options.SessionID,
+		Model:             options.Model,
+		ReasoningEffort:   options.ReasoningEffort,
+		Depth:             options.Depth,
+		Cwd:               options.Cwd,
+		FileTracker:       options.FileTracker,
+		EnabledTools:      options.EnabledTools,
+		DisabledTools:     options.DisabledTools,
+		Progress:          progressCallback,
 	})
 }

@@ -2755,45 +2742,6 @@ func shellCommandAdditionalPermissionsRequested(args map[string]any) bool {
 	return strings.TrimSpace(value) == string(tools.SandboxPermissionsWithAdditionalPermissions)
 }

-// normalizeNoopAdditionalPermissions treats a provider-expanded empty or
-// already-covered additional_permissions object as if it had been omitted.
-// Some strict-schema providers materialize every optional property and may add
-// a workspace read that the default sandbox already grants; rejecting either
-// no-op makes the model retry an otherwise valid command. Requests that broaden
-// access and malformed payloads are left untouched so validation stays closed.
-func normalizeNoopAdditionalPermissions(args map[string]any, basePath string, engine *sandbox.Engine) {
-	raw, exists := args["additional_permissions"]
-	if !exists || raw == nil {
-		return
-	}
-	data, err := json.Marshal(raw)
-	if err != nil {
-		return
-	}
-	var profile sandbox.RequestPermissionProfile
-	if err := json.Unmarshal(data, &profile); err != nil {
-		return
-	}
-	normalized, err := sandbox.NormalizeRequestPermissionProfile(profile, basePath)
-	if err != nil {
-		return
-	}
-	noop := normalized.Empty()
-	if !noop && engine != nil {
-		if grantProfile, grantErr := sandbox.RequestPermissionGrantProfile(normalized); grantErr == nil {
-			noop = engine.CoversRequestPermissions(grantProfile)
-		}
-	}
-	if !noop {
-		return
-	}
-	delete(args, "additional_permissions")
-	if rawMode, ok := args["sandbox_permissions"].(string); ok &&
-		strings.TrimSpace(rawMode) == string(tools.SandboxPermissionsWithAdditionalPermissions) {
-		args["sandbox_permissions"] = string(tools.SandboxPermissionsUseDefault)
-	}
-}
-
 func inlineAdditionalPermissionsProfile(args map[string]any, basePath string) (sandbox.RequestPermissionProfile, bool, error) {
 	if !shellCommandAdditionalPermissionsRequested(args) {
 		if _, exists := args["additional_permissions"]; exists {
@@ -2984,20 +2932,22 @@ func partitionToolsCached(registry *tools.Registry, permissionMode PermissionMod
 	//   2. tool_search — always present, right after the stable block;
 	//   3. loaded deferred tools, alpha-sorted — APPENDED, so an unloaded->loaded
 	//      transition grows the tail instead of inserting into the eager block.
-	// tool_search's compact catalog also stays byte-stable as tools load, so only
-	// the appended full-schema tail changes.
+	// (tool_search's discovery text still shrinks as tools load, so keeping it and
+	// the loaded tail AFTER the eager block preserves the eager tools' cache across a
+	// load; fully stabilizing the loader's own description is a scoped follow-up.)
 	eager := make([]zeroruntime.ToolDefinition, 0, len(visible))
 	loadedTail := make([]zeroruntime.ToolDefinition, 0)
-	var deferredCatalog []tools.Tool
+	var hiddenTools []tools.Tool
 	for _, tool := range visible {
 		name := tool.Name()
 		if name == tools.ToolSearchToolName {
 			continue // added explicitly between the eager block and the loaded tail
 		}
 		if tools.IsDeferred(tool) {
-			deferredCatalog = append(deferredCatalog, tool)
 			if loaded[name] {
 				loadedTail = append(loadedTail, cachedRuntimeToolDefinition(defCache, tool))
+			} else {
+				hiddenTools = append(hiddenTools, tool)
 			}
 			continue
 		}
@@ -3010,16 +2960,15 @@ func partitionToolsCached(registry *tools.Registry, permissionMode PermissionMod
 		return loadedTail[left].Name < loadedTail[right].Name
 	})

-	// Keep the catalog byte-stable as tools load. tool_search already redirects
-	// requests for an exposed tool back to the current tool list, so retaining
-	// loaded names costs only compact catalog lines and avoids invalidating the
-	// provider cache at the loader definition on every load.
-	discovery := tools.BuildToolSearchDescription(deferredCatalog)
+	discovery := ""
+	if len(hiddenTools) > 0 {
+		discovery = tools.BuildToolSearchDescription(hiddenTools)
+	}

 	// tool_search is guaranteed runnable on the active path, so it is ALWAYS exposed
 	// — even when a non-empty EnabledTools allowlist omits it (the operator
 	// allowlisted the deferred tools, not the loader). It sits right after the stable
-	// eager block and carries the stable deferred-tool catalog.
+	// eager block and carries the discovery list for still-hidden tools.
 	description := loader.Description()
 	if discovery != "" {
 		description = discovery
@@ -64,22 +64,6 @@ func TestTypedExecutionOutcomeOverridesLegacySandboxHeuristics(t *testing.T) {
 		t.Fatal("narrow protected-metadata denial must not become an unrestricted retry")
 	}

-	nonRecoverableDenial := protectedDenial
-	nonRecoverableDenial.ExecutionOutcome = &execution.Outcome{
-		State: execution.StateDenied,
-		Kind:  execution.OutcomeEnforcementDenied,
-		Denial: &execution.Denial{
-			Capability:  execution.Capability{Kind: execution.CapabilityUnrestricted, Scope: "host"},
-			Source:      execution.DenialSourcePlatformSandbox,
-			Reason:      "sandbox enforcement failed closed",
-			Recoverable: false,
-			NextAction:  execution.DenialNextActionRequestApproval,
-		},
-	}
-	if sandboxRestrictedShellRetryCandidate(call, nil, nonRecoverableDenial, options) {
-		t.Fatal("non-recoverable sandbox denial must not become an unrestricted retry")
-	}
-
 	networkDenial := protectedDenial
 	networkDenial.ExecutionOutcome = &execution.Outcome{
 		State: execution.StateDenied,
@@ -304,18 +288,6 @@ func (tool *sandboxDeniedRetryTool) Run(_ context.Context, args map[string]any)
 	return tools.Result{
 		Status: tools.StatusError,
 		Output: "touch: cannot touch '/home/user/.npm/cache': Read-only file system",
-		ExecutionOutcome: &execution.Outcome{
-			State: execution.StateDenied,
-			Kind:  execution.OutcomeEnforcementDenied,
-			Exit:  &execution.Exit{Code: 1},
-			Denial: &execution.Denial{
-				Capability:  execution.Capability{Kind: execution.CapabilityUnrestricted, Scope: "host"},
-				Source:      execution.DenialSourcePlatformSandbox,
-				Reason:      "sandbox blocked command execution",
-				Recoverable: true,
-				NextAction:  execution.DenialNextActionRequestApproval,
-			},
-		},
 		Meta: map[string]string{
 			"exit_code":                    "1",
 			tools.SandboxLikelyDeniedMeta:  "true",
@@ -332,8 +304,7 @@ type sandboxDeniedExecCommandRetryTool struct {
 func (tool *sandboxDeniedExecCommandRetryTool) Name() string { return "exec_command" }

 type sandboxNetworkDeniedRetryTool struct {
-	calls                      []map[string]any
-	deferFileObservationCommit []bool
+	calls []map[string]any
 }

 func (tool *sandboxNetworkDeniedRetryTool) Name() string        { return "bash" }
@@ -356,7 +327,6 @@ func (tool *sandboxNetworkDeniedRetryTool) Run(ctx context.Context, args map[str
 }
 func (tool *sandboxNetworkDeniedRetryTool) RunWithOptions(ctx context.Context, args map[string]any, options tools.RunOptions) tools.Result {
 	tool.calls = append(tool.calls, cloneArgs(args))
-	tool.deferFileObservationCommit = append(tool.deferFileObservationCommit, options.DeferFileObservationCommit)
 	if shellNetworkAllowed(ctx, options.Sandbox, args) {
 		return tools.Result{Status: tools.StatusOK, Output: "server started"}
 	}
@@ -399,8 +369,7 @@ func agentNativeBackendStub() sandbox.Backend {
 }

 type sandboxNamespaceLimitedRetryTool struct {
-	calls                      []map[string]any
-	deferFileObservationCommit []bool
+	calls []map[string]any
 }

 func (tool *sandboxNamespaceLimitedRetryTool) Name() string        { return "bash" }
@@ -419,12 +388,8 @@ func (tool *sandboxNamespaceLimitedRetryTool) Parameters() tools.Schema {
 func (tool *sandboxNamespaceLimitedRetryTool) Safety() tools.Safety {
 	return tools.Safety{SideEffect: tools.SideEffectShell, Permission: tools.PermissionPrompt, Reason: "runs shell commands"}
 }
-func (tool *sandboxNamespaceLimitedRetryTool) Run(ctx context.Context, args map[string]any) tools.Result {
-	return tool.RunWithOptions(ctx, args, tools.RunOptions{})
-}
-func (tool *sandboxNamespaceLimitedRetryTool) RunWithOptions(_ context.Context, args map[string]any, options tools.RunOptions) tools.Result {
+func (tool *sandboxNamespaceLimitedRetryTool) Run(_ context.Context, args map[string]any) tools.Result {
 	tool.calls = append(tool.calls, cloneArgs(args))
-	tool.deferFileObservationCommit = append(tool.deferFileObservationCommit, options.DeferFileObservationCommit)
 	if args["sandbox_permissions"] == string(tools.SandboxPermissionsRequireEscalated) {
 		return tools.Result{Status: tools.StatusOK, Output: "stdout:\nUSER PID COMMAND\nanaxy 42 firefox\nanaxy 43 Discord"}
 	}
@@ -490,9 +455,6 @@ func TestRunRetriesShellUnsandboxedAfterSandboxNamespaceLimitedOutput(t *testing
 	if retryTool.calls[1]["sandbox_permissions"] != string(tools.SandboxPermissionsRequireEscalated) {
 		t.Fatalf("retry args = %#v, want require_escalated", retryTool.calls[1])
 	}
-	if len(retryTool.deferFileObservationCommit) != 2 || !retryTool.deferFileObservationCommit[1] {
-		t.Fatalf("retry defer flags = %#v, want retry observation deferred", retryTool.deferFileObservationCommit)
-	}
 	if len(requests) != 1 {
 		t.Fatalf("permission requests = %#v, want one unsandboxed retry approval", requests)
 	}
@@ -644,9 +606,6 @@ func TestRunRetriesNetworkDeniedShellWithNetworkGrant(t *testing.T) {
 	if _, escalated := retryTool.calls[1]["sandbox_permissions"]; escalated {
 		t.Fatalf("network retry must stay sandboxed, got retry args %#v", retryTool.calls[1])
 	}
-	if len(retryTool.deferFileObservationCommit) != 2 || !retryTool.deferFileObservationCommit[1] {
-		t.Fatalf("retry defer flags = %#v, want retry observation deferred", retryTool.deferFileObservationCommit)
-	}
 	if len(requests) != 1 || requests[0].Reason != sandbox.ReasonNetworkBlocked {
 		t.Fatalf("permission requests = %#v, want one network approval", requests)
 	}
@@ -2445,11 +2404,7 @@ func TestRunApprovedNetworkBashPromptAppliesTurnNetworkGrant(t *testing.T) {
 	root := t.TempDir()
 	command := "PATH=.:$PATH curl https://example.com"
 	if runtime.GOOS == "windows" {
-		if windowsTestUsesPowerShell() {
-			command = `$env:PATH = '.;' + $env:PATH; curl.cmd https://example.com`
-		} else {
-			command = "set PATH=.;%PATH% && curl https://example.com"
-		}
+		command = "set PATH=.;%PATH% && curl https://example.com"
 		fakeCurl := filepath.Join(root, "curl.cmd")
 		if err := os.WriteFile(fakeCurl, []byte("@echo fake curl %*\r\n"), 0o755); err != nil {
 			t.Fatal(err)
@@ -2570,17 +2525,13 @@ func TestRunDoesNotOfferPrefixApprovalForUnsafeBashCommand(t *testing.T) {

 func TestRunPromptsForDestructiveShellInsteadOfSandboxDeny(t *testing.T) {
 	root := t.TempDir()
-	command := "echo rm -rf /"
-	if runtime.GOOS == "windows" && windowsTestUsesPowerShell() {
-		command = `Write-Output 'rm -rf /'`
-	}
 	registry := tools.NewRegistry()
 	registry.Register(tools.NewScopedBashTool(root, nil))
 	provider := &mockProvider{
 		turns: [][]zeroruntime.StreamEvent{
 			{
 				{Type: zeroruntime.StreamEventToolCallStart, ToolCallID: "call-1", ToolName: "bash"},
-				{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "call-1", ArgumentsFragment: `{"command":` + quoteJSONString(command) + `}`},
+				{Type: zeroruntime.StreamEventToolCallDelta, ToolCallID: "call-1", ArgumentsFragment: `{"command":"echo rm -rf /"}`},
 				{Type: zeroruntime.StreamEventToolCallEnd, ToolCallID: "call-1"},
 				{Type: zeroruntime.StreamEventDone},
 			},
@@ -2676,12 +2627,6 @@ func TestRunAlwaysAllowWithoutSandboxStillAllowsCall(t *testing.T) {
 	}
 }

-func windowsTestUsesPowerShell() bool {
-	executable, _ := tools.HostShellCommand("")
-	name := strings.ToLower(filepath.Base(executable))
-	return strings.Contains(name, "powershell") || strings.HasPrefix(name, "pwsh")
-}
-
 func containsPermissionDecision(decisions []PermissionDecisionAction, want PermissionDecisionAction) bool {
 	for _, decision := range decisions {
 		if decision == want {
@@ -3215,17 +3160,22 @@ func TestBuildSystemPromptInjectsHostShellContext(t *testing.T) {
 		t.Fatalf("expected operating system in environment block, got %q", prompt)
 	}
 	if runtime.GOOS == "windows" {
-		wants := []string{"workdir/cwd", "MSYS binaries"}
-		if windowsTestUsesPowerShell() {
-			wants = append(wants, "PowerShell", "Get-ChildItem", "Select-String", "$env:NAME", "require_escalated")
-		} else {
-			wants = append(wants, "cmd.exe", "double quotes")
-		}
-		for _, want := range wants {
+		for _, want := range []string{"Windows cmd.exe syntax", "cwd argument", "MSYS binaries", "grep", "require_escalated", "use double quotes around the value"} {
 			if !strings.Contains(prompt, want) {
-				t.Fatalf("expected selected Windows shell guidance to mention %q, got %q", want, prompt)
+				t.Fatalf("expected Windows shell guidance to mention %q, got %q", want, prompt)
 			}
 		}
+		// The examples must themselves use the safe (double-quoted) form; a
+		// single-quoted example here would teach the model the exact syntax
+		// that fails under cmd.exe.
+		for _, want := range []string{`--jq ".a | b"`, `-run "A|B"`} {
+			if !strings.Contains(prompt, want) {
+				t.Fatalf("expected double-quoted example %q in Windows shell guidance, got %q", want, prompt)
+			}
+		}
+		if strings.Contains(prompt, `'.a | b'`) || strings.Contains(prompt, `'A|B'`) {
+			t.Fatalf("Windows shell guidance must not show the unsafe single-quoted form, got %q", prompt)
+		}
 	} else if !strings.Contains(prompt, "/bin/sh syntax") {
 		t.Fatalf("expected POSIX shell guidance in prompt, got %q", prompt)
 	}
@@ -3,7 +3,6 @@ package agent
 import (
 	"context"
 	"os"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
@@ -20,16 +19,6 @@ type propagationOutputTool struct {

 func TestOutputBudgetHookHelperProcess(t *testing.T) {
 	for index, arg := range os.Args {
-		if arg == "--zero-output-budget-hook-repeat" && index+1 < len(os.Args) {
-			repeats, err := strconv.Atoi(os.Args[index+1])
-			if err != nil {
-				os.Exit(2)
-			}
-			if _, err := os.Stdout.WriteString(strings.Repeat("hook feedback ", repeats)); err != nil {
-				os.Exit(2)
-			}
-			os.Exit(0)
-		}
 		if arg != "--zero-output-budget-hook" || index+1 >= len(os.Args) {
 			continue
 		}
@@ -41,102 +30,25 @@ func TestOutputBudgetHookHelperProcess(t *testing.T) {
 }

 func largeOutputBudgetHookDispatcher() *hooks.Dispatcher {
-	return outputBudgetHookDispatcherFor("propagation_output", 200)
-}
-
-func outputBudgetHookDispatcherFor(toolName string, repeats int) *hooks.Dispatcher {
-	feedback := strings.Repeat("hook feedback ", repeats)
-	hookArgs := []string{
-		"-test.run=TestOutputBudgetHookHelperProcess",
-		"--",
-		"--zero-output-budget-hook",
-		feedback,
-	}
-	if repeats > 1_000 {
-		hookArgs = []string{
-			"-test.run=TestOutputBudgetHookHelperProcess",
-			"--",
-			"--zero-output-budget-hook-repeat",
-			strconv.Itoa(repeats),
-		}
-	}
+	feedback := strings.Repeat("hook feedback ", 200)
 	return hooks.NewDispatcher(hooks.DispatcherOptions{Config: hooks.Config{
 		Enabled: true,
 		Hooks: []hooks.Definition{{
 			ID:      "large-feedback",
 			Event:   hooks.EventAfterTool,
-			Matcher: toolName,
+			Matcher: "propagation_output",
 			Command: os.Args[0],
-			Args:    hookArgs,
+			Args: []string{
+				"-test.run=TestOutputBudgetHookHelperProcess",
+				"--",
+				"--zero-output-budget-hook",
+				feedback,
+			},
 			Enabled: true,
 		}},
 	}})
 }

-func TestExecuteToolCallCommitsReadObservationAfterFinalBoundary(t *testing.T) {
-	root := t.TempDir()
-	targetPath := filepath.Join(root, "target.txt")
-	if err := os.WriteFile(targetPath, []byte("known content\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	linkPath := filepath.Join(root, "small.txt")
-	if err := os.Symlink(targetPath, linkPath); err != nil {
-		t.Skipf("symlink unavailable: %v", err)
-	}
-	resolvedPath, err := filepath.EvalSymlinks(linkPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	registry := tools.NewRegistry()
-	registry.Register(tools.NewReadFileTool(root))
-	tracker := tools.NewFileTracker()
-
-	result, abortErr := executeToolCall(context.Background(), registry, ToolCall{
-		ID: "read-small", Name: "read_file", Arguments: `{"path":"small.txt"}`,
-	}, PermissionModeAuto, Options{Cwd: root, FileTracker: tracker})
-	if abortErr != nil || result.Status != tools.StatusOK {
-		t.Fatalf("executeToolCall: result=%#v err=%v", result, abortErr)
-	}
-	if !tracker.SeenWhole(resolvedPath) {
-		t.Fatal("unmodified final read output was not committed as observed")
-	}
-}
-
-func TestExecuteToolCallDoesNotCommitReadObservationBeforeHookBudget(t *testing.T) {
-	t.Setenv("ZERO_TOOL_OUTPUT_CEILING_TOKENS", "80")
-	root := t.TempDir()
-	targetPath := filepath.Join(root, "target.txt")
-	if err := os.WriteFile(targetPath, []byte("known content\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	linkPath := filepath.Join(root, "small.txt")
-	if err := os.Symlink(targetPath, linkPath); err != nil {
-		t.Skipf("symlink unavailable: %v", err)
-	}
-	resolvedPath, err := filepath.EvalSymlinks(linkPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	registry := tools.NewRegistry()
-	registry.Register(tools.NewReadFileTool(root))
-	tracker := tools.NewFileTracker()
-
-	result, abortErr := executeToolCall(context.Background(), registry, ToolCall{
-		ID: "read-hook", Name: "read_file", Arguments: `{"path":"small.txt"}`,
-	}, PermissionModeAuto, Options{
-		Cwd: root, FileTracker: tracker, Hooks: outputBudgetHookDispatcherFor("read_file", 20_000),
-	})
-	if abortErr != nil {
-		t.Fatalf("executeToolCall: %v", abortErr)
-	}
-	if !result.Truncated {
-		t.Fatalf("precondition: hook feedback was not truncated: %#v", result)
-	}
-	if tracker.SeenWhole(resolvedPath) {
-		t.Fatal("read observation committed before hook output was budgeted")
-	}
-}
-
 func (tool propagationOutputTool) Name() string        { return "propagation_output" }
 func (tool propagationOutputTool) Description() string { return "returns output for propagation tests" }
 func (tool propagationOutputTool) Parameters() tools.Schema {
@@ -91,7 +91,7 @@ func (c *profileController) maybeEscalate() (PostureEscalation, bool) {
 	if c.policy == nil || c.escalated {
 		return PostureEscalation{}, false
 	}
-	if !c.failureTripped && !c.riskTripped && !c.scTripped && !c.uncertainTrip {
+	if !(c.failureTripped || c.riskTripped || c.scTripped || c.uncertainTrip) {
 		return PostureEscalation{}, false
 	}
 	c.escalated = true
@@ -121,67 +121,3 @@ func toolNameForResult(messages []zeroruntime.Message, index int) string {
 func isPrunedPlaceholder(content string) bool {
 	return strings.HasPrefix(strings.TrimSpace(content), "[pruned ")
 }
-
-var supersedableReadTools = map[string]bool{
-	"read_file":          true,
-	"read_minified_file": true,
-	"grep":               true,
-	"glob":               true,
-	"list_directory":     true,
-}
-
-// pruneSupersededReadResults removes only older byte-identical results of the
-// same read call. It runs when context pressure already requires a rewrite, so
-// it does not trade a warm provider-cache prefix for a small apparent saving.
-func pruneSupersededReadResults(messages []zeroruntime.Message) ([]zeroruntime.Message, int) {
-	type seenResultKey struct {
-		call    string
-		content string
-	}
-	seen := map[seenResultKey]struct{}{}
-	out := messages
-	reclaimed := 0
-	copied := false
-
-	for index := len(messages) - 1; index >= 0; index-- {
-		message := messages[index]
-		if message.Role != zeroruntime.MessageRoleTool || isPrunedPlaceholder(message.Content) {
-			continue
-		}
-		call, ok := toolCallForResult(messages, index)
-		if !ok || !supersedableReadTools[call.Name] {
-			continue
-		}
-		key := seenResultKey{
-			call:    call.Name + "\x00" + strings.TrimSpace(call.Arguments),
-			content: message.Content,
-		}
-		if _, exists := seen[key]; exists {
-			placeholder := fmt.Sprintf("[superseded identical %s result — the newer result remains in context]", call.Name)
-			if !copied {
-				out = append([]zeroruntime.Message(nil), messages...)
-				copied = true
-			}
-			out[index].Content = placeholder
-			reclaimed += max(0, ApproxTextTokens(message.Content)-ApproxTextTokens(placeholder))
-			continue
-		}
-		seen[key] = struct{}{}
-	}
-	return out, reclaimed
-}
-
-func toolCallForResult(messages []zeroruntime.Message, resultIndex int) (zeroruntime.ToolCall, bool) {
-	id := messages[resultIndex].ToolCallID
-	if id == "" {
-		return zeroruntime.ToolCall{}, false
-	}
-	for index := resultIndex - 1; index >= 0; index-- {
-		for _, call := range messages[index].ToolCalls {
-			if call.ID == id {
-				return call, true
-			}
-		}
-	}
-	return zeroruntime.ToolCall{}, false
-}
@@ -25,13 +25,6 @@ func toolCallMsg(id, name string) zeroruntime.Message {
 	}
 }

-func toolCallWithArgs(id, name, args string) zeroruntime.Message {
-	return zeroruntime.Message{
-		Role:      zeroruntime.MessageRoleAssistant,
-		ToolCalls: []zeroruntime.ToolCall{{ID: id, Name: name, Arguments: args}},
-	}
-}
-
 func TestPruneSkipsSmallSessions(t *testing.T) {
 	// Total reclaimable is under the gate → no pruning.
 	msgs := []zeroruntime.Message{
@@ -127,69 +120,3 @@ func TestPruneDoesNotMutateInput(t *testing.T) {
 		t.Fatal("pruneStaleToolOutput must not mutate the caller's slice")
 	}
 }
-
-func TestPruneSupersededReadResultsOnlyDropsIdenticalOlderReads(t *testing.T) {
-	body := strings.Repeat("same source line\n", 1000)
-	messages := []zeroruntime.Message{
-		toolCallWithArgs("old", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "old", Content: body},
-		toolCallWithArgs("different", "read_file", `{"path":"b.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "different", Content: body},
-		toolCallWithArgs("new", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "new", Content: body},
-	}
-	out, reclaimed := pruneSupersededReadResults(messages)
-	if reclaimed <= 0 || !strings.Contains(out[1].Content, "superseded identical") {
-		t.Fatalf("older duplicate was not pruned: reclaimed=%d output=%q", reclaimed, out[1].Content)
-	}
-	if out[3].Content != body || out[5].Content != body {
-		t.Fatal("different call and newest result must remain exact")
-	}
-	if messages[1].Content != body {
-		t.Fatal("input slice was mutated")
-	}
-}
-
-func TestPruneSupersededReadResultsKeepsChangedAndMutatingResults(t *testing.T) {
-	messages := []zeroruntime.Message{
-		toolCallWithArgs("r1", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "r1", Content: "version one"},
-		toolCallWithArgs("r2", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "r2", Content: "version two"},
-		toolCallWithArgs("e1", "edit_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "e1", Content: "edited"},
-		toolCallWithArgs("e2", "edit_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "e2", Content: "edited"},
-	}
-	out, reclaimed := pruneSupersededReadResults(messages)
-	if reclaimed != 0 {
-		t.Fatalf("unsafe results were pruned: %d", reclaimed)
-	}
-	for index := range messages {
-		if out[index].Content != messages[index].Content {
-			t.Fatalf("message %d changed unexpectedly", index)
-		}
-	}
-}
-
-func TestPruneSupersededReadResultsFindsMatchingBodyAcrossChangedRead(t *testing.T) {
-	bodyA := strings.Repeat("version a\n", 100)
-	bodyB := strings.Repeat("version b\n", 100)
-	messages := []zeroruntime.Message{
-		toolCallWithArgs("old-a", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "old-a", Content: bodyA},
-		toolCallWithArgs("middle-b", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "middle-b", Content: bodyB},
-		toolCallWithArgs("new-a", "read_file", `{"path":"a.go"}`),
-		{Role: zeroruntime.MessageRoleTool, ToolCallID: "new-a", Content: bodyA},
-	}
-
-	out, reclaimed := pruneSupersededReadResults(messages)
-
-	if reclaimed <= 0 || !strings.Contains(out[1].Content, "superseded identical") {
-		t.Fatalf("older matching body was not pruned across a changed result: reclaimed=%d output=%q", reclaimed, out[1].Content)
-	}
-	if out[3].Content != bodyB || out[5].Content != bodyA {
-		t.Fatal("changed middle result and newest matching result must remain exact")
-	}
-}
@@ -26,16 +26,6 @@ func TestSpecialistDelegationContext(t *testing.T) {
 	if strings.Contains(got, "nameless") {
 		t.Fatalf("nameless entry should be skipped: %q", got)
 	}
-	for _, want := range []string{"reduce total context", "Do not delegate small direct work", "bounded assignment"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("missing evidence-driven delegation guidance %q: %q", want, got)
-		}
-	}
-	for _, unwanted := range []string{"delegate to it proactively", "launch several specialists in parallel"} {
-		if strings.Contains(got, unwanted) {
-			t.Fatalf("retained broad delegation guidance %q: %q", unwanted, got)
-		}
-	}
 }

 func TestSystemPromptIncludesDelegationOnlyWithSpecialists(t *testing.T) {
@@ -11,7 +11,6 @@ import (

 	"github.com/Gitlawb/zero/internal/config"
 	"github.com/Gitlawb/zero/internal/repomap"
-	"github.com/Gitlawb/zero/internal/tools"
 	"github.com/Gitlawb/zero/internal/workspaceseed"
 )

@@ -179,19 +178,21 @@ func approvedCommandPrefixContext(options Options) string {
 	return "## Approved Command Prefixes\n\nThe following command prefixes have already been approved and do not need another permission prompt:\n" + strings.Join(lines, "\n")
 }

-// specialistDelegationContext describes when a specialist earns its extra
-// context and coordination cost. It renders only when specialists are known
-// (which is only where the Task tool is actually registered), so a run with no
-// delegatable specialists produces the previous prompt unchanged.
+// specialistDelegationContext nudges the orchestrator to offload read-heavy or
+// parallelizable work to a specialist sub-agent via the Task tool, keeping large
+// tool outputs out of the main context. It renders only when specialists are
+// known (which is only where the Task tool is actually registered), so a run with
+// no delegatable specialists produces the previous prompt unchanged.
 func specialistDelegationContext(options Options) string {
 	if len(options.Specialists) == 0 {
 		return ""
 	}
 	var b strings.Builder
 	b.WriteString("<specialists>\n")
-	b.WriteString("Use the Task tool when a specialist's focused context, expertise, or an independent parallel subtask is likely to improve quality or reduce total context. ")
-	b.WriteString("Do not delegate small direct work, duplicate exploration, or split sequential steps merely because a specialist is available. ")
-	b.WriteString("When delegating, give a bounded assignment and consume its concise evidence instead of importing a long transcript.\n")
+	b.WriteString("Delegate focused or read-heavy work to a specialist sub-agent with the Task tool instead of doing it inline. ")
+	b.WriteString("When a request matches a specialist's purpose, delegate to it proactively — you do not need the user to ask first. ")
+	b.WriteString("This keeps large tool outputs — searches, file dumps, multi-step exploration — out of your own context, so you stay fast and token-efficient. ")
+	b.WriteString("Prefer delegating codebase search and exploration; for independent subtasks, launch several specialists in parallel. Handle small, direct edits yourself.\n")
 	b.WriteString("Available specialists (call Task with the matching name when the task fits its purpose):\n")
 	for _, info := range options.Specialists {
 		name := strings.TrimSpace(info.Name)
@@ -309,7 +310,11 @@ func workspaceContext(cwd string) string {
 	b.WriteString("<environment>\n")
 	b.WriteString("Working directory: " + cwd + "\n")
 	b.WriteString("Operating system: " + runtime.GOOS + "\n")
-	b.WriteString(tools.HostShellEnvironmentGuidance() + "\n")
+	if runtime.GOOS == "windows" {
+		b.WriteString("Shell syntax: Windows cmd.exe syntax for exec_command/bash tools. To put | & > < etc inside an arg value, use double quotes around the value, not single quotes (single quotes do not protect metachars in cmd.exe): gh --jq \".a | b\", go test -run \"A|B\". Do not pipe to or invoke POSIX coreutils from Git for Windows (usr\\bin head/grep/tail/cat/...): they are MSYS binaries and fail under the write-restricted sandbox; use native Zero tools (grep, read_file, list_directory, glob) or cmd.exe findstr/more instead, or sandbox_permissions require_escalated only when host-level execution is truly required. Prefer the workdir/cwd argument over cd when changing directories.\n")
+	} else {
+		b.WriteString("Shell syntax: /bin/sh syntax for exec_command/bash tools; prefer the workdir/cwd argument instead of cd when changing directories.\n")
+	}
 	if branch := gitBranchForPrompt(cwd); branch != "" {
 		b.WriteString("Git branch: " + branch + "\n")
 	}
@@ -31,10 +31,15 @@ work.
   tests, or config before you modify behavior. Never edit a file you have not
   read.
 2. **Plan.** For multi-step work, call update_plan with an ordered checklist and
-   keep it current at meaningful milestones. Mark completed work and the next
-   in-progress step together when practical; do not spend separate model turns
-   updating the plan after every file or command. Keep at most one item
-   in_progress. Skip the plan for trivial one-step tasks.
+   keep it live. The plan bar is the user's progress signal — call update_plan
+   after EACH concrete unit of work (every file written, every command run), not
+   just at coarse milestones: mark the finished item completed and the next one
+   in_progress before you start it. A plan stuck at 0/N while files are landing is
+   a bug, not economy — these calls are cheap, expected, and the update_plan cards
+   are hidden from the transcript, so frequent updates cost the user nothing and
+   never clutter the conversation. Keep at most one item in_progress, and never
+   batch the updates to the end of the turn. Skip the plan for trivial one-step
+   tasks.
 3. **Implement.** Make focused changes that match the surrounding code's style,
   naming, and conventions. Prefer the smallest change that fully solves the
   problem. Avoid broad refactors, unrelated rewrites, dependency churn, and
@@ -52,9 +57,8 @@ work.
  file tools - read_file, list_directory, glob, grep, write_file, edit_file,
  apply_patch - over shelling out to cat/sed/awk/python for file operations.
  They are safer, reviewable, and produce clean diffs.
- Keep edits focused and reviewable. A single patch may update several related
-  files when they form one coherent change; do not hide unrelated edits in a
-  bulk shell or script rewrite.
+- Make one tool call per file. Do not batch multi-file writes into a single
+  shell or script invocation.
 - For edits to existing files, prefer edit_file or apply_patch with minimal,
  targeted diffs. Match the existing indentation, imports, and idioms. Match the
  file's comment density: do not add explanatory comments unless the user asks or
@@ -125,7 +125,9 @@ func Score(suite Suite, input ScoreInput) Report {
 	if len(task.RequiredTraceEvents) > 0 {
 		report.Results = append(report.Results, scoreTraceEvents(task.RequiredTraceEvents, input))
 	}
-	report.Results = append(report.Results, unknownCommandResults(input.CommandResults, seenCommands, input)...)
+	for _, result := range unknownCommandResults(input.CommandResults, seenCommands, input) {
+		report.Results = append(report.Results, result)
+	}
 	report.finishSummary()
 	return report
 }
@@ -40,14 +40,14 @@ func FormatFacts(info repoinfo.Info) string {
 	b.WriteString("Pre-computed repository facts (from a local scan — verify and fill gaps):\n")

 	if info.PrimaryLanguage != "" {
-		fmt.Fprintf(&b, "- Primary language: %s (of %d detected)\n", info.PrimaryLanguage, info.LanguageCount)
+		b.WriteString(fmt.Sprintf("- Primary language: %s (of %d detected)\n", info.PrimaryLanguage, info.LanguageCount))
 	}
 	if langs := topLanguages(info.Languages, 5); langs != "" {
 		b.WriteString("- Languages: " + langs + "\n")
 	}
-	fmt.Fprintf(&b, "- Size: ~%d files, ~%d LOC, max dir depth %d\n", info.FileCount, info.LOCEstimate, info.MaxDepth)
+	b.WriteString(fmt.Sprintf("- Size: ~%d files, ~%d LOC, max dir depth %d\n", info.FileCount, info.LOCEstimate, info.MaxDepth))
 	if info.WorkspaceType != "" && info.WorkspaceType != "none" {
-		fmt.Fprintf(&b, "- Workspace: %s (%d packages)\n", info.WorkspaceType, info.WorkspacePackageCount)
+		b.WriteString(fmt.Sprintf("- Workspace: %s (%d packages)\n", info.WorkspaceType, info.WorkspacePackageCount))
 	}
 	if len(info.BuildTools) > 0 {
 		b.WriteString("- Build tools: " + strings.Join(info.BuildTools, ", ") + "\n")
@@ -149,9 +149,12 @@ func TestTerminateProcessKillsForkedChildren(t *testing.T) {

 	// The forked child must be gone too (poll until reaped by init).
 	deadline := time.Now().Add(2 * time.Second)
-	// Only ESRCH proves the child is gone; any other error (e.g. EPERM) would
-	// wrongly pass the test, so treat it as still-present and keep polling.
-	for !errors.Is(syscall.Kill(childPID, syscall.Signal(0)), syscall.ESRCH) {
+	for {
+		// Only ESRCH proves the child is gone; any other error (e.g. EPERM) would
+		// wrongly pass the test, so treat it as still-present and keep polling.
+		if errors.Is(syscall.Kill(childPID, syscall.Signal(0)), syscall.ESRCH) {
+			break // child no longer exists
+		}
 		if time.Now().After(deadline) {
 			_ = syscall.Kill(childPID, syscall.SIGKILL)
 			t.Fatalf("forked child %d survived terminateProcess — group kill failed", childPID)
@@ -27,8 +27,6 @@ Usage:
 Not meant to be run interactively — point your editor's ACP / external-agent
 setting at "zero acp".`

-var acpSignalContext = signalContext
-
 // runACP serves ACP over stdio so an editor can drive ZERO's agent core. It
 // speaks JSON-RPC 2.0 (newline-delimited JSON) on stdin/stdout; stderr stays free
 // for human-readable diagnostics. The session lifecycle maps onto ZERO's own
@@ -44,9 +42,7 @@ func runACP(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int
 		}
 	}

-	// The process's own stdin belongs exclusively to this Conn for the life of
-	// the command, so cancellation may close it to interrupt an idle read.
-	conn := acp.NewOwnedConn(deps.stdin, stdout)
+	conn := acp.NewConn(deps.stdin, stdout)
 	acp.NewAgent(conn, acp.Deps{
 		ResolveConfig: deps.resolveConfig,
 		DiscoverModels: func(ctx context.Context, profile config.ProviderProfile) ([]providermodeldiscovery.Model, error) {
@@ -77,9 +73,9 @@ func runACP(args []string, stdout io.Writer, stderr io.Writer, deps appDeps) int
 		AgentInfo:            acp.Implementation{Name: "zero", Version: version},
 	})

-	ctx, stop := acpSignalContext()
+	ctx, stop := signalContext()
 	defer stop()
-	if err := conn.Serve(ctx); err != nil {
+	if err := conn.Serve(ctx); err != nil && ctx.Err() == nil {
 		return writeAppError(stderr, "acp: "+err.Error(), exitCrash)
 	}
 	return exitSuccess
@@ -1,120 +0,0 @@
-package cli
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-type acpTestReader func([]byte) (int, error)
-
-func (r acpTestReader) Read(p []byte) (int, error) { return r(p) }
-
-type acpTestWriter func([]byte) (int, error)
-
-func (w acpTestWriter) Write(p []byte) (int, error) { return w(p) }
-
-func installACPTestContext(t *testing.T) context.CancelFunc {
-	t.Helper()
-	ctx, cancel := context.WithCancel(context.Background())
-	previous := acpSignalContext
-	acpSignalContext = func() (context.Context, context.CancelFunc) {
-		return ctx, cancel
-	}
-	t.Cleanup(func() {
-		cancel()
-		acpSignalContext = previous
-	})
-	return cancel
-}
-
-func TestRunACPCancellationPreservesTerminalReadError(t *testing.T) {
-	cancel := installACPTestContext(t)
-	wantErr := errors.New("transport read failed")
-	reader := acpTestReader(func(p []byte) (int, error) {
-		return copy(p, `{"jsonrpc":"1.0","id":1}`+"\n"), wantErr
-	})
-	writeStarted := make(chan struct{}, 1)
-	releaseWrite := make(chan struct{})
-	var stdout bytes.Buffer
-	writer := acpTestWriter(func(p []byte) (int, error) {
-		writeStarted <- struct{}{}
-		<-releaseWrite
-		return stdout.Write(p)
-	})
-	var stderr bytes.Buffer
-	done := make(chan int, 1)
-	go func() {
-		done <- runACP(nil, writer, &stderr, fillAppDeps(appDeps{stdin: reader}))
-	}()
-
-	select {
-	case <-writeStarted:
-	case <-time.After(time.Second):
-		t.Fatal("ACP did not reach the response write")
-	}
-	// Keep Serve in the synchronous write until cancellation is observable. The
-	// regression requires the genuine read error to win over that cancellation.
-	cancel()
-	close(releaseWrite)
-
-	select {
-	case code := <-done:
-		if code != exitCrash {
-			t.Fatalf("exit code = %d, want crash %d", code, exitCrash)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("ACP did not exit after terminal read error")
-	}
-	if got := stderr.String(); !strings.Contains(got, "acp: "+wantErr.Error()) {
-		t.Fatalf("stderr = %q, want terminal read error", got)
-	}
-}
-
-func TestRunACPIdleCancellationExitsCleanly(t *testing.T) {
-	cancel := installACPTestContext(t)
-	pipeReader, pipeWriter := io.Pipe()
-	t.Cleanup(func() { _ = pipeWriter.Close() })
-	readStarted := make(chan struct{}, 1)
-	reader := &acpNotifyingReadCloser{ReadCloser: pipeReader, readStarted: readStarted}
-	var stdout, stderr bytes.Buffer
-	done := make(chan int, 1)
-	go func() {
-		done <- runACP(nil, &stdout, &stderr, fillAppDeps(appDeps{stdin: reader}))
-	}()
-
-	select {
-	case <-readStarted:
-	case <-time.After(time.Second):
-		t.Fatal("ACP did not begin reading")
-	}
-	cancel()
-
-	select {
-	case code := <-done:
-		if code != exitSuccess {
-			t.Fatalf("exit code = %d, want success %d; stderr: %s", code, exitSuccess, stderr.String())
-		}
-	case <-time.After(time.Second):
-		t.Fatal("ACP did not exit after cancellation")
-	}
-	if stderr.Len() != 0 {
-		t.Fatalf("stderr = %q, want empty", stderr.String())
-	}
-}
-
-type acpNotifyingReadCloser struct {
-	io.ReadCloser
-	readStarted chan<- struct{}
-	once        sync.Once
-}
-
-func (r *acpNotifyingReadCloser) Read(p []byte) (int, error) {
-	r.once.Do(func() { r.readStarted <- struct{}{} })
-	return r.ReadCloser.Read(p)
-}
@@ -515,7 +515,9 @@ func agentEvalReportFromBenchmark(suite agenteval.Suite, report agenteval.Benchm
 		if task.Agent.Truncated {
 			converted.Truncated = true
 		}
-		converted.Failures = append(converted.Failures, agentEvalFailuresFromTaskReport(task)...)
+		for _, failure := range agentEvalFailuresFromTaskReport(task) {
+			converted.Failures = append(converted.Failures, failure)
+		}
 	}
 	return converted
 }
@@ -585,9 +585,6 @@ func fillAppDeps(deps appDeps) appDeps {
 	baseProbeProviderHealth := deps.probeProviderHealth
 	deps.probeProviderHealth = func(ctx context.Context, options providerhealth.Options) providerhealth.Result {
 		options.Profile = applyStoredProviderKeyAt(options.Profile, userConfigPath)
-		if options.OAuthResolver == nil {
-			options.OAuthResolver, _ = oauthLoginForProfile(options.Profile)
-		}
 		return baseProbeProviderHealth(ctx, options)
 	}
 	return deps
@@ -40,11 +40,10 @@ func runContext(args []string, stdout io.Writer, stderr io.Writer, deps appDeps)
 		return writeAppError(stderr, err.Error(), exitCrash)
 	}
 	report, err := contextreport.Build(contextreport.Options{
-		WorkspaceRoot:  workspaceRoot,
-		Provider:       resolved.Provider,
-		Registry:       newCoreRegistry(workspaceRoot),
-		ContextWindow:  modelContextWindow(modelRegistry, resolved.Provider.Model),
-		DeferThreshold: resolved.Tools.DeferThreshold,
+		WorkspaceRoot: workspaceRoot,
+		Provider:      resolved.Provider,
+		Registry:      newCoreRegistry(workspaceRoot),
+		ContextWindow: modelContextWindow(modelRegistry, resolved.Provider.Model),
 	})
 	if err != nil {
 		return writeAppError(stderr, err.Error(), exitCrash)
@@ -77,10 +77,11 @@ func TestRegisterToolSearchIfEligibleSkipsWhenThresholdZero(t *testing.T) {
 	}
 }

-func TestDeferredEligibleCountIncludesOptionalBuiltins(t *testing.T) {
+func TestDeferredEligibleCountIgnoresCoreTools(t *testing.T) {
 	registry := newCoreRegistry(t.TempDir())
-	if got := deferredEligibleCount(registry, agent.PermissionModeAuto, nil, nil); got < 3 {
-		t.Fatalf("deferredEligibleCount(core) = %d, want at least 3 optional built-ins", got)
+	// newCoreRegistry holds only built-ins; none implement Deferred().
+	if got := deferredEligibleCount(registry, agent.PermissionModeAuto, nil, nil); got != 0 {
+		t.Fatalf("deferredEligibleCount(core) = %d, want 0", got)
 	}
 }

@@ -139,7 +139,6 @@ func runSkillInfo(args []string, dir string, stdout io.Writer, stderr io.Writer)
 	}
 	if info.Hash != "" {
 		lines = append(lines, "  hash: "+info.Hash)
-		lines = append(lines, fmt.Sprintf("  hash drift: %t", info.HashDrift))
 	}
 	lines = append(lines, "  path: "+info.Skill.Path)
 	if _, err := fmt.Fprintln(stdout, redaction.RedactString(strings.Join(lines, "\n"), redaction.Options{})); err != nil {
@@ -83,48 +83,6 @@ func TestRunSkillAddInfoRemove(t *testing.T) {
 	if !strings.Contains(info, src) || !strings.Contains(info, "sha256:") {
 		t.Fatalf("info missing source/hash:\n%s", info)
 	}
-	if !strings.Contains(info, "hash drift: false") {
-		t.Fatalf("info missing hash drift status:\n%s", info)
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if exit := runWithDeps([]string{"skill", "info", "confirmation-policy", "--json"}, &stdout, &stderr, deps); exit != 0 {
-		t.Fatalf("skill info --json exit = %d, stderr = %s", exit, stderr.String())
-	}
-	var beforeJSON map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &beforeJSON); err != nil {
-		t.Fatalf("parse skill info json: %v\n%s", err, stdout.String())
-	}
-	if beforeJSON["hashDrift"] != false {
-		t.Fatalf("hashDrift before edit = %#v, want false", beforeJSON["hashDrift"])
-	}
-
-	skillPath := filepath.Join(skillsDir, "confirmation-policy", "SKILL.md")
-	if err := os.WriteFile(skillPath, []byte("---\ndescription: edited\n---\nchanged\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	stdout.Reset()
-	stderr.Reset()
-	if exit := runWithDeps([]string{"skill", "info", "confirmation-policy"}, &stdout, &stderr, deps); exit != 0 {
-		t.Fatalf("skill info after edit exit = %d, stderr = %s", exit, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), "hash drift: true") {
-		t.Fatalf("info missing hash drift after edit:\n%s", stdout.String())
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if exit := runWithDeps([]string{"skill", "info", "confirmation-policy", "--json"}, &stdout, &stderr, deps); exit != 0 {
-		t.Fatalf("skill info --json after edit exit = %d, stderr = %s", exit, stderr.String())
-	}
-	var afterJSON map[string]any
-	if err := json.Unmarshal(stdout.Bytes(), &afterJSON); err != nil {
-		t.Fatalf("parse skill info json after edit: %v\n%s", err, stdout.String())
-	}
-	if afterJSON["hashDrift"] != true {
-		t.Fatalf("hashDrift after edit = %#v, want true", afterJSON["hashDrift"])
-	}

 	// remove deletes it
 	stdout.Reset()
@@ -734,12 +734,14 @@ func (cfg *mcpWritableConfig) setServerDisabled(name string, disabled bool) (boo
 		switch {
 		case legacyFound:
 			raw = legacyRaw
+			found = true
 		case config.IsDefaultMCPServer(name):
 			// A built-in default server isn't written to the file until the user
 			// overrides it. Treat it as present with an empty base so disabling it
 			// writes a minimal {"disabled":true} entry that merges over the default —
 			// letting `zero mcp disable <default>` work even though it lives in code.
 			raw = nil
+			found = true
 		default:
 			return false, false, nil
 		}
@@ -5,8 +5,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
@@ -14,7 +12,6 @@ import (
 	"time"

 	"github.com/Gitlawb/zero/internal/config"
-	"github.com/Gitlawb/zero/internal/oauth"
 	"github.com/Gitlawb/zero/internal/providerhealth"
 	"github.com/Gitlawb/zero/internal/sessions"
 )
@@ -112,65 +109,6 @@ func TestRunDoctorConnectivityProbesProvider(t *testing.T) {
 	}
 }

-func TestRunDoctorConnectivityUsesOAuthLogin(t *testing.T) {
-	tokenPath := filepath.Join(t.TempDir(), "oauth-tokens.json")
-	t.Setenv("XDG_CONFIG_HOME", t.TempDir())
-	t.Setenv("ZERO_OAUTH_STORAGE", "file")
-	t.Setenv("ZERO_OAUTH_TOKENS_PATH", tokenPath)
-	store, err := oauth.NewStore(oauth.StoreOptions{FilePath: tokenPath})
-	if err != nil {
-		t.Fatalf("NewStore: %v", err)
-	}
-	if err := store.Save(oauth.ProviderKey("xai"), oauth.Token{
-		AccessToken: "oauth-doctor-token",
-		ExpiresAt:   time.Now().Add(time.Hour),
-	}); err != nil {
-		t.Fatalf("seed OAuth token: %v", err)
-	}
-
-	var gotAuth string
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotAuth = r.Header.Get("Authorization")
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"data":[]}`))
-	}))
-	defer server.Close()
-
-	profile := config.ProviderProfile{
-		Name:         "xai",
-		CatalogID:    "xai",
-		ProviderKind: config.ProviderKindOpenAICompatible,
-		BaseURL:      server.URL + "/v1",
-		Model:        "grok-4",
-	}
-	var stdout bytes.Buffer
-	var stderr bytes.Buffer
-	exitCode := runWithDeps([]string{"doctor", "--connectivity"}, &stdout, &stderr, appDeps{
-		getwd: func() (string, error) {
-			return t.TempDir(), nil
-		},
-		resolveConfig: func(string, config.Overrides) (config.ResolvedConfig, error) {
-			return config.ResolvedConfig{
-				Provider:       profile,
-				Providers:      []config.ProviderProfile{profile},
-				ActiveProvider: profile.Name,
-			}, nil
-		},
-		probeProviderHealth: providerhealth.Probe,
-		now:                 fixedCLITime("2026-07-29T20:00:00Z"),
-	})
-
-	if exitCode != exitSuccess {
-		t.Fatalf("doctor exit = %d, want success; stderr=%q\n%s", exitCode, stderr.String(), stdout.String())
-	}
-	if gotAuth != "Bearer oauth-doctor-token" {
-		t.Fatalf("Authorization = %q, want OAuth bearer", gotAuth)
-	}
-	if !strings.Contains(stdout.String(), "[pass] provider.connectivity") {
-		t.Fatalf("doctor did not report passing connectivity:\n%s", stdout.String())
-	}
-}
-
 func TestRunDoctorConnectivityReportsProviderHealthFailure(t *testing.T) {
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
@@ -19,7 +19,6 @@ func TestProviderCatalogRuntimeProvidersShowOnboardingSetupHints(t *testing.T) {
 		{id: "openai", name: "OpenAI", transport: "openai", defaultModel: "gpt-4.1"},
 		{id: "groq", name: "Groq", transport: "openai-compatible", defaultModel: "llama-3.3-70b-versatile"},
 		{id: "longcat", name: "LongCat", transport: "openai-compatible", defaultModel: "LongCat-2.0"},
-		{id: "fireworks", name: "Fireworks AI", transport: "openai-compatible", defaultModel: "accounts/fireworks/models/kimi-k2p7-code"},
 		{id: "ollama-cloud", name: "Ollama Cloud", transport: "openai-compatible", defaultModel: "qwen3-coder:480b"},
 		{id: "ollama", name: "Ollama Local", transport: "openai-compatible", defaultModel: "llama3.1"},
 	}
@@ -83,10 +83,10 @@ func runProvidersDetect(args []string, stdout io.Writer, stderr io.Writer, deps
 func parseProviderDetectArgs(args []string) (providerDetectOptions, bool, error) {
 	options := providerDetectOptions{}
 	for _, arg := range args {
-		switch arg {
-		case "-h", "--help", "help":
+		switch {
+		case arg == "-h" || arg == "--help" || arg == "help":
 			return options, true, nil
-		case "--json":
+		case arg == "--json":
 			options.json = true
 		default:
 			return options, false, execUsageError{fmt.Sprintf("unexpected argument %q", arg)}
@@ -244,19 +244,19 @@ func parseUsageArgs(args []string) (usageOptions, bool, error) {
 func FormatReport(report usage.Report, insertions int, deletions int) string {
 	var builder strings.Builder
 	builder.WriteString("Usage report (cost is a reconstructed estimate)\n\n")
-	fmt.Fprintf(&builder, "%-12s %10s %14s %14s\n", "date", "requests", "tokens", "est. cost")
+	builder.WriteString(fmt.Sprintf("%-12s %10s %14s %14s\n", "date", "requests", "tokens", "est. cost"))
 	for _, bucket := range report.Buckets {
-		fmt.Fprintf(&builder, "%-12s %10d %14s %14s\n",
-			bucket.Date, bucket.Requests, groupThousands(bucket.TotalTokens), formatUSD(bucket.TotalCost))
+		builder.WriteString(fmt.Sprintf("%-12s %10d %14s %14s\n",
+			bucket.Date, bucket.Requests, groupThousands(bucket.TotalTokens), formatUSD(bucket.TotalCost)))
 	}
-	fmt.Fprintf(&builder, "\n%-12s %10d %14s %14s\n",
-		"total", report.Total.Requests, groupThousands(report.Total.TotalTokens), formatUSD(report.Total.TotalCost))
+	builder.WriteString(fmt.Sprintf("\n%-12s %10d %14s %14s\n",
+		"total", report.Total.Requests, groupThousands(report.Total.TotalTokens), formatUSD(report.Total.TotalCost)))

-	fmt.Fprintf(&builder, "\nnet LOC (estimate): +%d / -%d = %d\n",
-		insertions, deletions, report.NetLOC)
+	builder.WriteString(fmt.Sprintf("\nnet LOC (estimate): +%d / -%d = %d\n",
+		insertions, deletions, report.NetLOC))
 	if report.NetLOCPositive {
-		fmt.Fprintf(&builder, "tokens per net LOC: %.1f\n", report.TokensPerNetLOC)
-		fmt.Fprintf(&builder, "est. cost per net LOC: %s\n", formatUSD(report.CostPerNetLOC))
+		builder.WriteString(fmt.Sprintf("tokens per net LOC: %.1f\n", report.TokensPerNetLOC))
+		builder.WriteString(fmt.Sprintf("est. cost per net LOC: %s\n", formatUSD(report.CostPerNetLOC)))
 	} else {
 		builder.WriteString("tokens per net LOC: n/a (net LOC <= 0)\n")
 		builder.WriteString("est. cost per net LOC: n/a (net LOC <= 0)\n")
@@ -8,7 +8,6 @@ import (
 	"os/exec"
 	"runtime"
 	"strings"
-	"sync"
 	"time"
 )

@@ -18,11 +17,7 @@ func LoadProviderCommand(command string) (FileConfig, error) {
 	stdout, stderr, err := runProviderCommand(command, providerCommandTimeout)
 	if err != nil {
 		if errors.Is(err, errProviderCommandTimeout) {
-			// Report which phase ran out of time, and anything the command
-			// managed to say. This used to be a bare string with the underlying
-			// error and stderr both dropped, which left a user whose command was
-			// slow on a cold machine with nothing to act on.
-			return FileConfig{}, fmt.Errorf("provider command timed out after %s: %w%s", providerCommandTimeout, err, commandOutput(stderr))
+			return FileConfig{}, fmt.Errorf("provider command timed out after 5s")
 		}
 		return FileConfig{}, fmt.Errorf("provider command failed: %w%s", err, commandOutput(stderr))
 	}
@@ -45,111 +40,20 @@ func LoadProviderCommand(command string) (FileConfig, error) {

 var errProviderCommandTimeout = errors.New("provider command timeout")

-// providerCommandDrainGrace bounds how long the timeout path waits for cmd.Wait
-// to return after the process tree has been terminated. Terminate normally makes
-// that immediate; this exists so a descendant that refuses to die cannot extend
-// a call whose deadline has already expired.
-const providerCommandDrainGrace = 2 * time.Second
-
-// syncBuffer serialises the command's I/O pump against reads from this package.
-// On the timeout path runProviderCommand can return while cmd.Wait is still
-// draining, so the buffers outlive the call and a plain bytes.Buffer would be
-// read and written concurrently.
-type syncBuffer struct {
-	mu  sync.Mutex
-	buf bytes.Buffer
-}
-
-func (b *syncBuffer) Write(p []byte) (int, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.Write(p)
-}
-
-// snapshot copies out what has been written so far. A copy rather than the
-// buffer's own slice, which the pump may still append to.
-func (b *syncBuffer) snapshot() []byte {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return append([]byte(nil), b.buf.Bytes()...)
-}
-
-// awaitWithGrace waits for done and gives up after grace, reporting whether the
-// wait completed rather than expired.
-//
-// Split out from the timeout path so the bound can be asserted on its own. In
-// place it is effectively untestable: Terminate kills the tree, so Wait returns
-// promptly and an unbounded receive would behave identically in every test that
-// is not pathological, which is exactly how the old unbounded receive survived.
-func awaitWithGrace(done <-chan error, grace time.Duration) bool {
-	timer := time.NewTimer(grace)
-	defer timer.Stop()
-	select {
-	case <-done:
-		return true
-	case <-timer.C:
-		return false
-	}
-}
-
-// runProviderCommand runs a provider command under a real deadline.
-//
-// "Real" is the point: timeout used to bound only the wait, so the call could
-// take arbitrarily longer than it. Two phases sat outside it. Starting the
-// process ran before the clock began, and on Windows that is CREATE_SUSPENDED,
-// job-object creation and assignment, and a system-wide thread snapshot, none of
-// which is fast on a cold or contended machine. Draining after termination was
-// unbounded as well. Both are inside the budget now, so the deadline is an upper
-// bound rather than a floor.
 func runProviderCommand(command string, timeout time.Duration) ([]byte, []byte, error) {
 	cmd := shellCommand(command)
 	// Bound the time Wait spends draining I/O pipes after the process exits,
 	// in case an orphaned descendant still holds the write ends open.
 	cmd.WaitDelay = time.Second

-	stdout := &syncBuffer{}
-	stderr := &syncBuffer{}
-	cmd.Stdout = stdout
-	cmd.Stderr = stderr
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr

-	// Armed before the process is started, so process creation is inside the
-	// budget rather than ahead of it.
-	deadline := time.NewTimer(timeout)
-	defer deadline.Stop()
-
-	type startResult struct {
-		proc *commandProcess
-		err  error
-	}
-	// Buffered, so the goroutine can finish and exit even when nobody is left
-	// waiting on it because the deadline already fired.
-	started := make(chan startResult, 1)
-	go func() {
-		proc, err := startCommandProcess(cmd)
-		started <- startResult{proc: proc, err: err}
-	}()
-
-	var proc *commandProcess
-	select {
-	case result := <-started:
-		if result.err != nil {
-			return stdout.snapshot(), stderr.snapshot(), result.err
-		}
-		proc = result.proc
-	case <-deadline.C:
-		// The start is still in flight and will eventually hand back whatever it
-		// created, so cleanup is handed off rather than abandoned. Wait reaps the
-		// process; without it a started-but-orphaned command becomes a zombie.
-		go func() {
-			result := <-started
-			if result.err != nil {
-				return
-			}
-			result.proc.Terminate()
-			_ = cmd.Wait()
-			result.proc.Close()
-		}()
-		return stdout.snapshot(), stderr.snapshot(), fmt.Errorf("%w: starting the command exceeded %s", errProviderCommandTimeout, timeout)
+	proc, err := startCommandProcess(cmd)
+	if err != nil {
+		return nil, nil, err
 	}
 	defer proc.Close()

@@ -158,6 +62,9 @@ func runProviderCommand(command string, timeout time.Duration) ([]byte, []byte,
 		done <- cmd.Wait()
 	}()

+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+
 	select {
 	case err := <-done:
 		if err != nil {
@@ -170,25 +77,13 @@ func runProviderCommand(command string, timeout time.Duration) ([]byte, []byte,
 			proc.Terminate()
 		}
 		if errors.Is(err, exec.ErrWaitDelay) {
-			// Wrap rather than replace. A descendant holding the inherited pipes
-			// open and the command never finishing at all are different failures
-			// that both collapsed into the same bare sentinel, which left callers
-			// and tests unable to tell which one happened. Callers that only ask
-			// errors.Is(err, errProviderCommandTimeout) are unaffected, so the
-			// message LoadProviderCommand reports is unchanged.
-			return stdout.snapshot(), stderr.snapshot(), fmt.Errorf("%w: %w", errProviderCommandTimeout, err)
+			return stdout.Bytes(), stderr.Bytes(), errProviderCommandTimeout
 		}
-		return stdout.snapshot(), stderr.snapshot(), err
-	case <-deadline.C:
+		return stdout.Bytes(), stderr.Bytes(), err
+	case <-timer.C:
 		proc.Terminate()
-		// Bounded, unlike the bare receive this replaces. Terminate kills the
-		// tree so Wait almost always returns at once, but "almost always" was
-		// doing real work here: a tree that resists termination used to hold the
-		// call open indefinitely, long past the deadline that had just expired.
-		// Returning early leaves cmd.Wait running, which is why the buffers are
-		// synchronised.
-		awaitWithGrace(done, providerCommandDrainGrace)
-		return stdout.snapshot(), stderr.snapshot(), fmt.Errorf("%w: the command did not finish within %s", errProviderCommandTimeout, timeout)
+		<-done
+		return stdout.Bytes(), stderr.Bytes(), errProviderCommandTimeout
 	}
 }

@@ -3,7 +3,6 @@ package config
 import (
 	"errors"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strconv"
@@ -92,29 +91,6 @@ func TestLoadProviderCommandTimeout(t *testing.T) {
 	assertProcessTerminatedIfStarted(t, pidFile)
 }

-// providerCommandTestBudget bounds the two background-child tests below, and is
-// deliberately NOT providerCommandTimeout. Those tests assert which error each
-// cmd.Wait path yields and that the leftover descendant is killed; neither is a
-// claim about how fast Windows can start a process. Driving them through
-// LoadProviderCommand billed the fixture's own startup to the production 5s
-// budget, so on a loaded runner the outer timer won the select in
-// runProviderCommand: the nonzero-exit test saw a timeout instead of the exit
-// status it asserts, and the timer's Terminate killed the background child
-// before it recorded its PID, putting the PID file permanently out of reach no
-// matter how long the assertion polled for it.
-//
-// This is a hang-breaker, not a tuned margin. Nothing in a healthy run waits on
-// it, since both tests return about one WaitDelay after the fixture exits.
-const providerCommandTestBudget = 60 * time.Second
-
-// backgroundChildLifetime must exceed providerCommandTestBudget so that a child
-// dying of old age is unobservable: any run where runProviderCommand has not
-// returned yet trips the budget first. That is what lets both tests drop their
-// old elapsed-versus-lifetime bounds. "Still alive when the call returned" is
-// now true by construction, so a child found dead afterwards can only have been
-// killed by proc.Terminate.
-const backgroundChildLifetime = 120 * time.Second
-
 // TestLoadProviderCommandTerminatesBackgroundChild covers a command that
 // exits immediately but leaves a detached child holding the inherited
 // stdout/stderr pipes open (e.g. `sleep 600 & exit`). cmd.Wait() only
@@ -122,22 +98,24 @@ const backgroundChildLifetime = 120 * time.Second
 // leftover child instead of just returning and leaking it.
 func TestLoadProviderCommandTerminatesBackgroundChild(t *testing.T) {
 	pidFile := filepath.Join(t.TempDir(), "bg.pid")
+	childLifetime := 10 * time.Second
 	command := writeCommand(t, commandScript{
 		Stdout:                 `{"name":"cmd","provider":"openai","apiKey":"sk-command","model":"gpt-command"}`,
-		BackgroundSleepSeconds: int(backgroundChildLifetime / time.Second),
+		BackgroundSleepSeconds: int(childLifetime / time.Second),
 		BackgroundPidFile:      pidFile,
 	})

-	_, _, err := runProviderCommand(command, providerCommandTestBudget)
+	start := time.Now()
+	_, err := LoadProviderCommand(command)
+	elapsed := time.Since(start)
 	if err == nil {
-		t.Fatal("runProviderCommand() error = nil, want error from WaitDelay-bounded wait")
+		t.Fatal("LoadProviderCommand() error = nil, want error from WaitDelay-bounded wait")
 	}
-	// Name the exact path. The outer-timer path reports the bare sentinel, so
-	// matching only that, or the "timed out after 5s" text this test used to
-	// match, would also be satisfied by a slow runner taking precisely the path
-	// this test exists to rule out.
-	if !errors.Is(err, errProviderCommandTimeout) || !errors.Is(err, exec.ErrWaitDelay) {
-		t.Fatalf("error = %v, want errProviderCommandTimeout wrapping exec.ErrWaitDelay", err)
+	if !strings.Contains(err.Error(), "timed out after 5s") {
+		t.Fatalf("error = %q, want timeout", err.Error())
+	}
+	if elapsed >= childLifetime {
+		t.Fatalf("returned after %s, want before the background child finishes naturally after %s", elapsed, childLifetime)
 	}
 	assertProcessTerminated(t, pidFile)
 }
@@ -150,25 +128,25 @@ func TestLoadProviderCommandTerminatesBackgroundChild(t *testing.T) {
 // be terminated on that path.
 func TestLoadProviderCommandTerminatesBackgroundChildOnFailure(t *testing.T) {
 	pidFile := filepath.Join(t.TempDir(), "bg-fail.pid")
+	childLifetime := 10 * time.Second
 	command := writeCommand(t, commandScript{
 		Stderr:                 "boom",
 		ExitCode:               7,
-		BackgroundSleepSeconds: int(backgroundChildLifetime / time.Second),
+		BackgroundSleepSeconds: int(childLifetime / time.Second),
 		BackgroundPidFile:      pidFile,
 	})

-	_, _, err := runProviderCommand(command, providerCommandTestBudget)
-	// The shell's own exit status has to survive. A timeout here means the
-	// budget swallowed it, which is exactly what this test kept reporting on CI.
-	if errors.Is(err, errProviderCommandTimeout) {
-		t.Fatalf("error = %v, want the shell's exit status rather than a timeout", err)
+	start := time.Now()
+	_, err := LoadProviderCommand(command)
+	elapsed := time.Since(start)
+	if err == nil {
+		t.Fatal("LoadProviderCommand() error = nil, want failure from nonzero exit")
 	}
-	var exitErr *exec.ExitError
-	if !errors.As(err, &exitErr) {
-		t.Fatalf("error = %v, want *exec.ExitError from the nonzero exit", err)
+	if !strings.Contains(err.Error(), "exit status") {
+		t.Fatalf("error = %q, want exit status failure", err.Error())
 	}
-	if exitErr.ExitCode() != 7 {
-		t.Fatalf("exit code = %d, want 7", exitErr.ExitCode())
+	if elapsed >= childLifetime {
+		t.Fatalf("returned after %s, want before the background child finishes naturally after %s", elapsed, childLifetime)
 	}
 	assertProcessTerminated(t, pidFile)
 }
@@ -327,33 +305,8 @@ func writeCommand(t *testing.T, script commandScript) string {
 				"Set-Content -LiteralPath '" + psSingleQuote(readyFile) + "' -Value ready -Encoding Ascii; " +
 				"Start-Sleep -Seconds " + itoa(script.BackgroundSleepSeconds)
 			lines = append(lines, "start /B powershell -NoProfile -Command \""+bgSleep+"\"")
-			// Wait for the child to record its PID before exiting, so the PID is
-			// on disk while the tree is still alive: runProviderCommand kills the
-			// tree one WaitDelay after the script exits, and a child that has not
-			// written by then never will.
-			//
-			// This waits in cmd itself. Spawning a second PowerShell just to poll
-			// cost another interpreter cold start, and that start is pure overhead
-			// added AFTER the PID is already written. On a loaded runner it pushed
-			// the script's exit past the 5s provider-command timeout, so the
-			// nonzero-exit test saw a timeout instead of the exit status it
-			// asserts. The wait is also bounded now: giving up and letting the PID
-			// assertion fail is far more diagnosable than blocking until the
-			// timeout fires and reporting an unrelated error. Each iteration is
-			// about a second, since `ping -n 2` sleeps between its two echoes,
-			// so the ceiling is roughly 15s: far longer than any cold PowerShell
-			// start seen on a runner, and far shorter than
-			// providerCommandTestBudget, so giving up surfaces a legible
-			// PID-file failure rather than a timeout that hides the real cause.
-			lines = append(lines,
-				":zeroWaitReady",
-				"if exist \""+readyFile+"\" goto zeroReady",
-				"set /a ZERO_READY_TRIES+=1",
-				"if %ZERO_READY_TRIES% GEQ 15 goto zeroReady",
-				"ping -n 2 127.0.0.1 >nul",
-				"goto zeroWaitReady",
-				":zeroReady",
-			)
+			waitForReady := "while (-not (Test-Path -LiteralPath '" + psSingleQuote(readyFile) + "')) { Start-Sleep -Milliseconds 10 }"
+			lines = append(lines, "powershell -NoProfile -Command \""+waitForReady+"\"")
 		}
 		lines = append(lines, "exit /b "+itoa(script.ExitCode))
 		if err := os.WriteFile(path, []byte(strings.Join(lines, "\r\n")), 0o700); err != nil {
@@ -414,133 +367,3 @@ func itoa(value int) string {
 	}
 	return string(digits[index:])
 }
-
-// The whole point of #811: providerCommandTimeout has to be an upper bound on
-// how long the call takes, not a floor. Process creation used to run before the
-// clock started and the post-termination drain was unbounded, so a slow or
-// contended machine could block startup for far longer than the error text
-// promised.
-//
-// This one guards the end-to-end contract against gross regressions. It is NOT
-// the assertion that pins the drain bound: Terminate kills the tree, so Wait
-// returns promptly and this passes even with the drain unbounded. That property
-// is pinned by TestAwaitWithGraceGivesUp, and the start-phase bound by
-// TestRunProviderCommandCountsProcessStartAgainstTheDeadline.
-func TestRunProviderCommandBoundsTotalDuration(t *testing.T) {
-	pidFile := filepath.Join(t.TempDir(), "bound.pid")
-	command := writeCommand(t, commandScript{SleepSeconds: 60, PidFile: pidFile})
-
-	const budget = 2 * time.Second
-	start := time.Now()
-	_, _, err := runProviderCommand(command, budget)
-	elapsed := time.Since(start)
-
-	if !errors.Is(err, errProviderCommandTimeout) {
-		t.Fatalf("error = %v, want the timeout sentinel", err)
-	}
-	// Budget, plus the bounded drain, plus room for a loaded runner. A failure
-	// here means some phase is outside the deadline again, which is the bug.
-	ceiling := budget + providerCommandDrainGrace + 8*time.Second
-	if elapsed > ceiling {
-		t.Fatalf("returned after %s with a %s budget; the timeout is not bounding the call (ceiling %s)", elapsed, budget, ceiling)
-	}
-	assertProcessTerminatedIfStarted(t, pidFile)
-}
-
-// The timeout error has to carry something an operator can act on. It used to be
-// a bare string with the underlying error and the command's stderr both dropped,
-// so a user whose provider command was slow got no clue which phase ran out or
-// what the command had said.
-func TestLoadProviderCommandTimeoutReportsDiagnostics(t *testing.T) {
-	command := writeCommand(t, commandScript{
-		Stderr:       "provider is warming up",
-		SleepSeconds: 30,
-		PidFile:      filepath.Join(t.TempDir(), "diag.pid"),
-	})
-
-	_, err := LoadProviderCommand(command)
-	if err == nil {
-		t.Fatal("LoadProviderCommand() error = nil, want timeout")
-	}
-	if !strings.Contains(err.Error(), "timed out") {
-		t.Fatalf("error = %q, want a timeout message", err.Error())
-	}
-	// Wrapped, so callers can still classify it.
-	if !errors.Is(err, errProviderCommandTimeout) {
-		t.Fatalf("error = %v, want errors.Is against the timeout sentinel", err)
-	}
-	// And it must say which phase, rather than only that time ran out.
-	if !strings.Contains(err.Error(), "did not finish") && !strings.Contains(err.Error(), "starting the command") {
-		t.Fatalf("error = %q, want it to name the phase that exceeded the deadline", err.Error())
-	}
-}
-
-// The output buffers are written by cmd.Wait's I/O pump, which keeps running
-// after the timeout path has returned them to the caller, so a plain
-// bytes.Buffer would be read and written concurrently. Asserted on the buffer
-// directly: driving it end to end does not reliably produce the overlap, because
-// a terminated command usually stops writing before the snapshot is taken, so
-// such a test passes with the locking removed and proves nothing.
-//
-// Only meaningful under -race, which CI runs.
-func TestSyncBufferAllowsConcurrentWriteAndSnapshot(t *testing.T) {
-	buffer := &syncBuffer{}
-	writing := make(chan struct{})
-	go func() {
-		defer close(writing)
-		for i := 0; i < 2000; i++ {
-			_, _ = buffer.Write([]byte("x"))
-		}
-	}()
-	for i := 0; i < 2000; i++ {
-		_ = buffer.snapshot()
-	}
-	<-writing
-	if len(buffer.snapshot()) != 2000 {
-		t.Fatalf("buffer holds %d bytes, want 2000", len(buffer.snapshot()))
-	}
-}
-
-// The drain after termination must be bounded. Asserted directly on the helper,
-// because in place it is untestable without a tree that refuses to die: Wait
-// normally returns at once, which is precisely why an unbounded receive sat
-// there unnoticed. A channel that never fires is the pathological case made
-// cheap.
-func TestAwaitWithGraceGivesUp(t *testing.T) {
-	never := make(chan error)
-	start := time.Now()
-	if awaitWithGrace(never, 50*time.Millisecond) {
-		t.Fatal("reported completion for a wait that never finished")
-	}
-	if elapsed := time.Since(start); elapsed > 5*time.Second {
-		t.Fatalf("gave up after %s, want roughly the grace period", elapsed)
-	}
-	// Still reports completion when the wait does finish, or the timeout path
-	// would always claim the tree hung.
-	done := make(chan error, 1)
-	done <- nil
-	if !awaitWithGrace(done, time.Second) {
-		t.Fatal("reported expiry for a wait that had already finished")
-	}
-}
-
-// Process creation has to be inside the budget. It used to run before the clock
-// started, and on Windows that phase is CREATE_SUSPENDED plus job-object setup
-// plus a system-wide thread snapshot, none of it fast on a contended machine.
-//
-// A budget that is already spent when the call begins can only be exceeded
-// during the start, so the phase named in the error is what distinguishes the
-// two orderings: with the clock started afterwards, the start would always
-// complete first and the failure would come from the wait instead.
-func TestRunProviderCommandCountsProcessStartAgainstTheDeadline(t *testing.T) {
-	command := writeCommand(t, commandScript{Stdout: `{"name":"cmd","provider":"openai","apiKey":"sk-x","model":"m"}`})
-
-	_, _, err := runProviderCommand(command, time.Nanosecond)
-	if !errors.Is(err, errProviderCommandTimeout) {
-		t.Fatalf("error = %v, want the timeout sentinel", err)
-	}
-	if !strings.Contains(err.Error(), "starting the command") {
-		t.Fatalf("error = %q, want the start phase to be the one that exceeded the deadline; "+
-			"anything else means process creation is outside the budget again", err.Error())
-	}
-}
@@ -87,7 +87,7 @@ func mergeMCPServer(base MCPServerConfig, next MCPServerConfig, canReenable bool
 		// server the user explicitly enabled. The only layer allowed to
 		// override an explicit higher-scope decision is the CLI override scope
 		// (canReenable=true).
-		if canReenable || !baseDisabledSet || baseDisabled == next.Disabled {
+		if canReenable || !(baseDisabledSet && baseDisabled != next.Disabled) {
 			base.Disabled = next.Disabled
 		}
 	}
@@ -113,7 +113,7 @@ type PreferencesConfig struct {
 	// ZERO_THEME, so a /theme choice survives restart. Empty = unset (defaults auto).
 	Theme string `json:"theme,omitempty"`
 	// Recaps is a tri-state: nil (unset) defaults to ON; an explicit false means
-	// the user turned idle recaps off. A *bool is its own tri-state, so no
+	// the user turned post-turn recaps off. A *bool is its own tri-state, so no
 	// custom unmarshal is needed (unlike ToolsConfig.DeferThreshold's int).
 	Recaps *bool `json:"recaps,omitempty"`
 }
@@ -130,7 +130,7 @@ type RecentModelEntry struct {
 // MaxRecentModels caps the persisted/displayed recent-selection history.
 const MaxRecentModels = 5

-// RecapsEnabled reports whether idle recaps are on. Unset defaults to ON.
+// RecapsEnabled reports whether post-turn recaps are on. Unset defaults to ON.
 func (p PreferencesConfig) RecapsEnabled() bool {
 	return p.Recaps == nil || *p.Recaps
 }
@@ -546,7 +546,7 @@ func SetRecentModels(path string, entries []RecentModelEntry) (FileConfig, error
 	return cfg, nil
 }

-// SetRecapsEnabled persists the idle recap preference, mirroring
+// SetRecapsEnabled persists the post-turn recap preference, mirroring
 // SetFavoriteModels (read-modify-atomic-write).
 func SetRecapsEnabled(path string, enabled bool) (FileConfig, error) {
 	path = strings.TrimSpace(path)
@@ -40,7 +40,6 @@ type Options struct {
 	Provider            config.ProviderProfile
 	Registry            *tools.Registry
 	ContextWindow       int
-	DeferThreshold      int
 	ProjectContextFiles []string
 }

@@ -57,8 +56,6 @@ type Report struct {
 	FreeTokens           int        `json:"freeTokens"`
 	UsedFraction         float64    `json:"usedFraction"`
 	ToolCount            int        `json:"toolCount"`
-	AvailableToolCount   int        `json:"availableToolCount,omitempty"`
-	DeferredToolCount    int        `json:"deferredToolCount,omitempty"`
 	ProjectGuidelineFile string     `json:"projectGuidelineFile,omitempty"`
 	Categories           []Category `json:"categories"`
 }
@@ -116,10 +113,8 @@ func Build(options Options) (Report, error) {
 		categories = append(categories, category(CategoryWorkspaceMap, "Workspace map", estimateTextTokens(workspaceMap), report.ContextWindow))
 	}

-	toolCount, availableTools, deferredTools, toolTokens := estimateRegistryTools(options.Registry, options.DeferThreshold)
+	toolCount, toolTokens := estimateRegistryTools(options.Registry)
 	report.ToolCount = toolCount
-	report.AvailableToolCount = availableTools
-	report.DeferredToolCount = deferredTools
 	if toolTokens > 0 {
 		categories = append(categories, category(CategoryTools, "Tools", toolTokens, report.ContextWindow))
 	}
@@ -180,11 +175,7 @@ func Format(report Report) string {
 		lines = append(lines, fmt.Sprintf("usage: %s tokens (context window unknown)", compactNumber(report.UsedTokens)))
 	}
 	if report.ToolCount > 0 {
-		toolLine := fmt.Sprintf("tools: %d exposed", report.ToolCount)
-		if report.AvailableToolCount > report.ToolCount {
-			toolLine += fmt.Sprintf(", %d available, %d deferred", report.AvailableToolCount, report.DeferredToolCount)
-		}
-		lines = append(lines, toolLine)
+		lines = append(lines, fmt.Sprintf("tools: %d", report.ToolCount))
 	}
 	if report.ProjectGuidelineFile != "" {
 		lines = append(lines, "project_guidelines: "+report.ProjectGuidelineFile)
@@ -221,51 +212,29 @@ func category(key string, name string, tokens int, contextWindow int) Category {
 	return cat
 }

-func estimateRegistryTools(registry *tools.Registry, deferThreshold int) (int, int, int, int) {
+func estimateRegistryTools(registry *tools.Registry) (int, int) {
 	if registry == nil {
-		return 0, 0, 0, 0
+		return 0, 0
 	}
 	all := registry.All()
 	sort.Slice(all, func(left int, right int) bool {
 		return all[left].Name() < all[right].Name()
 	})
-	var visible []tools.Tool
-	var deferred []tools.Tool
+	total := 0
+	count := 0
 	for _, tool := range all {
 		if tool.Safety().Permission == tools.PermissionDeny {
 			continue
 		}
-		visible = append(visible, tool)
-		if tools.IsDeferred(tool) {
-			deferred = append(deferred, tool)
-		}
-	}
-	active := deferThreshold > 0 && len(deferred) >= deferThreshold
-	exposed := visible
-	if active {
-		exposed = make([]tools.Tool, 0, len(visible)-len(deferred)+1)
-		for _, tool := range visible {
-			if !tools.IsDeferred(tool) && tool.Name() != tools.ToolSearchToolName {
-				exposed = append(exposed, tool)
-			}
-		}
-		exposed = append(exposed, tools.NewToolSearchTool(registry))
-	}
-
-	total := 0
-	for _, tool := range exposed {
+		count++
 		total += estimateTextTokens(tool.Name())
-		description := tool.Description()
-		if active && tool.Name() == tools.ToolSearchToolName {
-			description = tools.BuildToolSearchDescription(deferred)
-		}
-		total += estimateTextTokens(description)
+		total += estimateTextTokens(tool.Description())
 		if encoded, err := json.Marshal(tool.Parameters()); err == nil {
 			total += estimateTextTokens(string(encoded))
 		}
 		total += toolDefinitionOverheadTokens
 	}
-	return len(exposed), len(visible), len(deferred), total
+	return count, total
 }

 func readProjectGuidelines(root string, names []string) (string, string) {
@@ -130,35 +130,6 @@ func TestBuildHasStableJSONContractAndCategoryMath(t *testing.T) {
 	}
 }

-func TestBuildReportsInitialDeferredToolSurface(t *testing.T) {
-	root := t.TempDir()
-	registry := tools.NewRegistry()
-	for _, tool := range tools.CoreToolsScoped(root, nil) {
-		registry.Register(tool)
-	}
-
-	eager, err := Build(Options{WorkspaceRoot: root, Registry: registry})
-	if err != nil {
-		t.Fatal(err)
-	}
-	deferred, err := Build(Options{WorkspaceRoot: root, Registry: registry, DeferThreshold: 3})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if deferred.DeferredToolCount < 3 {
-		t.Fatalf("DeferredToolCount = %d, want at least 3", deferred.DeferredToolCount)
-	}
-	if deferred.AvailableToolCount != eager.ToolCount {
-		t.Fatalf("available tools = %d, want eager total %d", deferred.AvailableToolCount, eager.ToolCount)
-	}
-	if deferred.ToolCount >= deferred.AvailableToolCount {
-		t.Fatalf("initial exposed tools = %d, available = %d; expected a smaller initial surface", deferred.ToolCount, deferred.AvailableToolCount)
-	}
-	if categoryByKey(deferred, CategoryTools).Tokens >= categoryByKey(eager, CategoryTools).Tokens {
-		t.Fatalf("deferred tool schemas did not reduce the initial context")
-	}
-}
-
 func TestBuildClampsFreeBudgetWhenOverContextWindow(t *testing.T) {
 	root := t.TempDir()
 	writeTestFile(t, root, "AGENTS.md", strings.Repeat("very large project rule\n", 1000))
@@ -100,7 +100,7 @@ func (d *deepgramTranscriber) StreamTranscribe(ctx context.Context, chunks <-cha
 				}
 			default:
 			}
-			return compose(), fmt.Errorf("Deepgram stream error: %w", err) //nolint:staticcheck // Preserve established user-facing error text.
+			return compose(), fmt.Errorf("Deepgram stream error: %w", err)
 		}
 		if typ != websocket.MessageText {
 			continue
@@ -2,7 +2,6 @@ package imageinput

 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"net/http"
 	"os"
@@ -17,13 +16,6 @@ import (
 // clipboard, or (nil, "", nil) when the clipboard has no image. Called when
 // text clipboard is empty (the user pasted a screenshot). The media type is
 // sniffed from the bytes, not trusted from the clipboard.
-// ErrClipboardImageUnreadable reports that the clipboard holds an image the host
-// has no way to extract. It is deliberately distinct from "no image on the
-// clipboard", which is an ordinary no-op: this one is actionable, and silence is
-// the wrong response to it.
-var ErrClipboardImageUnreadable = errors.New(
-	"the clipboard holds an image but no helper on this host can read it; on macOS install pngpaste (brew install pngpaste) or a Python with pyobjc")
-
 func ReadClipboardImage() ([]byte, string, error) {
 	data, err := readClipboardImageBytes()
 	if err != nil {
@@ -103,71 +95,35 @@ func readClipboardImageWindows() ([]byte, error) {

 // readClipboardImageDarwin uses osascript to check for and read a clipboard
 // image. Returns (nil, nil) when no image is present.
-// darwinClipboardInfo reports what the pasteboard is currently offering, and
-// darwinClipboardExtract pulls the PNG bytes out of it.
-//
-// Both are vars so the two-step logic below can be driven in a test. The step
-// that matters, "the clipboard holds an image and nothing here can extract it",
-// only happens when the first succeeds and the second fails, which cannot be
-// arranged by stubbing the caller: a test that substitutes ReadClipboardImage
-// asserts the plumbing around this function rather than the decision inside it,
-// and stays green with that decision reverted.
-var (
-	darwinClipboardInfo = func() (string, error) {
-		out, err := exec.Command("sh", "-c", `osascript -e 'clipboard info'`).Output()
-		return string(out), err
+func readClipboardImageDarwin() ([]byte, error) {
+	// Check clipboard info for image classes.
+	check := `osascript -e 'clipboard info'`
+	out, err := exec.Command("sh", "-c", check).Output()
+	if err != nil {
+		return nil, nil
 	}
-	darwinClipboardExtract = func() ([]byte, error) {
-		// pngpaste if available, falling back to a Python one-liner. Neither
-		// ships with macOS: pngpaste is Homebrew-only and Apple dropped the
-		// bundled PyObjC, so a stock Mac fails here every time.
-		cmd := exec.Command("sh", "-c", `pngpaste - 2>/dev/null || python3 -c "
+	info := string(out)
+	if !strings.Contains(info, "PNG") && !strings.Contains(info, "JPEG") && !strings.Contains(info, "TIFF") && !strings.Contains(info, "GIF") {
+		return nil, nil
+	}
+	// Write clipboard image to a temp file via AppleScript, then read it.
+	// Using pngpaste if available, falling back to a Python one-liner.
+	cmd := exec.Command("sh", "-c", `pngpaste - 2>/dev/null || python3 -c "
 import AppKit, sys
 pb = AppKit.NSPasteboard.generalPasteboard()
 data = pb.dataForType_(AppKit.NSPasteboardTypePNG)
 if data:
    sys.stdout.buffer.write(data.bytes())
 "`)
-		var stdout bytes.Buffer
-		cmd.Stdout = &stdout
-		if err := cmd.Run(); err != nil {
-			return nil, err
-		}
-		return stdout.Bytes(), nil
-	}
-)
-
-// darwinClipboardOffersImage reports whether the pasteboard info line names an
-// image class.
-func darwinClipboardOffersImage(info string) bool {
-	for _, class := range []string{"PNG", "JPEG", "TIFF", "GIF"} {
-		if strings.Contains(info, class) {
-			return true
-		}
-	}
-	return false
-}
-
-func readClipboardImageDarwin() ([]byte, error) {
-	info, err := darwinClipboardInfo()
-	if err != nil {
+	var stdout bytes.Buffer
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
 		return nil, nil
 	}
-	if !darwinClipboardOffersImage(info) {
+	if stdout.Len() == 0 {
 		return nil, nil
 	}
-	// Past this point the clipboard is KNOWN to hold an image, because the probe
-	// above said so. A failure here is therefore not "no image", it is "there is
-	// an image and nothing on this host can extract it". Reporting that as
-	// absence is what left users staring at a paste that silently did nothing.
-	data, err := darwinClipboardExtract()
-	if err != nil {
-		return nil, ErrClipboardImageUnreadable
-	}
-	if len(data) == 0 {
-		return nil, ErrClipboardImageUnreadable
-	}
-	return data, nil
+	return stdout.Bytes(), nil
 }

 // readClipboardImageLinux tries wl-paste (Wayland) then xclip (X11) to read
@@ -1,84 +0,0 @@
-package imageinput
-
-import (
-	"errors"
-	"testing"
-)
-
-// Drives readClipboardImageDarwin's own decision rather than the plumbing around
-// it. Both shell steps are substituted, so this runs on any platform and, more
-// importantly, actually reaches the branch under test: a test that stubs
-// ReadClipboardImage instead stays green with the production change reverted,
-// which is how the first version of this coverage slipped through.
-func TestReadClipboardImageDarwinDistinguishesUnreadableFromAbsent(t *testing.T) {
-	restore := func() func() {
-		info, extract := darwinClipboardInfo, darwinClipboardExtract
-		return func() { darwinClipboardInfo, darwinClipboardExtract = info, extract }
-	}()
-	t.Cleanup(restore)
-
-	const pngInfo = `«class PNGf», «class 8BPS»`
-
-	t.Run("image present but no extractor is actionable", func(t *testing.T) {
-		darwinClipboardInfo = func() (string, error) { return pngInfo, nil }
-		darwinClipboardExtract = func() ([]byte, error) { return nil, errors.New("exit status 127") }
-
-		data, err := readClipboardImageDarwin()
-		if !errors.Is(err, ErrClipboardImageUnreadable) {
-			t.Fatalf("err = %v, want ErrClipboardImageUnreadable; a stock Mac gets silence instead of a remedy", err)
-		}
-		if data != nil {
-			t.Fatalf("data = %q, want none", data)
-		}
-	})
-
-	t.Run("extractor producing nothing is also actionable", func(t *testing.T) {
-		darwinClipboardInfo = func() (string, error) { return pngInfo, nil }
-		darwinClipboardExtract = func() ([]byte, error) { return nil, nil }
-
-		if _, err := readClipboardImageDarwin(); !errors.Is(err, ErrClipboardImageUnreadable) {
-			t.Fatalf("err = %v, want ErrClipboardImageUnreadable for an extractor that exits 0 with no bytes", err)
-		}
-	})
-
-	// The other half of the distinction, and the reason this cannot simply always
-	// report an error: an empty clipboard is an ordinary no-op, and turning that
-	// into a notice would make every stray Ctrl+V nag the user.
-	t.Run("no image on the clipboard stays silent", func(t *testing.T) {
-		darwinClipboardInfo = func() (string, error) { return `«class utf8»`, nil }
-		darwinClipboardExtract = func() ([]byte, error) {
-			t.Fatal("extractor ran despite the clipboard offering no image")
-			return nil, nil
-		}
-
-		data, err := readClipboardImageDarwin()
-		if err != nil || data != nil {
-			t.Fatalf("data=%q err=%v, want a silent no-op", data, err)
-		}
-	})
-
-	t.Run("probe failure stays silent", func(t *testing.T) {
-		darwinClipboardInfo = func() (string, error) { return "", errors.New("osascript missing") }
-		darwinClipboardExtract = func() ([]byte, error) {
-			t.Fatal("extractor ran despite the info probe failing")
-			return nil, nil
-		}
-
-		if data, err := readClipboardImageDarwin(); err != nil || data != nil {
-			t.Fatalf("data=%q err=%v, want a silent no-op", data, err)
-		}
-	})
-
-	t.Run("working extractor returns the bytes", func(t *testing.T) {
-		darwinClipboardInfo = func() (string, error) { return pngInfo, nil }
-		darwinClipboardExtract = func() ([]byte, error) { return []byte("png-bytes"), nil }
-
-		data, err := readClipboardImageDarwin()
-		if err != nil {
-			t.Fatalf("err = %v, want none", err)
-		}
-		if string(data) != "png-bytes" {
-			t.Fatalf("data = %q, want the extractor's bytes", data)
-		}
-	})
-}
@@ -48,7 +48,7 @@ func buildMinimalPDF(text string) []byte {
 	buf.WriteString("0 " + strconv.Itoa(len(offsets)+1) + "\n")
 	buf.WriteString("0000000000 65535 f \n")
 	for _, off := range offsets {
-		fmt.Fprintf(&buf, "%010d 00000 n \n", off)
+		buf.WriteString(fmt.Sprintf("%010d 00000 n \n", off))
 	}
 	buf.WriteString("trailer\n<< /Size " + strconv.Itoa(len(offsets)+1) + " /Root 1 0 R >>\n")
 	buf.WriteString("startxref\n" + strconv.Itoa(xrefStart) + "\n%%EOF\n")
@@ -277,7 +277,7 @@ func buildEmptyTextPDF() []byte {
 	buf.WriteString("0 " + strconv.Itoa(len(offsets)+1) + "\n")
 	buf.WriteString("0000000000 65535 f \n")
 	for _, off := range offsets {
-		fmt.Fprintf(&buf, "%010d 00000 n \n", off)
+		buf.WriteString(fmt.Sprintf("%010d 00000 n \n", off))
 	}
 	buf.WriteString("trailer\n<< /Size " + strconv.Itoa(len(offsets)+1) + " /Root 1 0 R >>\n")
 	buf.WriteString("startxref\n" + strconv.Itoa(xrefStart) + "\n%%EOF\n")
@@ -1,7 +1,6 @@
 package lsp

 import (
-	"context"
 	"encoding/json"
 	"testing"
 )
@@ -65,7 +64,7 @@ func TestDecodeSymbols(t *testing.T) {

 func TestNavigateUnknownOp(t *testing.T) {
 	m := NewManager(t.TempDir())
-	_, _, ok, err := m.Navigate(context.TODO(), NavRequest{Op: "bogus", Path: "x.go"})
+	_, _, ok, err := m.Navigate(nil, NavRequest{Op: "bogus", Path: "x.go"})
 	if err == nil {
 		t.Fatal("expected an error for an unknown nav op")
 	}
@@ -77,7 +76,7 @@ func TestNavigateUnknownOp(t *testing.T) {
 func TestNavigateUnsupportedExtensionDegrades(t *testing.T) {
 	// A file type with no configured server degrades to ok=false, no error.
 	m := NewManager(t.TempDir())
-	_, _, ok, err := m.Navigate(context.TODO(), NavRequest{Op: NavDefinition, Path: "notes.unknownext", Line: 1, Character: 1})
+	_, _, ok, err := m.Navigate(nil, NavRequest{Op: NavDefinition, Path: "notes.unknownext", Line: 1, Character: 1})
 	if err != nil {
 		t.Fatalf("unsupported extension should not error, got %v", err)
 	}
@@ -138,7 +138,6 @@ var descriptors = []Descriptor{
 	openAICompat("groq", "Groq", "https://api.groq.com/openai/v1", "llama-3.3-70b-versatile", []string{"GROQ_API_KEY"}),
 	openAICompat("deepseek", "DeepSeek", "https://api.deepseek.com/v1", "deepseek-chat", []string{"DEEPSEEK_API_KEY"}),
 	openAICompat("together", "Together AI", "https://api.together.xyz/v1", "meta-llama/Llama-3.3-70B-Instruct-Turbo", []string{"TOGETHER_API_KEY"}),
-	openAICompat("fireworks", "Fireworks AI", "https://api.fireworks.ai/inference/v1", "accounts/fireworks/models/kimi-k2p7-code", []string{"FIREWORKS_API_KEY"}, "fireworks-ai"),
 	openAICompat("dashscope", "DashScope", "https://dashscope-intl.aliyuncs.com/compatible-mode/v1", "qwen-plus", []string{"DASHSCOPE_API_KEY", "QWEN_API_KEY"}, "qwen"),
 	openAICompat("moonshot", "Moonshot AI", "https://api.moonshot.ai/v1", "kimi-k2-0905-preview", []string{"MOONSHOT_API_KEY"}, "kimi"),
 	openAICompat("atlascloud", "Atlas Cloud", "https://api.atlascloud.ai/v1", "qwen/qwen3.5-flash", []string{"ATLASCLOUD_API_KEY"}, "atlas cloud", "atlas"),
@@ -22,7 +22,6 @@ var expectedCatalogIDs = []string{
 	"groq",
 	"deepseek",
 	"together",
-	"fireworks",
 	"dashscope",
 	"moonshot",
 	"atlascloud",
@@ -156,28 +155,6 @@ func TestLongCatDescriptor(t *testing.T) {
 	}
 }

-func TestFireworksDescriptor(t *testing.T) {
-	descriptor, err := Require("fireworks")
-	if err != nil {
-		t.Fatalf("Require(fireworks) error = %v", err)
-	}
-	if descriptor.Name != "Fireworks AI" {
-		t.Fatalf("Name = %q, want Fireworks AI", descriptor.Name)
-	}
-	if descriptor.DefaultBaseURL != "https://api.fireworks.ai/inference/v1" {
-		t.Fatalf("DefaultBaseURL = %q, want Fireworks OpenAI-compatible endpoint", descriptor.DefaultBaseURL)
-	}
-	if descriptor.DefaultModel != "accounts/fireworks/models/kimi-k2p7-code" {
-		t.Fatalf("DefaultModel = %q, want accounts/fireworks/models/kimi-k2p7-code", descriptor.DefaultModel)
-	}
-	if descriptor.Transport != TransportOpenAICompatible {
-		t.Fatalf("Transport = %q, want %q", descriptor.Transport, TransportOpenAICompatible)
-	}
-	if !reflect.DeepEqual(descriptor.AuthEnvVars, []string{"FIREWORKS_API_KEY"}) {
-		t.Fatalf("AuthEnvVars = %#v, want FIREWORKS_API_KEY", descriptor.AuthEnvVars)
-	}
-}
-
 func TestAtlasCloudDescriptor(t *testing.T) {
 	descriptor, err := Require("atlascloud")
 	if err != nil {
@@ -369,7 +346,7 @@ func TestListByTransportPreservesCatalogOrder(t *testing.T) {
 		TransportBedrock:         {"bedrock"},
 		TransportVertex:          {"vertex"},
 		TransportAnthropicCompat: {"minimax", "minimaxi-cn", "opencode-go-anthropic-compatible", "custom-anthropic-compatible"},
-		TransportOpenAICompat:    {"gitlawb-opengateway", "aimlapi", "ollama-cloud", "ollama", "lmstudio", "openrouter", "huggingface", "chatgpt", "groq", "deepseek", "together", "fireworks", "dashscope", "moonshot", "atlascloud", "longcat", "nvidia-nim", "mistral", "github", "xai", "venice", "xiaomi-mimo", "bankr", "zai", "zai-cn", "kilocode", "opencode", "opencode-go", "atomic-chat", "chatgpt-proxy", "custom-openai-compatible"},
+		TransportOpenAICompat:    {"gitlawb-opengateway", "aimlapi", "ollama-cloud", "ollama", "lmstudio", "openrouter", "huggingface", "chatgpt", "groq", "deepseek", "together", "dashscope", "moonshot", "atlascloud", "longcat", "nvidia-nim", "mistral", "github", "xai", "venice", "xiaomi-mimo", "bankr", "zai", "zai-cn", "kilocode", "opencode", "opencode-go", "atomic-chat", "chatgpt-proxy", "custom-openai-compatible"},
 	}

 	for transport, wantIDs := range cases {
@@ -46,13 +46,12 @@ const (
 const defaultTimeout = 5 * time.Second

 type Options struct {
-	Profile       config.ProviderProfile
-	Connectivity  bool
-	HTTPClient    *http.Client
-	Resolver      Resolver
-	OAuthResolver providerio.TokenResolver
-	Timeout       time.Duration
-	UserAgent     string
+	Profile      config.ProviderProfile
+	Connectivity bool
+	HTTPClient   *http.Client
+	Resolver     Resolver
+	Timeout      time.Duration
+	UserAgent    string
 }

 type Resolver interface {
@@ -208,26 +207,11 @@ func Probe(ctx context.Context, options Options) Result {
 		"providerKind": metadata.ProviderKind,
 	}, profile))

-	oauthConfigured := options.OAuthResolver != nil
-	if oauthConfigured {
-		var resolveErr error
-		profile, oauthConfigured, resolveErr = profileWithOAuthCredential(ctx, profile, options.OAuthResolver, false)
-		if resolveErr != nil {
-			result.add(check("provider.auth", "Provider auth", StatusFail, CategoryAuth, "Provider OAuth credential could not be resolved: "+resolveErr.Error(), map[string]any{
-				"oauthLogin": true,
-			}, profile))
-			return result.finalize()
-		}
-	}
-	if credentialRequired(profile, metadata.ProviderKind) && !hasCredential(profile) && !oauthConfigured {
+	if credentialRequired(profile, metadata.ProviderKind) && !hasCredential(profile) {
 		result.add(check("provider.auth", "Provider auth", StatusFail, CategoryAuth, fmt.Sprintf("Provider %s requires API credentials.", providerName(profile)), credentialDetails(profile), profile))
 		return result.finalize()
 	}
-	if oauthConfigured {
-		result.add(check("provider.auth", "Provider auth", StatusPass, CategoryAuth, fmt.Sprintf("Provider %s has OAuth credentials configured.", providerName(profile)), map[string]any{
-			"oauthLogin": true,
-		}, profile))
-	} else if hasCredential(profile) {
+	if hasCredential(profile) {
 		result.add(check("provider.auth", "Provider auth", StatusPass, CategoryAuth, fmt.Sprintf("Provider %s has credentials configured.", providerName(profile)), credentialDetails(profile), profile))
 	} else {
 		result.add(check("provider.auth", "Provider auth", StatusPass, CategoryAuth, fmt.Sprintf("Provider %s does not require API credentials.", providerName(profile)), credentialDetails(profile), profile))
@@ -302,35 +286,9 @@ func connectivityCheck(ctx context.Context, profile config.ProviderProfile, kind
 	if err != nil {
 		return classifyTransportError(err, profile)
 	}
-	defer func(body io.ReadCloser) {
-		_ = body.Close()
-	}(response.Body)
-	if response.StatusCode == http.StatusUnauthorized && options.OAuthResolver != nil {
-		refreshed, ok, refreshErr := profileWithOAuthCredential(requestCtx, options.Profile, options.OAuthResolver, true)
-		if refreshErr != nil {
-			return check("provider.connectivity", "Provider connectivity", StatusFail, CategoryAuth, "Provider OAuth credential refresh failed: "+refreshErr.Error(), map[string]any{
-				"statusCode": response.StatusCode,
-			}, profile)
-		}
-		if ok {
-			_ = response.Body.Close()
-			profile = refreshed
-			request, allowLoopbackOrPrivate, err = healthRequest(requestCtx, profile, kind, options)
-			if err != nil {
-				return check("provider.connectivity", "Provider connectivity", StatusFail, CategoryConfig, err.Error(), nil, profile)
-			}
-			if options.HTTPClient == nil {
-				client = newConnectivityClient(timeout, options.Resolver, sensitiveAuthHeaderNames(profile, kind), allowLoopbackOrPrivate)
-			}
-			response, err = client.Do(request)
-			if err != nil {
-				return classifyTransportError(err, profile)
-			}
-			defer func(body io.ReadCloser) {
-				_ = body.Close()
-			}(response.Body)
-		}
-	}
+	defer func() {
+		_ = response.Body.Close()
+	}()

 	body, err := io.ReadAll(io.LimitReader(response.Body, 64*1024))
 	if err != nil {
@@ -362,23 +320,6 @@ func connectivityCheck(ctx context.Context, profile config.ProviderProfile, kind
 	}, profile)
 }

-func profileWithOAuthCredential(ctx context.Context, profile config.ProviderProfile, resolver providerio.TokenResolver, forceRefresh bool) (config.ProviderProfile, bool, error) {
-	if resolver == nil {
-		return profile, false, nil
-	}
-	header, value, ok, err := resolver(ctx, forceRefresh)
-	if err != nil || !ok {
-		return profile, false, err
-	}
-	if strings.TrimSpace(header) == "" {
-		header = "Authorization"
-	}
-	profile.AuthHeader = header
-	profile.AuthScheme = ""
-	profile.AuthHeaderValue = value
-	return profile, true, nil
-}
-
 func healthRequest(ctx context.Context, profile config.ProviderProfile, kind config.ProviderKind, options Options) (*http.Request, bool, error) {
 	baseURL, err := resolvedBaseURL(profile, kind)
 	if err != nil {
@@ -450,7 +391,7 @@ func validateEndpoint(ctx context.Context, endpoint string, resolver Resolver, a
 		return endpointSafetyError{message: "provider connectivity URL is unsafe: localhost hosts are blocked"}
 	}
 	if addr, err := netip.ParseAddr(normalized); err == nil {
-		if reason := blockedAddrReason(addr); reason != "" && (!allowLoopbackOrPrivate || (!addr.IsLoopback() && !addr.IsPrivate())) {
+		if reason := blockedAddrReason(addr); reason != "" && !(allowLoopbackOrPrivate && (addr.IsLoopback() || addr.IsPrivate())) {
 			return endpointSafetyError{message: "provider connectivity URL is unsafe: " + reason}
 		}
 		return nil
@@ -466,7 +407,7 @@ func validateEndpoint(ctx context.Context, endpoint string, resolver Resolver, a
 		return endpointSafetyError{message: "provider connectivity host resolved to no addresses"}
 	}
 	for _, addr := range addrs {
-		if reason := blockedAddrReason(addr); reason != "" && (!allowLoopbackOrPrivate || (!addr.IsLoopback() && !addr.IsPrivate())) {
+		if reason := blockedAddrReason(addr); reason != "" && !(allowLoopbackOrPrivate && (addr.IsLoopback() || addr.IsPrivate())) {
 			return endpointSafetyError{message: "provider connectivity URL is unsafe: " + reason}
 		}
 	}
@@ -588,7 +529,7 @@ func safeDialContext(resolver Resolver, allowLoopbackOrPrivate bool) func(contex
 			return nil, err
 		}
 		if addr, parseErr := netip.ParseAddr(host); parseErr == nil {
-			if reason := blockedAddrReason(addr); reason != "" && (!allowLoopbackOrPrivate || (!addr.IsLoopback() && !addr.IsPrivate())) {
+			if reason := blockedAddrReason(addr); reason != "" && !(allowLoopbackOrPrivate && (addr.IsLoopback() || addr.IsPrivate())) {
 				return nil, endpointSafetyError{message: "provider connectivity URL is unsafe: " + reason}
 			}
 			return dialer.DialContext(ctx, network, address)
@@ -601,7 +542,7 @@ func safeDialContext(resolver Resolver, allowLoopbackOrPrivate bool) func(contex
 			return nil, endpointSafetyError{message: "provider connectivity host resolved to no addresses"}
 		}
 		for _, addr := range addrs {
-			if reason := blockedAddrReason(addr); reason != "" && (!allowLoopbackOrPrivate || (!addr.IsLoopback() && !addr.IsPrivate())) {
+			if reason := blockedAddrReason(addr); reason != "" && !(allowLoopbackOrPrivate && (addr.IsLoopback() || addr.IsPrivate())) {
 				return nil, endpointSafetyError{message: "provider connectivity URL is unsafe: " + reason}
 			}
 		}
@@ -807,9 +748,6 @@ func redact(message string, profile config.ProviderProfile) string {

 func providerSecrets(profile config.ProviderProfile) []string {
 	secrets := []string{profile.APIKey, profile.AuthHeaderValue}
-	if fields := strings.Fields(profile.AuthHeaderValue); len(fields) == 2 {
-		secrets = append(secrets, fields[1])
-	}
 	for _, value := range profile.CustomHeaders {
 		if strings.TrimSpace(value) != "" {
 			secrets = append(secrets, value)
@@ -180,182 +180,6 @@ func TestProbeResolvedKindConnectivityAuthErrorRedactsSecret(t *testing.T) {
 	}
 }

-func TestProbeConnectivityUsesOAuthCredential(t *testing.T) {
-	var gotAuth string
-	resolverCalled := false
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		gotAuth = r.Header.Get("Authorization")
-		return &http.Response{
-			StatusCode: http.StatusOK,
-			Status:     "200 OK",
-			Body:       io.NopCloser(strings.NewReader(`{"data":[]}`)),
-			Header:     make(http.Header),
-		}, nil
-	})}
-
-	result := Probe(context.Background(), Options{
-		Profile: config.ProviderProfile{
-			Name:         "xai",
-			CatalogID:    "xai",
-			ProviderKind: config.ProviderKindOpenAICompatible,
-			BaseURL:      "https://api.example.com/v1",
-			Model:        "grok-4",
-		},
-		Connectivity: true,
-		HTTPClient:   client,
-		Resolver:     staticResolver{addr: netip.MustParseAddr("93.184.216.34")},
-		OAuthResolver: func(context.Context, bool) (string, string, bool, error) {
-			resolverCalled = true
-			return "Authorization", "Bearer oauth-test-token", true, nil
-		},
-	})
-
-	if result.Status != StatusPass {
-		t.Fatalf("Status = %q, want pass: %#v", result.Status, result.Checks)
-	}
-	if !resolverCalled {
-		t.Fatal("OAuth resolver was not called")
-	}
-	if gotAuth != "Bearer oauth-test-token" {
-		t.Fatalf("Authorization = %q, want OAuth bearer", gotAuth)
-	}
-}
-
-func TestProbeConnectivityOAuthCredentialsAreRedacted(t *testing.T) {
-	const (
-		staticKey  = "STATICKEYVALUE1234567890abcdef"
-		oauthToken = "hf_VASANTHSENTINEL0011223344"
-	)
-	var authHeaders []string
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		authHeaders = append(authHeaders, r.Header.Get("Authorization"))
-		return &http.Response{
-			StatusCode: http.StatusUnauthorized,
-			Status:     "401 Unauthorized",
-			Body:       io.NopCloser(strings.NewReader(`{"error":{"message":"invalid credentials ` + staticKey + ` and ` + oauthToken + `"}}`)),
-			Header:     make(http.Header),
-		}, nil
-	})}
-
-	result := Probe(context.Background(), Options{
-		Profile: config.ProviderProfile{
-			Name:         "xai",
-			CatalogID:    "xai",
-			ProviderKind: config.ProviderKindOpenAICompatible,
-			BaseURL:      "https://api.example.com/v1",
-			APIKey:       staticKey,
-			Model:        "grok-4",
-		},
-		Connectivity: true,
-		HTTPClient:   client,
-		Resolver:     staticResolver{addr: netip.MustParseAddr("93.184.216.34")},
-		OAuthResolver: func(context.Context, bool) (string, string, bool, error) {
-			return "Authorization", "Bearer " + oauthToken, true, nil
-		},
-	})
-
-	if len(authHeaders) != 2 {
-		t.Fatalf("Authorization headers = %#v, want initial request and one refresh retry", authHeaders)
-	}
-	for _, header := range authHeaders {
-		if header != "Bearer "+oauthToken {
-			t.Fatalf("Authorization = %q, want OAuth bearer", header)
-		}
-	}
-	check := result.Check("provider.connectivity")
-	if check == nil || check.Category != CategoryAuth {
-		t.Fatalf("provider.connectivity = %#v, want auth failure", check)
-	}
-	if strings.Contains(check.Message, staticKey) {
-		t.Fatalf("static API key leaked in message: %q", check.Message)
-	}
-	if strings.Contains(check.Message, oauthToken) {
-		t.Fatalf("OAuth token leaked in message: %q", check.Message)
-	}
-	if strings.Count(check.Message, "[REDACTED]") != 2 {
-		t.Fatalf("expected both credentials to be redacted, got %q", check.Message)
-	}
-}
-
-func TestProbeWithoutConnectivityRejectsUnavailableOAuthCredential(t *testing.T) {
-	resolverCalled := false
-	result := Probe(context.Background(), Options{
-		Profile: config.ProviderProfile{
-			Name:         "xai",
-			CatalogID:    "xai",
-			ProviderKind: config.ProviderKindOpenAICompatible,
-			BaseURL:      "https://api.example.com/v1",
-			Model:        "grok-4",
-		},
-		OAuthResolver: func(context.Context, bool) (string, string, bool, error) {
-			resolverCalled = true
-			return "", "", false, nil
-		},
-	})
-
-	if !resolverCalled {
-		t.Fatal("OAuth resolver was not called")
-	}
-	if result.Status != StatusFail {
-		t.Fatalf("Status = %q, want fail: %#v", result.Status, result.Checks)
-	}
-	check := result.Check("provider.auth")
-	if check == nil || check.Status != StatusFail || check.Category != CategoryAuth {
-		t.Fatalf("provider.auth = %#v, want auth failure", check)
-	}
-}
-
-func TestProbeConnectivityRefreshesOAuthCredentialAfterUnauthorized(t *testing.T) {
-	var authHeaders []string
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		authHeaders = append(authHeaders, r.Header.Get("Authorization"))
-		status := http.StatusOK
-		body := `{"data":[]}`
-		if len(authHeaders) == 1 {
-			status = http.StatusUnauthorized
-			body = `{"error":{"message":"expired"}}`
-		}
-		return &http.Response{
-			StatusCode: status,
-			Status:     http.StatusText(status),
-			Body:       io.NopCloser(strings.NewReader(body)),
-			Header:     make(http.Header),
-		}, nil
-	})}
-
-	var refreshFlags []bool
-	result := Probe(context.Background(), Options{
-		Profile: config.ProviderProfile{
-			Name:         "xai",
-			CatalogID:    "xai",
-			ProviderKind: config.ProviderKindOpenAICompatible,
-			BaseURL:      "https://api.example.com/v1",
-			Model:        "grok-4",
-		},
-		Connectivity: true,
-		HTTPClient:   client,
-		Resolver:     staticResolver{addr: netip.MustParseAddr("93.184.216.34")},
-		OAuthResolver: func(_ context.Context, forceRefresh bool) (string, string, bool, error) {
-			refreshFlags = append(refreshFlags, forceRefresh)
-			token := "stale-token"
-			if forceRefresh {
-				token = "fresh-token"
-			}
-			return "Authorization", "Bearer " + token, true, nil
-		},
-	})
-
-	if result.Status != StatusPass {
-		t.Fatalf("Status = %q, want pass after refresh: %#v", result.Status, result.Checks)
-	}
-	if len(refreshFlags) != 2 || refreshFlags[0] || !refreshFlags[1] {
-		t.Fatalf("OAuth refresh flags = %#v, want [false true]", refreshFlags)
-	}
-	if len(authHeaders) != 2 || authHeaders[0] != "Bearer stale-token" || authHeaders[1] != "Bearer fresh-token" {
-		t.Fatalf("Authorization headers = %#v, want stale then fresh bearer", authHeaders)
-	}
-}
-
 func TestProbeConnectivityClassifiesTimeout(t *testing.T) {
 	client := &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
 		return nil, context.DeadlineExceeded
@@ -122,14 +122,6 @@ var curatedModels = map[string][]Model{
 		{ID: "deepseek-ai/DeepSeek-R1", Description: "reasoning model"},
 		{ID: "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8", Description: "multimodal model"},
 	},
-	"fireworks": {
-		// Serverless-only curated set: ordinary API-key setups hit /inference/v1
-		// and cannot use on-demand deployment IDs.
-		{ID: "accounts/fireworks/models/kimi-k2p7-code", Description: "catalog default"},
-		{ID: "accounts/fireworks/models/deepseek-v4-flash", Description: "fast coding model"},
-		{ID: "accounts/fireworks/models/gpt-oss-120b", Description: "general model"},
-		{ID: "accounts/fireworks/models/deepseek-v4-pro", Description: "reasoning model"},
-	},
 	"dashscope": {
 		{ID: "qwen-plus", Description: "catalog default"},
 		{ID: "qwen-max", Description: "strong general model"},
@@ -28,11 +28,6 @@ func TestModelsAreProviderScoped(t *testing.T) {
 			want:     []string{"llama-3.3-70b-versatile", "openai/gpt-oss-120b"},
 			notWant:  []string{"gpt-4.1", "claude-sonnet-4.5"},
 		},
-		{
-			provider: "fireworks",
-			want:     []string{"accounts/fireworks/models/kimi-k2p7-code", "accounts/fireworks/models/deepseek-v4-flash"},
-			notWant:  []string{"gpt-4.1", "llama-3.3-70b-versatile"},
-		},
 		{
 			provider: "chatgpt",
 			want:     []string{"gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"},
@@ -132,8 +132,6 @@ func ModelsDevProviderID(provider providercatalog.Descriptor) string {
 		return "zai"
 	case "minimaxi-cn":
 		return "minimax"
-	case "fireworks":
-		return "fireworks-ai"
 	default:
 		return strings.TrimSpace(provider.ID)
 	}
@@ -131,7 +131,6 @@ func TestModelsDevProviderIDMapsZeroAliases(t *testing.T) {
 		"ollama-cloud": "ollama-cloud",
 		"zai-cn":       "zai",
 		"minimaxi-cn":  "minimax",
-		"fireworks":    "fireworks-ai",
 	}
 	for zeroID, want := range tests {
 		provider, ok := providercatalog.Get(zeroID)
@@ -62,7 +62,7 @@ func TestDetectLocalRuntimesReportsReachableRuntime(t *testing.T) {
 	if !detected[0].Reachable {
 		t.Fatalf("runtime should be reachable: %#v", detected[0])
 	}
-	if len(detected[0].Models) == 0 || detected[0].Models[0] != "llama3.1" {
+	if detected[0].Models == nil || len(detected[0].Models) == 0 || detected[0].Models[0] != "llama3.1" {
 		t.Fatalf("expected discovered model list, got %#v", detected[0].Models)
 	}
 }
@@ -25,9 +25,7 @@ type TokenResolver func(ctx context.Context, forceRefresh bool) (header string,
 //
 // base carries the API-key auth config (key + default header/scheme). setExtra
 // (optional) sets the provider's non-auth headers on every attempt. Transient
-// retries are handled by the inner SendWithRetry: 429/503/529 on their own
-// budget, and provably pre-send transport failures (refused or timed-out
-// connect, DNS, TLS handshake) on a separate, shorter one.
+// retries (429/503/529) are handled by the inner SendWithRetry.
 func SendWithAuthRetry(
 	ctx context.Context,
 	client *http.Client,
@@ -3,9 +3,6 @@ package providerio
 import (
 	"bytes"
 	"context"
-	"errors"
-	"io"
-	"net"
 	"net/http"
 	"strconv"
 	"strings"
@@ -20,22 +17,13 @@ import (
 // (previously only the OpenAI provider retried; Anthropic and Gemini surfaced the
 // first failure).
 //
-// What is retried: 429 (rate limit) and 503 (service unavailable) — the statuses
-// where the server explicitly did NOT accept the request — plus PROVABLY
-// pre-send transport failures (DNS resolution, a refused/unreachable dial, a TLS
-// handshake timeout) where no request bytes ever left this host. In every one of
-// those cases we KNOW the server did not receive and process the request, so a
-// replay cannot duplicate work. Other 5xx (500/502/504) and every ambiguous or
-// post-send transport error (connection reset, broken pipe, EOF, a generic i/o
-// timeout, context deadline) are NOT retried: a completion POST is
-// non-idempotent and may already have reached and been processed by the server,
-// so replaying it could duplicate (billable) work. Only the INITIAL request is
-// ever in scope; once the response body starts streaming it is never re-issued.
-// Pre-send classification is by syscall errno (portable across POSIX and
-// Windows), scoped to an Op=="dial" *net.OpError so the same errno raised on a
-// post-send read/write can't be misread as pre-send. NXDOMAIN is treated as
-// permanent (not retried), and the pre-send path fails fast on its own
-// sub-second schedule rather than the seconds-long 429 backoff.
+// What is retried: ONLY 429 (rate limit) and 503 (service unavailable) — the
+// statuses where the server explicitly did NOT accept the request, so replaying
+// it cannot duplicate work. Other 5xx (500/502/504) and transport/network errors
+// are NOT retried: a completion POST is non-idempotent and may have reached and
+// been processed by the server, so replaying it could duplicate
+// (billable) work. Only the INITIAL request is ever in scope; once the response
+// body starts streaming it is never re-issued.

 const defaultMaxRetryAttempts = 6

@@ -49,32 +37,12 @@ const maxBackoff = 30 * time.Second
 // schedule is 2s, 4s, 8s, 16s, then maxBackoff. A var so tests can shrink it.
 var retryBackoffBase = 2 * time.Second

-// preSendMaxAttempts bounds retries of a provably pre-send transport failure.
-// Unlike a 429 (whose window is measured in seconds), a refused/unreachable dial
-// either recovers within a few hundred ms or is a deterministic misconfiguration
-// (wrong host/port, dead local daemon) that will never recover — so a short,
-// low-count schedule fails fast instead of stalling the agent ~60s on the
-// rate-limit schedule. This bounds the pre-send path independently of the caller's
-// maxAttempts, which is tuned for 429/503.
-const preSendMaxAttempts = 3
-
-// preSendBackoffBase is the first wait before replaying a pre-send transport
-// failure. Modeled on the mid-stream reconnect base (internal/agent/reconnect.go),
-// it is sub-second so a transient dial blip recovers quickly and a permanent one
-// fails fast. A var so tests can shrink it.
-var preSendBackoffBase = 500 * time.Millisecond
-
 // SendWithRetry issues an HTTP request, retrying ONLY the safe-to-replay server
 // responses (429 and 503, see ShouldRetryStatus) up to maxAttempts — backing off
 // between tries and honoring a server Retry-After header and context
-// cancellation. The one transport-error exception is a PROVABLY pre-send failure
-// (see isPreSendTransportError): a refused/unreachable dial or DNS failure where
-// no request bytes left this host, retried on its own short schedule
-// (preSendMaxAttempts / preSendBackoff). Every other 5xx and every ambiguous or
-// post-send transport error is returned immediately, never replayed, because a
-// non-idempotent completion POST may already have been received. The request is
-// rebuilt from body each attempt; setHeader (if non-nil) sets headers on every
-// attempt.
+// cancellation. Other 5xx and transport/network errors are returned immediately,
+// never replayed (see the package note). The request is rebuilt from body each
+// attempt; setHeader (if non-nil) sets headers on every attempt.
 //
 // It returns the final *http.Response (which the caller inspects for a non-2xx
 // status, exactly as before) or an error for a network failure / context
@@ -92,47 +60,7 @@ func SendWithRetry(
 	if maxAttempts <= 0 {
 		maxAttempts = defaultMaxRetryAttempts
 	}
-	if client == nil {
-		client = http.DefaultClient
-	}
-	// Redirects are still FOLLOWED, so a redirecting gateway keeps working, but
-	// entering one makes that attempt non-retryable. The hazard is that client.Do
-	// can transmit the original POST to the first host, follow a 307/308, and then
-	// fail the dial to the redirect target: that error is an Op=="dial" error, so
-	// isPreSendTransportError would read it as "nothing was sent" and replay a
-	// completion the first host already received. Observing the redirect rather
-	// than blocking it keeps both properties, since a request that was redirected
-	// is never replayed while redirecting endpoints stay usable. The caller's own
-	// CheckRedirect still runs and still decides whether to proceed.
-	redirected := false
-	callerCheckRedirect := client.CheckRedirect
-	redirectAwareClient := *client
-	redirectAwareClient.CheckRedirect = func(request *http.Request, via []*http.Request) error {
-		redirected = true
-		if callerCheckRedirect != nil {
-			return callerCheckRedirect(request, via)
-		}
-		// Mirror net/http's default policy, which a nil CheckRedirect would have
-		// applied: stop after 10 hops.
-		if len(via) >= 10 {
-			return errors.New("stopped after 10 redirects")
-		}
-		return nil
-	}
-	// The two retry budgets are fully independent, each with its own counter and
-	// its own backoff ordinal, because they answer different questions: a
-	// dial/DNS/TLS failure is a fast local blip (preSendMaxAttempts, sub-second
-	// schedule) while a 429/503 is a server-side window measured in seconds
-	// (maxAttempts, retryBackoffBase). A single shared loop counter coupled them
-	// in both directions: status retries starved the pre-send budget, and
-	// pre-send retries shortened the status window and started its backoff at a
-	// later rung. Neither kind of failure now consumes or advances the other.
-	preSendAttempts := 0
-	statusAttempts := 0
-	for {
-		// Per attempt: only a redirect entered by THIS attempt can make its own
-		// transport error unsafe to replay.
-		redirected = false
+	for attempt := 1; ; attempt++ {
 		request, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(body))
 		if err != nil {
 			return nil, err
@@ -142,78 +70,32 @@ func SendWithRetry(
 		}

 		connectSpan := trace.FromContext(ctx).Span(trace.SpanProviderConnect)
-		response, err := redirectAwareClient.Do(request)
+		response, err := client.Do(request)
 		connectSpan.End()
 		if err != nil {
-			// Context cancellation always surfaces as cancellation, never a retry.
+			// A transport failure on a POST does NOT mean the server didn't receive
+			// it — the request may have arrived and be generating a (billable,
+			// non-idempotent) completion while only the response/connection failed.
+			// Replaying it could duplicate that work, so surface the error instead
+			// of retrying. Only 429/503 responses (below), where we KNOW the request
+			// was not accepted, are safe to retry.
 			if ctx.Err() != nil {
 				return nil, ctx.Err()
 			}
-			// A transport failure on a POST does NOT usually mean the server didn't
-			// receive it — the request may have arrived and be generating a
-			// (billable, non-idempotent) completion while only the response or
-			// connection failed. Replaying that could duplicate work, so it is
-			// surfaced immediately. The one safe exception is a PROVABLY pre-send
-			// failure (see isPreSendTransportError): the request never left this
-			// host, so a replay cannot duplicate anything — exactly like a 429/503
-			// where we KNOW the request was not accepted. The pre-send path uses
-			// its own short bound and sub-second schedule (preSendMaxAttempts /
-			// preSendBackoff), not the seconds-long 429 schedule, so a permanent
-			// dial failure fails fast instead of stalling the agent for ~60s.
-			// A redirect means the original POST already left this host, so the
-			// dial that failed belongs to a later hop and replaying would duplicate
-			// a completion the first host may already have processed.
-			if isPreSendTransportError(err) && !redirected {
-				preSendAttempts++
-				if preSendAttempts < preSendMaxAttempts {
-					if r := trace.FromContext(ctx); r != nil {
-						r.Counter(trace.CounterRetryCount, 1)
-					}
-					if preSendBackoff(ctx, preSendAttempts) {
-						continue
-					}
-					return nil, ctx.Err()
-				}
-			}
 			return nil, err
 		}

-		// Deliberately NOT guarded on `redirected`, unlike the transport-error
-		// branch above. The two differ in what is known about the request. A
-		// transport failure after a redirect leaves it unknown whether the
-		// redirect target received and began processing the POST, so replaying
-		// could duplicate billable work. Here every hop answered: a 307/308 is the
-		// origin declining and delegating, and a retryable status is the target
-		// declining as well, so nothing accepted the request and a replay
-		// duplicates nothing.
-		//
-		// The exposure is also identical to a retryable status with no redirect in
-		// play, which this package has always retried. Guarding on redirects here
-		// would not close a gap, it would make a rate-limited completion behind a
-		// redirecting gateway fail outright instead of backing off.
-		// The transport hop succeeded, so the connect phase is healthy again and
-		// the pre-send budget starts over. It bounds CONSECUTIVE connect failures,
-		// not the lifetime of the call: without this reset, two early dial retries
-		// followed by a 429 and then one more dial blip would surface a transport
-		// error while the status budget still had room, which is the coupling
-		// these two counters were split apart to remove. Total work stays bounded,
-		// since every reset costs a status attempt and those are capped.
-		preSendAttempts = 0
-
-		if ShouldRetryStatus(response.StatusCode) {
-			statusAttempts++
-			if statusAttempts < maxAttempts {
-				if r := trace.FromContext(ctx); r != nil {
-					r.Counter(trace.CounterRetryCount, 1)
-				}
-				wait := RetryAfter(response)
-				_ = response.Body.Close()
-				if Backoff(ctx, statusAttempts, wait) {
-					continue
-				}
-				// Backoff aborted: the only reason it returns false is ctx cancellation.
-				return nil, ctx.Err()
+		if ShouldRetryStatus(response.StatusCode) && attempt < maxAttempts {
+			if r := trace.FromContext(ctx); r != nil {
+				r.Counter(trace.CounterRetryCount, 1)
 			}
+			wait := RetryAfter(response)
+			_ = response.Body.Close()
+			if Backoff(ctx, attempt, wait) {
+				continue
+			}
+			// Backoff aborted: the only reason it returns false is ctx cancellation.
+			return nil, ctx.Err()
 		}

 		// Success, a non-retryable status, or retries exhausted on a retryable
@@ -227,119 +109,6 @@ func SendWithRetry(
 	}
 }

-// isPreSendTransportError reports whether a transport error PROVES no request
-// bytes reached the server, so replaying the request cannot duplicate a
-// billable completion. Only narrow, unambiguous pre-connect failures qualify: a
-// recoverable DNS lookup failure, a refused/unreachable dial, and a TLS
-// handshake timeout (the handshake completes before any HTTP request bytes are
-// written).
-//
-// The refused/unreachable errnos (ECONNREFUSED/ENETUNREACH/EHOSTUNREACH) are
-// matched by syscall errno via errors.Is — portable across platforms, since Go
-// maps the WSA* codes on Windows too — but ONLY when carried by an Op=="dial"
-// *net.OpError. errors.Is matches an errno anywhere in the chain regardless of
-// which socket operation raised it, and the kernel raises these same errnos on
-// an established connection when a route drops mid-generation; scoping to the
-// dial phase is what makes "no request bytes were sent" structural rather than
-// argued, so a post-send read/write can never replay a non-idempotent POST.
-// NXDOMAIN is treated as permanent (deterministic) and is NOT retried.
-//
-// Ambiguous or post-send failures are deliberately excluded and checked FIRST,
-// so an error that is both is never treated as pre-send: a reset or broken pipe
-// can follow a request that was already sent, and a bare "i/o timeout" covers
-// read timeouts after send as well as dial timeouts, so none of these prove the
-// request was not received and a non-idempotent POST must not be replayed on
-// them.
-func isPreSendTransportError(err error) bool {
-	if err == nil {
-		return false
-	}
-	// DNS resolution precedes any connection, so a lookup failure proves nothing
-	// was sent — but only retry a lookup that could plausibly succeed on a replay.
-	// NXDOMAIN (IsNotFound) is authoritative and deterministic (a mistyped or
-	// non-existent host), so retrying it just stalls the agent through the whole
-	// backoff schedule before failing anyway; a timeout or temporary SERVFAIL is
-	// worth another try. errors.As unwraps url.Error/OpError to reach the DNSError.
-	var dnsErr *net.DNSError
-	if errors.As(err, &dnsErr) {
-		return !dnsErr.IsNotFound
-	}
-	// Post-send / ambiguous failures, excluded first. EOF and reset are matched
-	// by identity so wording (or a hostname containing "eof") can't fool them.
-	if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) || isConnResetErrno(err) {
-		return false
-	}
-	// A CONNECT-phase timeout is provably pre-send for the same structural reason
-	// a refused dial is: the connection was never established, so no request
-	// bytes left this host. It has to be admitted BEFORE the wording exclusions
-	// below, because net surfaces it with "i/o timeout" in the message, which the
-	// blanket exclusion would otherwise reject. The gate is what keeps that safe:
-	// a post-send read timeout is also Timeout(), but carries Op "read", so it
-	// never reaches here.
-	if opErr := connectOpError(err); opErr != nil && opErr.Timeout() {
-		return true
-	}
-	msg := strings.ToLower(err.Error())
-	if strings.Contains(msg, "connection reset") ||
-		strings.Contains(msg, "broken pipe") ||
-		strings.Contains(msg, "i/o timeout") {
-		return false
-	}
-	// A refused/unreachable connection is provably pre-send ONLY when it was
-	// raised during the DIAL (connection-establishment) phase. The same errnos
-	// are also raised by the kernel on an ESTABLISHED connection — when a route
-	// drops or an ICMP unreachable arrives mid-generation — which is post-send.
-	// errors.Is matches an errno anywhere in the chain regardless of the
-	// operation, so we first require an Op=="dial" *net.OpError: that makes "no
-	// request bytes left this host" structural, so a post-send read/write carrying
-	// one of these can never replay a non-idempotent POST. dialPreSendErrnos is
-	// platform-specific: on Windows a refused dial carries the raw WSA* errno
-	// (WSAECONNREFUSED etc.), which does NOT satisfy errors.Is against the POSIX
-	// syscall.ECONNREFUSED, so the Windows list adds those codes. The string
-	// markers only catch a POSIX dial error already flattened past its errno.
-	if connectOpError(err) != nil {
-		for _, errno := range dialPreSendErrnos {
-			if errors.Is(err, errno) {
-				return true
-			}
-		}
-		switch {
-		case strings.Contains(msg, "connection refused"),
-			strings.Contains(msg, "network is unreachable"),
-			strings.Contains(msg, "no route to host"):
-			return true
-		}
-	}
-	// A TLS handshake times out after the TCP dial connects but before any HTTP
-	// request bytes are written, so it is structurally pre-send. net/http surfaces
-	// it as its own error string, not a *net.OpError, so it is matched by wording
-	// independent of the dial gate.
-	if strings.Contains(msg, "tls handshake timeout") {
-		return true
-	}
-	return false
-}
-
-// connectOpError returns the outermost *net.OpError in err's chain when it comes
-// from the connection-establishment phase, else nil. Go tags a direct dial with
-// Op "dial" and a failed CONNECT through an HTTP proxy with Op "proxyconnect";
-// a failure on an already-established connection carries Op "read"/"write".
-// This is how isPreSendTransportError scopes the pre-send match to the connect
-// phase so a post-send failure can't be misclassified as pre-send.
-//
-// "proxyconnect" belongs here for the same reason "dial" does: when HTTPS_PROXY
-// is set and the CONNECT fails, the tunnel to the model host was never built, so
-// no request bytes reached it. Omitting it meant every pre-send failure behind a
-// corporate proxy fell through to no-retry, which is the environment where
-// transient connect failures are most common.
-func connectOpError(err error) *net.OpError {
-	var opErr *net.OpError
-	if errors.As(err, &opErr) && (opErr.Op == "dial" || opErr.Op == "proxyconnect") {
-		return opErr
-	}
-	return nil
-}
-
 // ShouldRetryStatus reports whether an HTTP status is safe to retry for a
 // non-idempotent completion POST: 429 (Too Many Requests), 503 (Service
 // Unavailable), and 529 (Anthropic's "overloaded"). All mean the server
@@ -368,39 +137,6 @@ func Backoff(ctx context.Context, attempt int, retryAfter time.Duration) bool {
 	}
 }

-// preSendBackoff waits before pre-send retry attempt N (1-based) on a short
-// sub-second schedule (500ms, 1s, ...), returning false if the context is
-// cancelled during the wait. Separate from Backoff's seconds-long rate-limit
-// schedule because a pre-send dial failure recovers in milliseconds or never.
-func preSendBackoff(ctx context.Context, attempt int) bool {
-	timer := time.NewTimer(preSendBackoffWait(attempt))
-	defer timer.Stop()
-	select {
-	case <-ctx.Done():
-		return false
-	case <-timer.C:
-		return true
-	}
-}
-
-// preSendBackoffWait computes the pre-send wait before retry attempt N (1-based):
-// exponential from preSendBackoffBase (500ms, 1s, 2s, ...), capped at maxBackoff.
-// The exponent is clamped so a large attempt count cannot overflow.
-func preSendBackoffWait(attempt int) time.Duration {
-	exponent := attempt - 1
-	if exponent > 5 {
-		exponent = 5
-	}
-	if exponent < 0 {
-		exponent = 0
-	}
-	wait := preSendBackoffBase * time.Duration(1<<exponent)
-	if wait > maxBackoff {
-		wait = maxBackoff
-	}
-	return wait
-}
-
 // backoffWait computes the wait before retry attempt N (1-based): Retry-After
 // when supplied, else exponential from retryBackoffBase, both capped at
 // maxBackoff. The exponent is clamped so a large attempt count cannot overflow.
@@ -1,32 +0,0 @@
-//go:build !windows && !plan9
-
-package providerio
-
-import (
-	"errors"
-	"syscall"
-)
-
-// dialPreSendErrnos are the syscall errnos a refused or unreachable DIAL raises
-// on this platform. On POSIX the standard syscall constants are exactly what the
-// net package surfaces, so matching them via errors.Is is sufficient. Plan 9 is
-// excluded because it does not define these BSD-style errno constants (it uses
-// string errors), so the constants below would not compile there; Zero targets
-// linux/darwin/windows, so no Plan 9 variant is needed.
-var dialPreSendErrnos = []error{
-	syscall.ECONNREFUSED,
-	syscall.ENETUNREACH,
-	syscall.EHOSTUNREACH,
-	// A connect timeout is normally caught by the Timeout() check on the connect
-	// gate; this covers the case where the errno survives but the timeout flag
-	// does not, e.g. an error rebuilt from the errno alone.
-	syscall.ETIMEDOUT,
-}
-
-// isConnResetErrno reports whether err carries a connection-reset errno, the
-// post-send exclusion in isPreSendTransportError. It lives here (per platform)
-// so retry.go references no syscall constants and stays buildable on Plan 9,
-// which defines none of them.
-func isConnResetErrno(err error) bool {
-	return errors.Is(err, syscall.ECONNRESET)
-}
@@ -1,15 +0,0 @@
-//go:build plan9
-
-package providerio
-
-// Plan 9 has no BSD-style errno constants (it uses string errors), so the
-// errno-based classification is unavailable here: isConnResetErrno returns false
-// and dialPreSendErrnos is empty. retry.go still classifies via its string
-// markers on this platform, the pre-send inclusions (connection refused /
-// network unreachable / no route to host) and the separate post-send
-// "connection reset" exclusion each keep working through the wording checks.
-// Zero targets linux/darwin/windows, so this variant only keeps the package
-// building on Plan 9 rather than adding real support.
-var dialPreSendErrnos = []error{}
-
-func isConnResetErrno(error) bool { return false }
@@ -1,40 +0,0 @@
-//go:build windows
-
-package providerio
-
-import (
-	"errors"
-	"syscall"
-
-	"golang.org/x/sys/windows"
-)
-
-// dialPreSendErrnos are the errnos a refused or unreachable DIAL raises on
-// Windows. A real Windows dial failure carries the raw Winsock error
-// (WSAECONNREFUSED = 10061, WSAENETUNREACH = 10051, WSAEHOSTUNREACH = 10065), and
-// errors.Is against the POSIX syscall.ECONNREFUSED returns FALSE there because
-// Go's Windows syscall.ECONNREFUSED is a distinct value the net package never
-// produces. So the WSA codes must be matched explicitly, or a refused dial would
-// silently never be retried on Windows. The POSIX constants stay in the list too
-// so an error built with them (e.g. a test fixture) still classifies.
-var dialPreSendErrnos = []error{
-	syscall.ECONNREFUSED,
-	syscall.ENETUNREACH,
-	syscall.EHOSTUNREACH,
-	syscall.ETIMEDOUT,
-	windows.WSAECONNREFUSED,
-	windows.WSAENETUNREACH,
-	windows.WSAEHOSTUNREACH,
-	// Same reasoning as the POSIX ETIMEDOUT entry, with the Winsock code a real
-	// Windows connect timeout actually carries.
-	windows.WSAETIMEDOUT,
-}
-
-// isConnResetErrno reports whether err carries a connection-reset errno, the
-// post-send exclusion in isPreSendTransportError. It matches the same
-// syscall.ECONNRESET the shared path used before the errno classification was
-// split out per platform, so behavior on Windows is unchanged; it lives here
-// so retry.go references no syscall constants and stays buildable on Plan 9.
-func isConnResetErrno(err error) bool {
-	return errors.Is(err, syscall.ECONNRESET)
-}
@@ -1,34 +1,15 @@
-//go:build !plan9
-
 package providerio

 import (
 	"context"
 	"errors"
-	"io"
-	"net"
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"sync/atomic"
-	"syscall"
 	"testing"
 	"time"
 )

-// wrapDialErrno builds the error shape a dial failure has (a *net.OpError
-// wrapping an *os.SyscallError wrapping the errno) so errors.Is reaches the
-// errno exactly as in production. These fixtures use the POSIX syscall.Exxx
-// constants, which do NOT reproduce a real Windows dial: that carries distinct
-// windows.WSA* errnos (Go's syscall.ECONNREFUSED is a value the net package
-// never produces on Windows). They still classify on Windows only because
-// dialPreSendErrnos there also lists the POSIX constants for exactly this
-// fixture reason; the real Windows dial branch is covered separately by
-// TestIsPreSendTransportErrorRealRefusedDial, which makes an actual refused dial.
-func wrapDialErrno(op string, errno syscall.Errno) error {
-	return &net.OpError{Op: op, Net: "tcp", Err: os.NewSyscallError("connectex", errno)}
-}
-
 type roundTripperFunc func(*http.Request) (*http.Response, error)

 func (f roundTripperFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
@@ -54,152 +35,6 @@ func TestSendWithRetryDoesNotReplayTransportErrors(t *testing.T) {
 	}
 }

-// A PROVABLY pre-send transport failure (no request bytes left this host) is
-// safe to replay and must be retried, bounded by preSendMaxAttempts (its own
-// short schedule), unlike an ambiguous post-send failure. Real dial failures
-// arrive as an Op=="dial" *net.OpError, so the errno cases are the production
-// shape on every platform (Windows included); the string case exercises the
-// wording fallback for a dial error already flattened past its errno.
-func TestSendWithRetryReplaysProvablyPreSendErrors(t *testing.T) {
-	shrinkBackoff(t)
-	cases := map[string]error{
-		"errno refused (dial)":      wrapDialErrno("dial", syscall.ECONNREFUSED),
-		"errno network unreachable": wrapDialErrno("dial", syscall.ENETUNREACH),
-		"errno host unreachable":    wrapDialErrno("dial", syscall.EHOSTUNREACH),
-		"dial string fallback":      &net.OpError{Op: "dial", Net: "tcp", Err: errors.New("connect: connection refused")},
-		"tls handshake timeout":     errors.New("net/http: TLS handshake timeout"),
-		"dns timeout":               &net.DNSError{Err: "server misbehaving", Name: "nope.invalid", IsTimeout: true},
-	}
-	for name, transportErr := range cases {
-		t.Run(name, func(t *testing.T) {
-			var calls int32
-			client := &http.Client{Transport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
-				atomic.AddInt32(&calls, 1)
-				return nil, transportErr
-			})}
-			// maxAttempts=6 (the default) proves the pre-send path is bounded by
-			// preSendMaxAttempts, not the caller's 429-tuned maxAttempts.
-			resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "http://example.invalid", []byte("{}"), nil, 6)
-			if resp != nil {
-				_ = resp.Body.Close()
-			}
-			if err == nil {
-				t.Fatal("expected the transport error to surface after retries are exhausted")
-			}
-			if got := atomic.LoadInt32(&calls); got != preSendMaxAttempts {
-				t.Fatalf("pre-send error tried %d times, want %d (preSendMaxAttempts)", got, preSendMaxAttempts)
-			}
-		})
-	}
-}
-
-// An ambiguous transport failure that could have followed a sent request must
-// NOT be replayed: a non-idempotent completion POST could duplicate billable
-// work. This is the safety line the fix must not cross.
-func TestSendWithRetryDoesNotReplayAmbiguousTransportErrors(t *testing.T) {
-	for name, transportErr := range map[string]error{
-		"generic i/o timeout": errors.New("dial tcp 1.2.3.4:443: i/o timeout"),
-		"broken pipe":         errors.New("write tcp: broken pipe"),
-		"unexpected eof":      io.ErrUnexpectedEOF,
-		// The pre-send errnos are also raised on an ESTABLISHED connection: a route
-		// dropping mid-generation surfaces on the pending read/write, which is
-		// post-send. Scoping to Op=="dial" must keep these from replaying the POST.
-		"host unreachable on read is post-send": wrapDialErrno("read", syscall.EHOSTUNREACH),
-		"net unreachable on write is post-send": wrapDialErrno("write", syscall.ENETUNREACH),
-		// NXDOMAIN is authoritative and deterministic, so retrying it would only
-		// stall the agent before failing anyway.
-		"dns nxdomain": &net.DNSError{Err: "no such host", Name: "nope.invalid", IsNotFound: true},
-	} {
-		t.Run(name, func(t *testing.T) {
-			var calls int32
-			client := &http.Client{Transport: roundTripperFunc(func(*http.Request) (*http.Response, error) {
-				atomic.AddInt32(&calls, 1)
-				return nil, transportErr
-			})}
-			resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "http://example.invalid", []byte("{}"), nil, 3)
-			if resp != nil {
-				_ = resp.Body.Close()
-			}
-			if err == nil {
-				t.Fatal("expected the transport error to surface")
-			}
-			if got := atomic.LoadInt32(&calls); got != 1 {
-				t.Fatalf("ambiguous transport error replayed %d times, want 1 (no retry)", got)
-			}
-		})
-	}
-}
-
-// A REAL refused dial (nothing listening on the target) must classify as
-// pre-send on every platform. This is the regression the errno-constant fixtures
-// miss: on Windows the kernel raises WSAECONNREFUSED, which errors.Is does NOT
-// match against syscall.ECONNREFUSED, so before dialPreSendErrnos carried the WSA
-// codes a refused dial returned false here and Windows never retried it. Using a
-// real Dial exercises the platform's true error shape.
-func TestIsPreSendTransportErrorRealRefusedDial(t *testing.T) {
-	// Reserve an ephemeral port, then close it, so a dial there is refused.
-	ln, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("listen: %v", err)
-	}
-	addr := ln.Addr().String()
-	if cerr := ln.Close(); cerr != nil {
-		t.Fatalf("close listener: %v", cerr)
-	}
-	conn, dialErr := (&net.Dialer{Timeout: 2 * time.Second}).Dial("tcp", addr)
-	if dialErr == nil {
-		_ = conn.Close()
-		t.Skip("expected a refused dial but the port accepted a connection")
-	}
-	if !isPreSendTransportError(dialErr) {
-		t.Fatalf("real refused dial not classified pre-send: %v", dialErr)
-	}
-}
-
-func TestIsPreSendTransportError(t *testing.T) {
-	cases := []struct {
-		name string
-		err  error
-		want bool
-	}{
-		{"nil", nil, false},
-		// DNS: a lookup that could recover is pre-send; NXDOMAIN is permanent.
-		{"dns timeout", &net.DNSError{Err: "server misbehaving", Name: "x.invalid", IsTimeout: true}, true},
-		{"dns temporary", &net.DNSError{Err: "server misbehaving", Name: "x.invalid", IsTemporary: true}, true},
-		{"dns nxdomain is permanent", &net.DNSError{Err: "no such host", Name: "x.invalid", IsNotFound: true}, false},
-		{"tls handshake timeout", errors.New("net/http: TLS handshake timeout"), true},
-		// Errno-wrapped DIAL failures: how a real refused/unreachable dial arrives
-		// on EVERY platform, including Windows where the wording differs entirely.
-		{"errno refused (dial)", wrapDialErrno("dial", syscall.ECONNREFUSED), true},
-		{"errno network unreachable (dial)", wrapDialErrno("dial", syscall.ENETUNREACH), true},
-		{"errno host unreachable (dial)", wrapDialErrno("dial", syscall.EHOSTUNREACH), true},
-		{"dial operror string fallback", &net.OpError{Op: "dial", Net: "tcp", Err: errors.New("connect: connection refused")}, true},
-		// The SAME errnos raised on a post-send read/write are NOT pre-send — the
-		// kernel reports them on an established connection when a route drops.
-		{"host unreachable on read is post-send", wrapDialErrno("read", syscall.EHOSTUNREACH), false},
-		{"net unreachable on write is post-send", wrapDialErrno("write", syscall.ENETUNREACH), false},
-		{"errno reset is post-send", wrapDialErrno("read", syscall.ECONNRESET), false},
-		// A refused/unreachable error already flattened past its *net.OpError can't
-		// be proven pre-send, so it is NOT retried (conservative direction).
-		{"flattened refused, no opError", errors.New("dial tcp 127.0.0.1:1: connect: connection refused"), false},
-		{"connection reset", errors.New("read tcp: connection reset by peer"), false},
-		{"broken pipe", errors.New("write tcp: broken pipe"), false},
-		{"unexpected eof", io.ErrUnexpectedEOF, false},
-		{"eof", io.EOF, false},
-		{"generic io timeout", errors.New("dial tcp: i/o timeout"), false},
-		{"context deadline", context.DeadlineExceeded, false},
-		// Exclusion is checked before inclusion, even for a dial OpError: an "i/o
-		// timeout" in the message wins over the refused wording.
-		{"exclusion wins over inclusion", &net.OpError{Op: "dial", Net: "tcp", Err: errors.New("connection refused / i/o timeout")}, false},
-		{"unrelated", errors.New("some other error"), false},
-	}
-	for _, c := range cases {
-		if got := isPreSendTransportError(c.err); got != c.want {
-			t.Errorf("%s: isPreSendTransportError(%v) = %v, want %v", c.name, c.err, got, c.want)
-		}
-	}
-}
-
 func TestShouldRetryStatus(t *testing.T) {
 	cases := map[int]bool{
 		http.StatusOK:                  false,
@@ -259,17 +94,12 @@ func TestBackoffWaitsThenReturnsTrue(t *testing.T) {
 	}
 }

-// shrinkBackoff makes both retry schedules (429 and pre-send) negligible for the
-// duration of a test.
+// shrinkBackoff makes retry waits negligible for the duration of a test.
 func shrinkBackoff(t *testing.T) {
 	t.Helper()
-	savedRetry, savedPreSend := retryBackoffBase, preSendBackoffBase
+	saved := retryBackoffBase
 	retryBackoffBase = time.Millisecond
-	preSendBackoffBase = time.Millisecond
-	t.Cleanup(func() {
-		retryBackoffBase = savedRetry
-		preSendBackoffBase = savedPreSend
-	})
+	t.Cleanup(func() { retryBackoffBase = saved })
 }

 func TestBackoffWaitSchedule(t *testing.T) {
@@ -296,30 +126,6 @@ func TestBackoffWaitSchedule(t *testing.T) {
 	}
 }

-// The pre-send schedule is sub-second and doubles, far shorter than the 429
-// schedule: a permanent dial failure fails in ~1.5s across preSendMaxAttempts
-// (500ms + 1s) instead of stalling the agent ~60s on 2/4/8/16/30s. This is the
-// second half of the fix for a mistyped host / dead local daemon hanging a turn.
-func TestPreSendBackoffWaitSchedule(t *testing.T) {
-	cases := []struct {
-		attempt int
-		want    time.Duration
-	}{
-		{1, 500 * time.Millisecond},
-		{2, 1 * time.Second},
-		{3, 2 * time.Second},
-		// The exponent clamps at 5 (500ms<<5 = 16s) so a large attempt count can't
-		// overflow; in practice preSendMaxAttempts caps retries at attempt 2, so
-		// only the 500ms/1s rungs are ever reached.
-		{50, 16 * time.Second},
-	}
-	for _, c := range cases {
-		if got := preSendBackoffWait(c.attempt); got != c.want {
-			t.Errorf("preSendBackoffWait(%d) = %v, want %v", c.attempt, got, c.want)
-		}
-	}
-}
-
 func TestSendWithRetryRetriesThenSucceeds(t *testing.T) {
 	shrinkBackoff(t)
 	var hits int32
@@ -387,316 +193,3 @@ func TestSendWithRetryReturnsLastResponseAfterMaxAttempts(t *testing.T) {
 		t.Fatalf("server hit %d times, want 2 (maxAttempts)", got)
 	}
 }
-
-// Redirects are still followed, so a gateway that answers the completion endpoint
-// with a 307/308 keeps working: the caller gets the final response, not the 3xx.
-func TestSendWithRetryFollowsRedirects(t *testing.T) {
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		if atomic.AddInt32(&calls, 1) == 1 {
-			return &http.Response{
-				StatusCode: http.StatusTemporaryRedirect,
-				Header:     http.Header{"Location": {"https://redirect-target.invalid/v1"}},
-				Body:       http.NoBody,
-				Request:    r,
-			}, nil
-		}
-		return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, Request: r}, nil
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://origin.invalid/v1", []byte("{}"), nil, 3)
-	if err != nil {
-		t.Fatalf("a redirected completion must succeed: %v", err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("status = %d, want 200 (the redirect should have been followed)", resp.StatusCode)
-	}
-	if got := atomic.LoadInt32(&calls); got != 2 {
-		t.Fatalf("transport called %d times, want 2 (origin then redirect target)", got)
-	}
-}
-
-// Once an attempt has entered a redirect, the original POST has already left this
-// host, so a dial failure on the redirect hop must NOT be replayed even though it
-// arrives as an Op=="dial" error that isPreSendTransportError would otherwise
-// treat as provably pre-send. Replaying it would re-bill a completion the first
-// host may already have processed.
-func TestSendWithRetryDoesNotReplayAfterRedirect(t *testing.T) {
-	shrinkBackoff(t)
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		if atomic.AddInt32(&calls, 1) == 1 {
-			return &http.Response{
-				StatusCode: http.StatusTemporaryRedirect,
-				Header:     http.Header{"Location": {"https://redirect-target.invalid/v1"}},
-				Body:       http.NoBody,
-				Request:    r,
-			}, nil
-		}
-		// The dial to the redirect target fails: pre-send in shape, but post-send
-		// in fact, because the origin already received the POST.
-		return nil, wrapDialErrno("dial", syscall.ECONNREFUSED)
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://origin.invalid/v1", []byte("{}"), nil, 6)
-	if resp != nil {
-		_ = resp.Body.Close()
-	}
-	if err == nil {
-		t.Fatal("expected the redirect-hop dial failure to surface as an error")
-	}
-	// Exactly two: the origin request and the single redirect hop. A third would
-	// mean the redirected POST was replayed.
-	if got := atomic.LoadInt32(&calls); got != 2 {
-		t.Fatalf("redirected POST was replayed: transport called %d times, want 2", got)
-	}
-}
-
-// A caller that supplies its own CheckRedirect keeps it: the retry path observes
-// redirects, it does not take the decision away from the caller.
-func TestSendWithRetryPreservesCallerRedirectPolicy(t *testing.T) {
-	var policyCalls int32
-	client := &http.Client{
-		CheckRedirect: func(*http.Request, []*http.Request) error {
-			atomic.AddInt32(&policyCalls, 1)
-			return http.ErrUseLastResponse
-		},
-		Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-			return &http.Response{
-				StatusCode: http.StatusTemporaryRedirect,
-				Header:     http.Header{"Location": {"https://redirect-target.invalid/v1"}},
-				Body:       http.NoBody,
-				Request:    r,
-			}, nil
-		}),
-	}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://origin.invalid/v1", []byte("{}"), nil, 3)
-	if err != nil {
-		t.Fatalf("caller policy asked to stop at the 3xx, so it must surface: %v", err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode != http.StatusTemporaryRedirect {
-		t.Fatalf("status = %d, want the 307 surfaced per the caller's policy", resp.StatusCode)
-	}
-	if got := atomic.LoadInt32(&policyCalls); got != 1 {
-		t.Fatalf("caller CheckRedirect called %d times, want 1 (it must not be discarded)", got)
-	}
-}
-
-// The pre-send retry budget is independent of the 429/503 status retries: two
-// rate-limit responses must not consume the pre-send allowance, so the first
-// refused dial after them still gets its own preSendMaxAttempts tries.
-func TestSendWithRetryPreSendBudgetSurvivesStatusRetries(t *testing.T) {
-	shrinkBackoff(t)
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		if atomic.AddInt32(&calls, 1) <= 2 {
-			return &http.Response{StatusCode: http.StatusTooManyRequests, Body: http.NoBody, Request: r}, nil
-		}
-		return nil, wrapDialErrno("dial", syscall.ECONNREFUSED)
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://x.invalid/v1", []byte("{}"), nil, 6)
-	if resp != nil {
-		_ = resp.Body.Close()
-	}
-	if err == nil {
-		t.Fatal("expected the exhausted pre-send failure to surface as an error")
-	}
-	// Two status responses (calls 1-2), then the pre-send failure gets its own
-	// budget: preSendMaxAttempts=3 means it retries twice more before returning.
-	if got := atomic.LoadInt32(&calls); got != 2+preSendMaxAttempts {
-		t.Fatalf("pre-send budget eaten by status retries: transport called %d times, want %d (2 status + %d pre-send)", got, 2+preSendMaxAttempts, preSendMaxAttempts)
-	}
-}
-
-// The inverse sequence: pre-send retries must not consume the 429/503 budget or
-// advance its backoff rung either. Two safely replayed refused dials followed by
-// rate limiting must still leave the status path its full maxAttempts window,
-// otherwise a couple of dial blips silently shorten every later rate-limit wait.
-func TestSendWithRetryStatusBudgetSurvivesPreSendRetries(t *testing.T) {
-	shrinkBackoff(t)
-	const maxAttempts = 3
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		if atomic.AddInt32(&calls, 1) <= 2 {
-			return nil, wrapDialErrno("dial", syscall.ECONNREFUSED)
-		}
-		return &http.Response{StatusCode: http.StatusTooManyRequests, Body: http.NoBody, Request: r}, nil
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://x.invalid/v1", []byte("{}"), nil, maxAttempts)
-	if err != nil {
-		t.Fatalf("exhausted status retries surface the response, not an error: %v", err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode != http.StatusTooManyRequests {
-		t.Fatalf("status = %d, want 429", resp.StatusCode)
-	}
-	// Calls 1-2 are the retried dial failures; the status path then gets its own
-	// full window (maxAttempts requests) before the 429 is surfaced.
-	if got := atomic.LoadInt32(&calls); got != 2+maxAttempts {
-		t.Fatalf("status budget eaten by pre-send retries: transport called %d times, want %d (2 pre-send + %d status)", got, 2+maxAttempts, maxAttempts)
-	}
-}
-
-// A redirect followed by a RETRYABLE STATUS is still retried, and deliberately
-// so. This is the case a reviewer flagged as a possible replay of billable work,
-// and the asymmetry with the transport-error guard above is intentional rather
-// than an oversight, so it is pinned here.
-//
-// The two situations differ in what is known about the request:
-//
-//   - Transport error after a redirect: the original POST reached the origin and
-//     the dial to the redirect target then failed, so whether the target received
-//     and began processing it is UNKNOWN. Replaying could duplicate work, which
-//     is why that path refuses to retry.
-//   - Retryable status after a redirect: every hop answered. A 307/308 is the
-//     origin declining to process and delegating, and a 429/503/529 is the target
-//     declining as well. Nothing accepted the request, so replaying duplicates
-//     nothing.
-//
-// The risk here is also exactly the risk of a 429 without any redirect, which
-// this package has always retried; the redirect adds no new ambiguity. Refusing
-// to retry would instead make a rate-limited completion behind a redirecting
-// gateway fail outright rather than back off.
-func TestSendWithRetryRetriesRedirectedRetryableStatus(t *testing.T) {
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		switch atomic.AddInt32(&calls, 1) {
-		case 1, 3:
-			// The origin declines and delegates, both times.
-			return &http.Response{
-				StatusCode: http.StatusTemporaryRedirect,
-				Header:     http.Header{"Location": {"https://redirect-target.invalid/v1"}},
-				Body:       http.NoBody,
-				Request:    r,
-			}, nil
-		case 2:
-			// The target declines too: rate limited, so nothing was accepted.
-			return &http.Response{StatusCode: http.StatusTooManyRequests, Body: http.NoBody, Request: r}, nil
-		default:
-			return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, Request: r}, nil
-		}
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://origin.invalid/v1", []byte("{}"), nil, 3)
-	if err != nil {
-		t.Fatalf("a rate-limited completion behind a redirect must still retry: %v", err)
-	}
-	_ = resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("status = %d, want 200 after the retry succeeded", resp.StatusCode)
-	}
-	// origin, target(429), origin, target(200).
-	if got := atomic.LoadInt32(&calls); got != 4 {
-		t.Fatalf("transport called %d times, want 4 (redirect, 429, redirect, 200)", got)
-	}
-}
-
-// A CONNECT-phase timeout is provably pre-send: the connection was never
-// established, so no request bytes left this host. It reaches the classifier
-// carrying "i/o timeout", which the blanket wording exclusion rejects, so
-// admitting it depends on the connect gate running first.
-//
-// The post-send counterpart is the point of the table: a read timeout is also
-// Timeout(), and must stay excluded, or a reply that timed out mid-generation
-// would replay a completion the server already billed.
-func TestPreSendClassifiesConnectTimeouts(t *testing.T) {
-	timeoutErr := &timeoutError{}
-	for name, testCase := range map[string]struct {
-		err  error
-		want bool
-	}{
-		"dial timeout": {
-			err:  &net.OpError{Op: "dial", Net: "tcp", Err: timeoutErr},
-			want: true,
-		},
-		"proxy connect timeout": {
-			err:  &net.OpError{Op: "proxyconnect", Net: "tcp", Err: timeoutErr},
-			want: true,
-		},
-		"read timeout stays post-send": {
-			err:  &net.OpError{Op: "read", Net: "tcp", Err: timeoutErr},
-			want: false,
-		},
-		"write timeout stays post-send": {
-			err:  &net.OpError{Op: "write", Net: "tcp", Err: timeoutErr},
-			want: false,
-		},
-	} {
-		t.Run(name, func(t *testing.T) {
-			if got := isPreSendTransportError(testCase.err); got != testCase.want {
-				t.Fatalf("isPreSendTransportError(%v) = %v, want %v", testCase.err, got, testCase.want)
-			}
-		})
-	}
-}
-
-// A failed CONNECT through an HTTP proxy is pre-send for the same structural
-// reason a refused dial is, but net tags it Op "proxyconnect", so a gate
-// matching only "dial" left every pre-send failure behind a corporate proxy
-// unretried.
-func TestPreSendClassifiesProxyConnectRefusal(t *testing.T) {
-	err := &net.OpError{Op: "proxyconnect", Net: "tcp", Err: syscall.ECONNREFUSED}
-	if !isPreSendTransportError(err) {
-		t.Fatal("a refused proxy CONNECT was not classified pre-send; no request bytes reached the model host")
-	}
-	// The op still has to be a connect phase. The same errno on an established
-	// connection is post-send and must not replay a POST.
-	post := &net.OpError{Op: "read", Net: "tcp", Err: syscall.ECONNREFUSED}
-	if isPreSendTransportError(post) {
-		t.Fatal("a read-phase error was classified pre-send")
-	}
-}
-
-// timeoutError is a net.Error whose Timeout() is true, matching the shape
-// net/http surfaces for a connect deadline.
-type timeoutError struct{}
-
-func (timeoutError) Error() string   { return "i/o timeout" }
-func (timeoutError) Timeout() bool   { return true }
-func (timeoutError) Temporary() bool { return true }
-
-// The pre-send budget bounds CONSECUTIVE connect failures, not the lifetime of
-// the call. Without a reset on a successful hop, an early run of dial blips
-// permanently spends the budget, so a later blip surfaces as a transport error
-// while the status budget still has room. That is the coupling the two counters
-// were split apart to remove, in the one ordering the earlier tests did not
-// cover: pre-send, then status, then pre-send again.
-func TestPreSendBudgetResetsAfterSuccessfulHop(t *testing.T) {
-	refused := &net.OpError{Op: "dial", Net: "tcp", Err: syscall.ECONNREFUSED}
-	var calls int32
-	client := &http.Client{Transport: roundTripperFunc(func(r *http.Request) (*http.Response, error) {
-		switch atomic.AddInt32(&calls, 1) {
-		case 1, 2:
-			// Two connect failures, spending the pre-send budget under the old
-			// lifetime accounting.
-			return nil, refused
-		case 3:
-			// A hop that reaches the server. It declines, so the request was not
-			// accepted and retrying stays safe.
-			return &http.Response{StatusCode: http.StatusTooManyRequests, Body: http.NoBody, Request: r}, nil
-		case 4:
-			// One more connect blip. With a lifetime cap this surfaces as an
-			// error; the call should still recover.
-			return nil, refused
-		default:
-			return &http.Response{StatusCode: http.StatusOK, Body: http.NoBody, Request: r}, nil
-		}
-	})}
-
-	resp, err := SendWithRetry(context.Background(), client, http.MethodPost, "https://origin.invalid/v1", []byte("{}"), nil, 3)
-	if err != nil {
-		t.Fatalf("interleaved connect and status failures returned %v; the pre-send budget did not reset after the hop that reached the server", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		t.Fatalf("status = %d, want 200", resp.StatusCode)
-	}
-	if got := atomic.LoadInt32(&calls); got != 5 {
-		t.Fatalf("transport called %d times, want 5 (dial, dial, 429, dial, 200)", got)
-	}
-}
@@ -188,7 +188,7 @@ func writePromptLine(builder *strings.Builder, format string, args ...any) {
 	if builder.Len() > 0 {
 		builder.WriteByte('\n')
 	}
-	fmt.Fprintf(builder, format, args...)
+	builder.WriteString(fmt.Sprintf(format, args...))
 }

 func clampBudget(text string, budget int) string {
@@ -225,7 +225,7 @@ func (backend Backend) SandboxEnvMarkers(policy Policy) []string {
 	if policy.Mode == ModeDisabled {
 		return nil
 	}
-	if (!backend.CommandWrapping || !backend.Available) && backend.Name != BackendWSL {
+	if !(backend.CommandWrapping && backend.Available) && backend.Name != BackendWSL {
 		return nil
 	}
 	name := backend.Name
@@ -27,22 +27,11 @@ var destructivePrograms = map[string]bool{
 	"mkfs": true, "fdisk": true, "shred": true, "dd": true, "parted": true,
 }

-var powerShellRemoveItemPrograms = map[string]bool{
-	"remove-item": true,
-	"ri":          true,
-	"rd":          true,
-	"rmdir":       true,
-	"del":         true,
-	"erase":       true,
-	"rm":          true,
-}
-
 // networkPrograms are commands that perform network egress/ingress.
 var networkPrograms = map[string]bool{
 	"curl": true, "wget": true, "ssh": true, "scp": true, "sftp": true,
 	"rsync": true, "nc": true, "ncat": true, "netcat": true, "telnet": true,
-	"ftp": true, "iwr": true, "irm": true, "invoke-webrequest": true,
-	"invoke-restmethod": true,
+	"ftp": true,
 }

 var localServerPrograms = map[string]bool{
@@ -183,10 +172,7 @@ func analyzeInto(script string, result *AnalysisResult, seen map[string]bool, de
 		if commandUsesNetwork(prog, rest) {
 			result.Network = true
 		}
-		if destructivePrograms[prog] ||
-			(prog == "rm" && hasRecursiveForce(rest)) ||
-			(powerShellRemoveItemPrograms[prog] && hasPowerShellRecursiveForce(rest)) ||
-			(prog == "find" && hasFindDelete(rest)) {
+		if destructivePrograms[prog] || (prog == "rm" && hasRecursiveForce(rest)) || (prog == "find" && hasFindDelete(rest)) {
 			result.Destructive = true
 		}
 		return true
@@ -493,19 +479,6 @@ func hasRecursiveForce(args []*syntax.Word) bool {
 	return recursive && force
 }

-func hasPowerShellRecursiveForce(args []*syntax.Word) bool {
-	recursive, force := false, false
-	for _, arg := range args {
-		switch strings.ToLower(wordText(arg)) {
-		case "-recurse", "-r":
-			recursive = true
-		case "-force":
-			force = true
-		}
-	}
-	return recursive && force
-}
-
 func hasFindDelete(args []*syntax.Word) bool {
 	for _, arg := range args {
 		if wordText(arg) == "-delete" {
@@ -45,27 +45,6 @@ func TestAnalyzeCommand(t *testing.T) {
 		{name: "sudo dynamic flag then rm -rf", script: `sudo "$maybe" rm -rf /tmp/x`, destructive: true},

 		{name: "curl", script: "curl https://example.com", network: true},
-		{name: "PowerShell iwr alias", script: "iwr https://example.com", network: true},
-		{name: "PowerShell irm alias", script: "irm https://example.com", network: true},
-		{name: "PowerShell Invoke-WebRequest", script: "Invoke-WebRequest https://example.com", network: true},
-		{name: "PowerShell Invoke-RestMethod", script: "Invoke-RestMethod https://example.com", network: true},
-		{name: "PowerShell Remove-Item recursive force", script: `Remove-Item -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell rm recursive force", script: `rm -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell ri recursive force", script: `ri -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell rd recursive force", script: `rd -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell rmdir recursive force", script: `rmdir -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell del recursive force", script: `del -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell erase recursive force", script: `erase -Recurse -Force 'C:\temp\x'`, destructive: true},
-		{name: "PowerShell ambiguous force abbreviation", script: `Remove-Item -Recurse -f 'C:\temp\x'`, destructive: false},
-		{name: "PowerShell Remove-Item without recurse", script: `Remove-Item -Force 'C:\temp\x'`, destructive: false},
-		{name: "Windows curl cmd", script: "curl.cmd https://example.com", network: true},
-		{name: "Windows curl exe", script: "curl.exe https://example.com", network: true},
-		{name: "Windows drive path curl exe", script: `'C:\tools\curl.exe' https://example.com`, network: true},
-		{name: "Windows UNC path curl exe", script: `'\\server\share\curl.exe' https://example.com`, network: true},
-		{name: "Windows dot relative path curl exe", script: `'.\curl.exe' https://example.com`, network: true},
-		{name: "Windows relative path curl exe", script: `'tools\curl.exe' https://example.com`, network: true},
-		{name: "Windows drive relative path curl exe", script: `'C:curl.exe' https://example.com`, network: true},
-		{name: "Windows npm cmd", script: "npm.cmd install", network: true},
 		{name: "wget piped to shell", script: "wget -qO- https://x.test | sh", network: true},
 		{name: "python http server", script: "python3 -m http.server 8000", network: true},
 		{name: "python pip install", script: "python3 -m pip install requests", network: true},
@@ -153,7 +153,10 @@ func unsafeCommandPrefix(prefix []string) bool {
 			return true
 		}
 	}
-	return unsafeCommandPrefixLauncher(prefix[0])
+	if unsafeCommandPrefixLauncher(prefix[0]) {
+		return true
+	}
+	return false
 }

 func unsafeCommandPrefixPart(part string) bool {
@@ -249,7 +249,7 @@ func (engine *Engine) shellSandboxActive(policy Policy) bool {
 		return false
 	}
 	backend := engine.backend
-	if !backend.Available || backend.Executable == "" || !backend.CommandWrapping || !backend.NativeIsolation {
+	if !(backend.Available && backend.Executable != "" && backend.CommandWrapping && backend.NativeIsolation) {
 		return false
 	}
 	// On Windows the command is only actually wrapped once `zero sandbox setup`
@@ -74,25 +74,6 @@ func TestEngineBashAllowGrantDoesNotBypassNetworkPrompt(t *testing.T) {
 	}
 }

-func TestEngineClassifiesPowerShellCurlCommandAsNetwork(t *testing.T) {
-	engine := NewEngine(EngineOptions{
-		WorkspaceRoot: t.TempDir(),
-		Policy:        DefaultPolicy(),
-	})
-	decision := engine.Evaluate(context.Background(), Request{
-		ToolName:       "bash",
-		SideEffect:     SideEffectShell,
-		Permission:     PermissionPrompt,
-		PermissionMode: PermissionModeAsk,
-		Args: map[string]any{
-			"command": `$env:PATH = '.;' + $env:PATH; curl.cmd https://example.com`,
-		},
-	})
-	if decision.Action != ActionPrompt || decision.Reason != ReasonNetworkBlocked || !HasRiskCategory(decision.Risk, "network") {
-		t.Fatalf("PowerShell curl command decision = %#v, want network prompt", decision)
-	}
-}
-
 func TestUnsandboxedExecutionAllowedPreservesDeniedReads(t *testing.T) {
 	root := t.TempDir()
 	policy := DefaultPolicy()
@@ -16,11 +16,7 @@ import (
 	"github.com/Gitlawb/zero/internal/redaction"
 )

-const (
-	grantSchemaVersion = 3
-	grantLockTimeout   = 5 * time.Second
-	grantLockRetry     = 10 * time.Millisecond
-)
+const grantSchemaVersion = 3

 type Grant struct {
 	ToolName   string        `json:"toolName"`
@@ -143,40 +139,7 @@ func (store *GrantStore) ConsumeMigrationNotice() (string, error) {
 	}
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	// Look for a pending notice WITHOUT taking the interprocess lock. Acquiring
-	// that lock creates the grants directory and opens <grants>.lockfile, so doing
-	// it unconditionally would make this call require a WRITABLE grants directory
-	// even when it has nothing to write. Every startup and every `zero exec` calls
-	// this, so a user with no grants file whose configured grants path (or its
-	// parent) sits on a read-only mount would fail outright with "failed to
-	// migrate sandbox grants", where reading alone reports an empty state and
-	// writes nothing.
-	state, needsMigration, err := store.readStateFile(false)
-	if err != nil {
-		return "", err
-	}
-	if !needsMigration && (state.Migration == nil || !state.Migration.NoticePending) {
-		return "", nil
-	}
-	// Past here a write is genuinely required — either a schema/policy migration,
-	// which only a lock holder may perform, or clearing NoticePending — so the
-	// lock is warranted and a read-only grants path legitimately fails (as it did
-	// before this lock existed, via readState's own migration path).
-	//
-	// Clearing the pending flag is a read-modify-write like any other mutator, so
-	// it takes the same interprocess lock: two frontends starting at once must not
-	// both read NoticePending, both print the notice, and clobber each other's
-	// write of the rest of the state.
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return "", err
-	}
-	defer unlock()
-	// Re-read under the lock. The unlocked peek above is only a snapshot: another
-	// process may have consumed the notice or migrated the file while this one
-	// waited, and when needsMigration was set that snapshot's contents are
-	// meaningless by readStateFile's contract.
-	state, err = store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return "", err
 	}
@@ -198,13 +161,7 @@ func (store *GrantStore) Grant(input GrantInput) (Grant, error) {
 	}
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return Grant{}, err
-	}
-	defer unlock()
-
-	state, err := store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return Grant{}, err
 	}
@@ -236,13 +193,7 @@ func (store *GrantStore) GrantCommandPrefix(input CommandPrefixInput) (CommandPr
 	}
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return CommandPrefixGrant{}, err
-	}
-	defer unlock()
-
-	state, err := store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return CommandPrefixGrant{}, err
 	}
@@ -386,13 +337,7 @@ func (store *GrantStore) Revoke(toolName string) (int, error) {
 	}
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return 0, err
-	}
-	defer unlock()
-
-	state, err := store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return 0, err
 	}
@@ -427,13 +372,7 @@ func (store *GrantStore) RevokePath(toolName string, scopePath string) (int, err
 	}
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return 0, err
-	}
-	defer unlock()
-
-	state, err := store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return 0, err
 	}
@@ -468,13 +407,7 @@ func (store *GrantStore) RevokePath(toolName string, scopePath string) (int, err
 func (store *GrantStore) Clear() (int, error) {
 	store.mu.Lock()
 	defer store.mu.Unlock()
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return 0, err
-	}
-	defer unlock()
-
-	state, err := store.readStateLocked()
+	state, err := store.readState()
 	if err != nil {
 		return 0, err
 	}
@@ -604,52 +537,7 @@ func reconcileScope(scope string, kind ScopeKind) (string, ScopeKind) {
 	return scope, kind
 }

-// readState reads the grant file for a caller that does NOT hold the
-// interprocess lock (the lookup/list paths). A schema or policy migration has to
-// write — a backup plus the migrated state — so it is performed under the lock,
-// and the read is retaken there because another process may have migrated the
-// file while this one waited.
 func (store *GrantStore) readState() (grantFile, error) {
-	state, needsMigration, err := store.readStateFile(false)
-	if err != nil || !needsMigration {
-		return state, err
-	}
-	unlock, err := store.lockStateFile()
-	if err != nil {
-		return grantFile{}, err
-	}
-	defer unlock()
-	return store.readStateLocked()
-}
-
-// readStateLocked reads the grant file for a caller that already holds the
-// interprocess lock, so a migration writes through directly instead of
-// re-acquiring it (which would deadlock against the caller's own lock).
-func (store *GrantStore) readStateLocked() (grantFile, error) {
-	state, _, err := store.readStateFile(true)
-	return state, err
-}
-
-// readStateFile decodes the grant file. needsMigration reports that the state on
-// disk must be rewritten (legacy schema or a changed policy version) and that the
-// caller has to retake this read while holding the interprocess lock; the
-// returned state is meaningless in that case.
-func (store *GrantStore) readStateFile(locked bool) (grantFile, bool, error) {
-	state, err := store.decodeState(locked)
-	if err != nil {
-		if errors.Is(err, errGrantMigrationNeedsLock) {
-			return grantFile{}, true, nil
-		}
-		return grantFile{}, false, err
-	}
-	return state, false, nil
-}
-
-// errGrantMigrationNeedsLock is the internal signal from decodeState that the
-// file needs a migration write, which only a lock holder may perform.
-var errGrantMigrationNeedsLock = errors.New("sandbox grants file needs a migration write")
-
-func (store *GrantStore) decodeState(locked bool) (grantFile, error) {
 	data, err := os.ReadFile(store.filePath)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
@@ -671,18 +559,12 @@ func (store *GrantStore) decodeState(locked bool) (grantFile, error) {
 		return grantFile{}, store.invalidGrantFile(err)
 	}
 	if head.SchemaVersion == 1 || head.SchemaVersion == 2 {
-		if !locked {
-			return grantFile{}, errGrantMigrationNeedsLock
-		}
 		return store.migrateLegacyState(data, head.SchemaVersion, head.Grants, head.CommandPrefixes)
 	}
 	if head.SchemaVersion != grantSchemaVersion {
 		return grantFile{}, fmt.Errorf("invalid sandbox grants file at %s: unsupported schemaVersion", store.filePath)
 	}
 	if head.PolicyVersion != execution.PolicyVersion {
-		if !locked {
-			return grantFile{}, errGrantMigrationNeedsLock
-		}
 		return store.migrateChangedPolicy(data, head.PolicyVersion, head.Grants, head.CommandPrefixes)
 	}
 	buckets := map[string][]Grant{}
@@ -918,36 +800,6 @@ func (store *GrantStore) writeState(state grantFile) error {
 	return nil
 }

-func (store *GrantStore) lockStateFile() (func(), error) {
-	lockPath := store.filePath + ".lockfile"
-	if err := os.MkdirAll(filepath.Dir(store.filePath), 0o700); err != nil {
-		return nil, err
-	}
-	file, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o600)
-	if err != nil {
-		return nil, err
-	}
-	deadline := time.Now().Add(grantLockTimeout)
-	for {
-		locked, err := tryLockGrantFile(file)
-		if err != nil {
-			_ = file.Close()
-			return nil, err
-		}
-		if locked {
-			return func() {
-				_ = unlockGrantFile(file)
-				_ = file.Close()
-			}, nil
-		}
-		if time.Now().After(deadline) {
-			_ = file.Close()
-			return nil, fmt.Errorf("timed out waiting for sandbox grants lock at %s", lockPath)
-		}
-		time.Sleep(grantLockRetry)
-	}
-}
-
 func normalizeStoredGrant(name string, grant Grant) (Grant, error) {
 	if strings.TrimSpace(grant.ToolName) == "" {
 		grant.ToolName = name
@@ -1,24 +0,0 @@
-//go:build !windows
-
-package sandbox
-
-import (
-	"errors"
-	"os"
-	"syscall"
-)
-
-func tryLockGrantFile(file *os.File) (bool, error) {
-	err := syscall.Flock(int(file.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
-	if err == nil {
-		return true, nil
-	}
-	if errors.Is(err, syscall.EWOULDBLOCK) || errors.Is(err, syscall.EAGAIN) {
-		return false, nil
-	}
-	return false, err
-}
-
-func unlockGrantFile(file *os.File) error {
-	return syscall.Flock(int(file.Fd()), syscall.LOCK_UN)
-}
@@ -1,60 +0,0 @@
-//go:build windows
-
-package sandbox
-
-import (
-	"errors"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-const (
-	grantLockfileFailImmediately = 0x00000001
-	grantLockfileExclusiveLock   = 0x00000002
-	grantErrorLockViolation      = syscall.Errno(33)
-	grantErrorSharingViolation   = syscall.Errno(32)
-)
-
-var (
-	grantKernel32         = syscall.NewLazyDLL("kernel32.dll")
-	grantProcLockFileEx   = grantKernel32.NewProc("LockFileEx")
-	grantProcUnlockFileEx = grantKernel32.NewProc("UnlockFileEx")
-)
-
-func tryLockGrantFile(file *os.File) (bool, error) {
-	var overlapped syscall.Overlapped
-	result, _, err := grantProcLockFileEx.Call(
-		file.Fd(),
-		uintptr(grantLockfileExclusiveLock|grantLockfileFailImmediately),
-		0,
-		1,
-		0,
-		uintptr(unsafe.Pointer(&overlapped)),
-	)
-	if result != 0 {
-		return true, nil
-	}
-	if errors.Is(err, grantErrorLockViolation) || errors.Is(err, grantErrorSharingViolation) {
-		return false, nil
-	}
-	if err == syscall.Errno(0) {
-		return false, nil
-	}
-	return false, err
-}
-
-func unlockGrantFile(file *os.File) error {
-	var overlapped syscall.Overlapped
-	result, _, err := grantProcUnlockFileEx.Call(
-		file.Fd(),
-		0,
-		1,
-		0,
-		uintptr(unsafe.Pointer(&overlapped)),
-	)
-	if result != 0 || err == syscall.Errno(0) {
-		return nil
-	}
-	return err
-}
@@ -1,13 +1,10 @@
 package sandbox

 import (
-	"errors"
 	"os"
 	"path/filepath"
-	"runtime"
 	"strings"
 	"testing"
-	"time"
 )

 func TestGrantStorePersistsListsRevokesAndClears(t *testing.T) {
@@ -73,246 +70,6 @@ func TestGrantStorePersistsListsRevokesAndClears(t *testing.T) {
 	}
 }

-func TestGrantStoreSerializesWritesAcrossStores(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "sandbox-grants.json")
-	storeA, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore A returned error: %v", err)
-	}
-	storeB, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore B returned error: %v", err)
-	}
-
-	unlock, err := storeA.lockStateFile()
-	if err != nil {
-		t.Fatalf("lockStateFile returned error: %v", err)
-	}
-
-	done := make(chan error, 1)
-	go func() {
-		_, err := storeB.Grant(GrantInput{ToolName: "write_file", Decision: GrantAllow})
-		done <- err
-	}()
-
-	select {
-	case err := <-done:
-		unlock()
-		t.Fatalf("Grant completed while another store held the file lock: %v", err)
-	case <-time.After(100 * time.Millisecond):
-		// Expected: storeB is waiting for storeA to release the lock.
-	}
-
-	unlock()
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Fatalf("Grant returned error after file lock release: %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("Grant did not complete after file lock release")
-	}
-}
-
-// TestGrantStoreSerializesMigrationNoticeAcrossStores covers the other
-// read-modify-write on the state file: clearing the pending flag. Two frontends
-// starting at once must not both read it as pending and clobber each other.
-func TestGrantStoreSerializesMigrationNoticeAcrossStores(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "sandbox-grants.json")
-	if err := writeText(path, `{"schemaVersion":1,"grants":{"write_file":{"toolName":"write_file","decision":"allow","approvedAt":"2026-06-05T14:30:00Z"}}}`); err != nil {
-		t.Fatalf("write v1 grants: %v", err)
-	}
-	storeA, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore A returned error: %v", err)
-	}
-	storeB, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore B returned error: %v", err)
-	}
-	// Migrate first, so the notice is pending and the lock contention below is
-	// about consuming it rather than about the migration write.
-	if _, err := storeA.List(); err != nil {
-		t.Fatalf("List returned error: %v", err)
-	}
-
-	unlock, err := storeA.lockStateFile()
-	if err != nil {
-		t.Fatalf("lockStateFile returned error: %v", err)
-	}
-	done := make(chan error, 1)
-	go func() {
-		notice, err := storeB.ConsumeMigrationNotice()
-		if err == nil && notice == "" {
-			err = errors.New("expected the pending migration notice")
-		}
-		done <- err
-	}()
-
-	select {
-	case err := <-done:
-		unlock()
-		t.Fatalf("ConsumeMigrationNotice completed while another store held the file lock: %v", err)
-	case <-time.After(100 * time.Millisecond):
-		// Expected: storeB is waiting for storeA to release the lock.
-	}
-
-	unlock()
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Fatalf("ConsumeMigrationNotice after lock release: %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("ConsumeMigrationNotice did not complete after file lock release")
-	}
-	// The flag write landed, so the notice is not reported twice.
-	if again, err := storeA.ConsumeMigrationNotice(); err != nil || again != "" {
-		t.Fatalf("second ConsumeMigrationNotice = %q err=%v, want empty", again, err)
-	}
-}
-
-// TestConsumeMigrationNoticeWritesNothingWithoutAPendingNotice is the regression
-// test for jatmn's #755 finding: ConsumeMigrationNotice took the interprocess
-// lock unconditionally, and acquiring that lock MkdirAlls the grants directory
-// and creates <grants>.lockfile. Every startup and every `zero exec` calls this,
-// so it turned "read the grants state" into "require a writable grants
-// directory" — a user with no grants file whose grants path sat on a read-only
-// mount failed outright with "failed to migrate sandbox grants".
-//
-// Asserting that nothing is created is the portable form of that requirement: it
-// holds identically on every OS and as any user, unlike a read-only-directory
-// test (see the sibling test, which cannot run everywhere).
-func TestConsumeMigrationNoticeWritesNothingWithoutAPendingNotice(t *testing.T) {
-	dir := filepath.Join(t.TempDir(), "config")
-	path := filepath.Join(dir, "sandbox-grants.json")
-	store, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore returned error: %v", err)
-	}
-
-	notice, err := store.ConsumeMigrationNotice()
-	if err != nil {
-		t.Fatalf("ConsumeMigrationNotice with no grants file: %v", err)
-	}
-	if notice != "" {
-		t.Fatalf("notice = %q, want empty when nothing was migrated", notice)
-	}
-	// Nothing at all may be created: not the lock file, not the grants file, not
-	// even the directory that would hold them.
-	if _, err := os.Lstat(dir); !os.IsNotExist(err) {
-		entries, _ := os.ReadDir(dir)
-		names := make([]string, 0, len(entries))
-		for _, entry := range entries {
-			names = append(names, entry.Name())
-		}
-		t.Fatalf("the grants directory was created (contents: %v); reading a state with no pending notice must not require a writable directory", names)
-	}
-}
-
-// TestConsumeMigrationNoticeToleratesAReadOnlyGrantsDirectory exercises the
-// actual failure from the same finding, rather than only its portable proxy
-// above: with the grants directory read-only and no grants file, the pre-fix
-// code failed at MkdirAll/OpenFile for the lock file.
-//
-// It cannot run everywhere — Windows ignores the mode bits used here, and root
-// bypasses directory permissions entirely — so it skips instead of pretending to
-// cover those platforms.
-func TestConsumeMigrationNoticeToleratesAReadOnlyGrantsDirectory(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("Unix directory mode bits do not deny writes on Windows")
-	}
-	if os.Geteuid() == 0 {
-		t.Skip("root bypasses directory permissions, so a read-only directory cannot be simulated")
-	}
-	dir := t.TempDir()
-	path := filepath.Join(dir, "sandbox-grants.json")
-	store, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore returned error: %v", err)
-	}
-	if err := os.Chmod(dir, 0o500); err != nil {
-		t.Skipf("cannot make the grants directory read-only: %v", err)
-	}
-	// Restore write permission so t.TempDir's cleanup can remove the directory.
-	t.Cleanup(func() { _ = os.Chmod(dir, 0o700) })
-	// Confirm the directory really is read-only here; otherwise this test would
-	// pass without exercising anything.
-	if probe, err := os.OpenFile(filepath.Join(dir, ".probe"), os.O_CREATE|os.O_RDWR, 0o600); err == nil {
-		_ = probe.Close()
-		t.Skip("this filesystem still allows writes to a 0500 directory")
-	}
-
-	notice, err := store.ConsumeMigrationNotice()
-	if err != nil {
-		t.Fatalf("ConsumeMigrationNotice on a read-only grants directory: %v", err)
-	}
-	if notice != "" {
-		t.Fatalf("notice = %q, want empty when nothing was migrated", notice)
-	}
-}
-
-// TestGrantStoreMigrationTakesTheFileLock covers the migrations that write
-// through readState: a legacy file must not be rewritten (nor its backup written)
-// while another process holds the lock, or two processes could both migrate and
-// one would clobber the other's result.
-func TestGrantStoreMigrationTakesTheFileLock(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "sandbox-grants.json")
-	original := `{"schemaVersion":1,"grants":{"write_file":{"toolName":"write_file","decision":"allow","approvedAt":"2026-06-05T14:30:00Z"}}}`
-	if err := writeText(path, original); err != nil {
-		t.Fatalf("write v1 grants: %v", err)
-	}
-	storeA, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore A returned error: %v", err)
-	}
-	storeB, err := NewGrantStore(StoreOptions{FilePath: path})
-	if err != nil {
-		t.Fatalf("NewGrantStore B returned error: %v", err)
-	}
-
-	unlock, err := storeA.lockStateFile()
-	if err != nil {
-		t.Fatalf("lockStateFile returned error: %v", err)
-	}
-	done := make(chan error, 1)
-	go func() {
-		_, err := storeB.List()
-		done <- err
-	}()
-
-	select {
-	case err := <-done:
-		unlock()
-		t.Fatalf("the migration ran while another store held the file lock: %v", err)
-	case <-time.After(100 * time.Millisecond):
-		if raw, err := os.ReadFile(path); err != nil {
-			unlock()
-			t.Fatalf("ReadFile grants: %v", err)
-		} else if string(raw) != original {
-			unlock()
-			t.Fatalf("the grant file was rewritten while the lock was held:\n%s", raw)
-		}
-	}
-
-	unlock()
-	select {
-	case err := <-done:
-		if err != nil {
-			t.Fatalf("List after lock release: %v", err)
-		}
-	case <-time.After(2 * time.Second):
-		t.Fatal("the migration did not complete after file lock release")
-	}
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("ReadFile migrated grants: %v", err)
-	}
-	if !strings.Contains(string(raw), `"schemaVersion": 3`) {
-		t.Fatalf("grant file was not migrated after the lock was released:\n%s", raw)
-	}
-}
-
 func TestGrantStoreMigratesExactV1GrantAndReportsOnce(t *testing.T) {
 	root := t.TempDir()
 	path := filepath.Join(root, "sandbox-grants.json")
@@ -38,7 +38,7 @@ func ApplyLandlockFilesystemProfile(profile PermissionProfile, cwd string) error
 	}
 	writeRoots := landlockWritableRoots(profile.FileSystem, cwd)
 	if len(writeRoots) == 0 {
-		return errors.New("Landlock requires at least one writable root") //nolint:staticcheck // Preserve the proper name and established user-facing text.
+		return errors.New("Landlock requires at least one writable root")
 	}
 	return installLandlockFilesystemRules(writeRoots)
 }
@@ -4,7 +4,7 @@ package sandbox

 import "errors"

-var ErrLandlockUnsupported = errors.New("Landlock is only supported on Linux") //nolint:staticcheck // Preserve the exported sentinel's established text.
+var ErrLandlockUnsupported = errors.New("Landlock is only supported on Linux")

 func ApplyLandlockFilesystemProfile(profile PermissionProfile, cwd string) error {
 	return ErrLandlockUnsupported
@@ -6,7 +6,6 @@ import (
 	"path/filepath"
 	"reflect"
 	"runtime"
-	"strings"
 	"testing"
 )

@@ -379,31 +378,7 @@ func TestCredentialDenyReadPathsIn(t *testing.T) {
 	home := t.TempDir()
 	awsDir := filepath.Join(home, ".aws")
 	gcloudDir := filepath.Join(home, ".config", "gcloud")
-	npmrc := filepath.Join(home, ".npmrc")
-	ghHosts := filepath.Join(home, ".config", "gh", "hosts.yml")
-	netrc := filepath.Join(home, ".netrc")
-	dockerConfig := filepath.Join(home, ".docker", "config.json")
-	kubeConfig := filepath.Join(home, ".kube", "config")
-	zeroConfig := filepath.Join(home, ".config", "zero")
-	if err := mkdirAll(
-		awsDir,
-		gcloudDir,
-		filepath.Dir(ghHosts),
-		filepath.Dir(dockerConfig),
-		filepath.Dir(kubeConfig),
-		filepath.Dir(zeroConfig),
-	); err != nil {
-		t.Fatal(err)
-	}
-	for _, path := range []string{npmrc, ghHosts, netrc, dockerConfig, kubeConfig, zeroConfig} {
-		if path == zeroConfig {
-			continue
-		}
-		if err := os.WriteFile(path, []byte("{}"), 0o600); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := os.MkdirAll(zeroConfig, 0o755); err != nil {
+	if err := mkdirAll(awsDir, gcloudDir); err != nil {
 		t.Fatal(err)
 	}
 	keyFile := filepath.Join(home, "sa-key.json")
@@ -412,17 +387,7 @@ func TestCredentialDenyReadPathsIn(t *testing.T) {
 	}

 	paths := credentialDenyReadPathsIn(home, keyFile, nil)
-	for _, want := range normalizeProfilePaths([]string{
-		awsDir,
-		gcloudDir,
-		keyFile,
-		npmrc,
-		ghHosts,
-		netrc,
-		dockerConfig,
-		kubeConfig,
-		zeroConfig,
-	}) {
+	for _, want := range normalizeProfilePaths([]string{awsDir, gcloudDir, keyFile}) {
 		if !stringSliceContains(paths, want) {
 			t.Errorf("credential deny paths = %#v, want %q included", paths, want)
 		}
@@ -453,58 +418,3 @@ func TestCredentialDenyReadPathsIn(t *testing.T) {
 		t.Errorf("credential deny paths without home = %#v, want key file included", homeless)
 	}
 }
-
-func TestCredentialDenyReadPathsForEnvironmentHonorsConfigOverrides(t *testing.T) {
-	root := t.TempDir()
-	configHome := filepath.Join(root, "xdg")
-	npmrc := filepath.Join(root, "npm", "userconfig")
-	ghConfigDir := filepath.Join(root, "gh")
-	cloudSDKConfig := filepath.Join(root, "gcloud")
-	netrc := filepath.Join(root, "netrc")
-	dockerConfigDir := filepath.Join(root, "docker")
-	kubeConfigA := filepath.Join(root, "kube", "a")
-	kubeConfigB := filepath.Join(root, "kube", "b")
-	zeroConfig := filepath.Join(configHome, "zero")
-	filePaths := []string{
-		npmrc,
-		filepath.Join(ghConfigDir, "hosts.yml"),
-		netrc,
-		filepath.Join(dockerConfigDir, "config.json"),
-		kubeConfigA,
-		kubeConfigB,
-		zeroConfig,
-	}
-	if err := os.MkdirAll(cloudSDKConfig, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	for _, path := range filePaths {
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if path == zeroConfig {
-			if err := os.MkdirAll(path, 0o755); err != nil {
-				t.Fatal(err)
-			}
-			continue
-		}
-		if err := os.WriteFile(path, []byte("{}"), 0o600); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	got := credentialDenyReadPathsForEnvironment(credentialPathEnvironment{
-		ConfigHome:      configHome,
-		CloudSDKConfig:  cloudSDKConfig,
-		NPMUserConfig:   npmrc,
-		GHConfigDir:     ghConfigDir,
-		Netrc:           netrc,
-		DockerConfigDir: dockerConfigDir,
-		KubeConfig:      strings.Join([]string{kubeConfigA, kubeConfigB}, string(filepath.ListSeparator)),
-	}, nil)
-	wantPaths := append(filePaths, cloudSDKConfig)
-	for _, want := range normalizeProfilePaths(wantPaths) {
-		if !stringSliceContains(got, want) {
-			t.Errorf("credential deny paths = %#v, want override %q included", got, want)
-		}
-	}
-}
@@ -145,10 +145,9 @@ func permissionProfileReadRoots(workspaceRoot string, policy Policy, scope *Scop
 }

 // credentialDenyReadPaths returns default deny-read entries for well-known
-// credential stores so sandboxed commands cannot read secrets under the
-// read-all workspace posture. This includes tool configuration files that can
-// carry credentials and are now discoverable through the preserved caller
-// environment. Two deliberate limits:
+// credential stores (~/.aws, ~/.config/gcloud, ~/.azure, and the file
+// GOOGLE_APPLICATION_CREDENTIALS points to) so sandboxed commands cannot read
+// cloud secrets under the read-all workspace posture. Two deliberate limits:
 //
 //   - Windows is skipped: a non-empty profile DenyRead switches the Windows
 //     runner onto the capability-SID/ACL deny path and away from the
@@ -167,114 +166,23 @@ func credentialDenyReadPaths(policy Policy) []string {
 	// A failed home lookup only drops the home-based candidates; the
 	// GOOGLE_APPLICATION_CREDENTIALS target must be protected regardless.
 	home, _ := os.UserHomeDir()
-	return credentialDenyReadPathsForEnvironment(credentialPathEnvironment{
-		Home:              home,
-		ConfigHome:        os.Getenv("XDG_CONFIG_HOME"),
-		CloudSDKConfig:    os.Getenv("CLOUDSDK_CONFIG"),
-		GoogleCredentials: os.Getenv("GOOGLE_APPLICATION_CREDENTIALS"),
-		NPMUserConfig:     firstNonEmpty(os.Getenv("NPM_CONFIG_USERCONFIG"), os.Getenv("npm_config_userconfig")),
-		GHConfigDir:       os.Getenv("GH_CONFIG_DIR"),
-		Netrc:             os.Getenv("NETRC"),
-		DockerConfigDir:   os.Getenv("DOCKER_CONFIG"),
-		KubeConfig:        os.Getenv("KUBECONFIG"),
-	}, policy.AllowRead)
+	return credentialDenyReadPathsIn(home, os.Getenv("GOOGLE_APPLICATION_CREDENTIALS"), policy.AllowRead)
 }

 // credentialDenyReadPathsIn is the pure core of credentialDenyReadPaths,
 // separated so tests can exercise it against a synthetic home directory.
 func credentialDenyReadPathsIn(home string, googleCredentials string, allowRead []string) []string {
-	return credentialDenyReadPathsForEnvironment(credentialPathEnvironment{
-		Home:              home,
-		GoogleCredentials: googleCredentials,
-	}, allowRead)
-}
-
-type credentialPathEnvironment struct {
-	Home              string
-	ConfigHome        string
-	CloudSDKConfig    string
-	GoogleCredentials string
-	NPMUserConfig     string
-	GHConfigDir       string
-	Netrc             string
-	DockerConfigDir   string
-	KubeConfig        string
-}
-
-func credentialDenyReadPathsForEnvironment(env credentialPathEnvironment, allowRead []string) []string {
 	var candidates []string
-	home := strings.TrimSpace(env.Home)
-	configHome := strings.TrimSpace(env.ConfigHome)
-	if configHome == "" && home != "" {
-		configHome = filepath.Join(home, ".config")
-	}
-	if home != "" {
+	if home = strings.TrimSpace(home); home != "" {
 		candidates = append(candidates,
 			filepath.Join(home, ".aws"),
+			filepath.Join(home, ".config", "gcloud"),
 			filepath.Join(home, ".azure"),
-			// git's credential store backend, which holds host passwords and
-			// personal access tokens in cleartext. Denied rather than the whole
-			// of ~/.ssh, because these cost nothing functionally: git reads them
-			// through a credential helper for authentication, not for identity,
-			// so a sandboxed git still works and simply cannot authenticate as
-			// the user. SSH key material is a harder trade and is tracked
-			// separately (#815).
-			filepath.Join(home, ".git-credentials"),
 		)
 	}
-	npmUserConfig := strings.TrimSpace(env.NPMUserConfig)
-	if npmUserConfig == "" && home != "" {
-		npmUserConfig = filepath.Join(home, ".npmrc")
-	}
-	netrc := strings.TrimSpace(env.Netrc)
-	if netrc == "" && home != "" {
-		netrc = filepath.Join(home, ".netrc")
-	}
-	dockerConfigDir := strings.TrimSpace(env.DockerConfigDir)
-	if dockerConfigDir == "" && home != "" {
-		dockerConfigDir = filepath.Join(home, ".docker")
-	}
-	candidates = append(candidates, npmUserConfig, netrc)
-	if dockerConfigDir != "" {
-		candidates = append(candidates, filepath.Join(dockerConfigDir, "config.json"))
-	}
-	if configHome != "" {
-		candidates = append(candidates,
-			filepath.Join(configHome, "zero"),
-			// The XDG location of the same git credential store. Denying the file
-			// rather than the directory is deliberate: ~/.config/git also holds
-			// the global git config, which userGitConfigReadPaths grants on
-			// purpose so a sandboxed git can read user.name and aliases instead
-			// of failing outright.
-			filepath.Join(configHome, "git", "credentials"),
-		)
-	}
-	cloudSDKConfig := strings.TrimSpace(env.CloudSDKConfig)
-	if cloudSDKConfig == "" && configHome != "" {
-		cloudSDKConfig = filepath.Join(configHome, "gcloud")
-	}
-	if cloudSDKConfig != "" {
-		candidates = append(candidates, cloudSDKConfig)
-	}
-	ghConfigDir := strings.TrimSpace(env.GHConfigDir)
-	if ghConfigDir == "" && configHome != "" {
-		ghConfigDir = filepath.Join(configHome, "gh")
-	}
-	if ghConfigDir != "" {
-		candidates = append(candidates, filepath.Join(ghConfigDir, "hosts.yml"))
-	}
-	if target := strings.TrimSpace(env.GoogleCredentials); target != "" {
+	if target := strings.TrimSpace(googleCredentials); target != "" {
 		candidates = append(candidates, target)
 	}
-	kubeConfig := strings.TrimSpace(env.KubeConfig)
-	if kubeConfig == "" && home != "" {
-		kubeConfig = filepath.Join(home, ".kube", "config")
-	}
-	for _, path := range filepath.SplitList(kubeConfig) {
-		if path = strings.TrimSpace(path); path != "" {
-			candidates = append(candidates, path)
-		}
-	}
 	allowRoots := normalizeProfilePaths(allowRead)
 	out := make([]string, 0, len(candidates))
 	for _, path := range normalizeProfilePaths(candidates) {
@@ -298,12 +206,11 @@ func credentialDenyReadPathsForEnvironment(env credentialPathEnvironment, allowR

 // userGitConfigReadPaths returns the user's global git config FILES so a
 // sandboxed git can read identity and config (user.name/email, aliases) instead
-// of failing with "unable to access ~/.gitconfig". On macOS, where reads are
-// allow-listed, granting only these files avoids exposing the surrounding
-// configuration directory. Linux uses a read-all profile with explicit
-// credential deny rules. The paths are granted at the macOS seatbelt read rule
-// rather than the cross-platform PermissionProfile so HOME-dependent paths
-// don't leak into the platform-agnostic policy snapshot.
+// of failing with "unable to access ~/.gitconfig". It is deliberately the config
+// files only — not the ~/.config/git directory, which can hold an XDG credential
+// store — so credentials and the rest of HOME stay unreadable. Granted at the
+// macOS-seatbelt read rule (not the cross-platform PermissionProfile) so the
+// HOME-dependent paths don't leak into the platform-agnostic policy snapshot.
 func userGitConfigReadPaths() []string {
 	home, err := os.UserHomeDir()
 	if err != nil || strings.TrimSpace(home) == "" {
@@ -1,93 +0,0 @@
-package sandbox
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// git's credential store holds host passwords and personal access tokens in
-// cleartext, in one of two locations depending on whether the user is on the
-// XDG layout. Neither was denied, so a sandboxed command could read them
-// (#815).
-//
-// Scoped to the credential files on purpose. Denying ~/.ssh as well would stop
-// a sandboxed git push over SSH from working, which is a functional trade that
-// issue tracks separately; these two cost nothing, because git reads them for
-// authentication rather than identity.
-func TestCredentialDenyReadPathsCoversGitCredentialStores(t *testing.T) {
-	home := t.TempDir()
-	configHome := filepath.Join(home, ".config")
-	if err := os.MkdirAll(filepath.Join(configHome, "git"), 0o700); err != nil {
-		t.Fatal(err)
-	}
-	// The builder only emits paths that exist, so these have to be real.
-	gitCredentials := filepath.Join(home, ".git-credentials")
-	xdgCredentials := filepath.Join(configHome, "git", "credentials")
-	gitConfig := filepath.Join(configHome, "git", "config")
-	for _, path := range []string{gitCredentials, xdgCredentials, gitConfig} {
-		if err := os.WriteFile(path, []byte("x"), 0o600); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	denied := credentialDenyReadPathsForEnvironment(credentialPathEnvironment{
-		Home:       home,
-		ConfigHome: configHome,
-	}, nil)
-	covered := func(target string) bool {
-		norm := normalizeProfilePath(target)
-		for _, entry := range denied {
-			if entry == norm || pathWithinRoot(entry, norm) {
-				return true
-			}
-		}
-		return false
-	}
-
-	if !covered(gitCredentials) {
-		t.Fatalf("~/.git-credentials is readable; deny list = %v", denied)
-	}
-	if !covered(xdgCredentials) {
-		t.Fatalf("~/.config/git/credentials is readable; deny list = %v", denied)
-	}
-	// The global git config must stay readable. userGitConfigReadPaths grants it
-	// deliberately so a sandboxed git can read user.name and aliases rather than
-	// failing with "unable to access", so denying the directory instead of the
-	// credential file would break that on purpose-built setups.
-	if covered(gitConfig) {
-		t.Fatalf("~/.config/git/config was denied; a sandboxed git loses its identity config")
-	}
-}
-
-// An explicit read grant still wins, matching how every other entry behaves: a
-// user who deliberately scopes a workspace over one of these paths is not
-// overridden by the default deny.
-//
-// Asserted from both sides on purpose. Checking only that the path is absent
-// under an allowRead is satisfied just as well by a deny rule that was never
-// added, so the run without allowRead has to establish that there is something
-// there for the grant to override.
-func TestGitCredentialDenyYieldsToExplicitAllowRead(t *testing.T) {
-	home := t.TempDir()
-	gitCredentials := filepath.Join(home, ".git-credentials")
-	if err := os.WriteFile(gitCredentials, []byte("x"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	target := normalizeProfilePath(gitCredentials)
-	listed := func(entries []string) bool {
-		for _, entry := range entries {
-			if entry == target {
-				return true
-			}
-		}
-		return false
-	}
-
-	if !listed(credentialDenyReadPathsForEnvironment(credentialPathEnvironment{Home: home}, nil)) {
-		t.Fatalf("~/.git-credentials is not denied without an allowRead; nothing for the grant to override")
-	}
-	if listed(credentialDenyReadPathsForEnvironment(credentialPathEnvironment{Home: home}, []string{home})) {
-		t.Fatalf("explicit allowRead %q did not re-include the credential store", home)
-	}
-}
@@ -1027,13 +1027,6 @@ func scrubSensitiveEnv(env []string, additionalKeys ...string) []string {
 		"GH_TOKEN",
 		"ZERO_WEBSEARCH_API_KEY",
 		"ZERO_DAEMON_REMOTE_TOKEN",
-		// The file form of the same bridge token. TokenFromEnv accepts either,
-		// so scrubbing only the inline variable left the pointer readable, and
-		// the default sandbox posture is read-all. There is no fallback
-		// location to guess at, the path comes from this variable alone, so
-		// removing it closes the leak rather than half of it. Same reasoning as
-		// GOOGLE_APPLICATION_CREDENTIALS below.
-		"ZERO_DAEMON_REMOTE_TOKEN_FILE",
 	}
 	for _, descriptor := range providercatalog.All() {
 		for _, key := range descriptor.AuthEnvVars {
@@ -699,11 +699,6 @@ func TestScrubSensitiveEnv(t *testing.T) {
 		"XAI_API_KEY=xai-12345",
 		"HUGGINGFACE_API_KEY=hf_12345",
 		"GOOGLE_APPLICATION_CREDENTIALS=/home/user/sa-key.json",
-		// Both forms of the daemon bridge token. The inline one was already
-		// scrubbed; the file form was not, which left a sandboxed command the
-		// path to read it from (#677).
-		"ZERO_DAEMON_REMOTE_TOKEN=bridge-token-inline",
-		"ZERO_DAEMON_REMOTE_TOKEN_FILE=/home/user/.zero/remote-token",
 		"COMPANY_LLM_SECRET=custom-secret",
 		"ZERO_OAUTH_MY_SVC_CLIENT_SECRET=oauth-secret",
 		"zero_oauth_second_client_secret=case-insensitive-secret",
@@ -266,74 +266,6 @@ func TestWindowsRestrictedTokenNestedPipeCapture(t *testing.T) {
 	}
 }

-// TestWindowsRestrictedTokenPowerShell exercises the default Windows shell
-// shape end to end under the write-restricted token. It covers PowerShell
-// initialization, a native pipeline (which creates IPC objects), UTF-8 output,
-// and workspace write enforcement.
-func TestWindowsRestrictedTokenPowerShell(t *testing.T) {
-	if os.Getenv("ZERO_SANDBOX_REAL_SMOKE") != "1" {
-		t.Skip("set ZERO_SANDBOX_REAL_SMOKE=1 to run real Windows sandbox smoke tests")
-	}
-	runnerExe := realSmokeExecutable(t, "ZERO_WINDOWS_COMMAND_RUNNER_EXE", WindowsSandboxCommandRunnerName)
-	powerShell := realSmokePowerShell(t)
-
-	root := t.TempDir()
-	outside := t.TempDir()
-	sandboxHome := filepath.Join(root, ".zero-sandbox")
-	profile := PermissionProfile{
-		FileSystem: FileSystemPolicy{
-			Kind:                 FileSystemRestricted,
-			ReadRoots:            []string{root},
-			WriteRoots:           []WritableRoot{{Root: root}},
-			IncludePlatformRoots: true,
-			AllowTemp:            true,
-		},
-		Network: NetworkPolicy{Mode: NetworkDeny},
-	}
-	config := WindowsSandboxCommandArgsOptions{
-		SandboxHome:       sandboxHome,
-		CommandCWD:        root,
-		WorkspaceRoots:    []string{root},
-		PermissionProfile: profile,
-		SandboxLevel:      WindowsSandboxLevelUnelevated,
-	}
-
-	insideMarker := filepath.Join(root, "powershell-ok.txt")
-	script := "$ErrorActionPreference='Stop'; " +
-		"[Console]::OutputEncoding=[System.Text.Encoding]::UTF8; " +
-		"$values = 1,2,3 | ForEach-Object { $_ * 2 }; " +
-		"[IO.File]::WriteAllText(" + powershellSingleQuote(insideMarker) + ", (($values -join ',') + ' ✓'))"
-	runWindowsRealSmokeCommand(t, runnerExe, config, []string{
-		powerShell, "-NoLogo", "-NoProfile", "-Command", script,
-	}, 0)
-	if bytes, err := os.ReadFile(insideMarker); err != nil || strings.TrimSpace(string(bytes)) != "2,4,6 ✓" {
-		t.Fatalf("PowerShell sandbox marker = %q, %v; want pipeline output", bytes, err)
-	}
-
-	outsideMarker := filepath.Join(outside, "powershell-denied.txt")
-	deniedScript := "$ErrorActionPreference='Stop'; " +
-		"[IO.File]::WriteAllText(" + powershellSingleQuote(outsideMarker) + ", 'leaked')"
-	runWindowsRealSmokeCommand(t, runnerExe, config, []string{
-		powerShell, "-NoLogo", "-NoProfile", "-Command", deniedScript,
-	}, 1)
-	if _, err := os.Stat(outsideMarker); err == nil {
-		t.Fatal("sandboxed PowerShell wrote outside every granted root")
-	} else if !os.IsNotExist(err) {
-		t.Fatalf("stat outside PowerShell marker: %v", err)
-	}
-}
-
-func realSmokePowerShell(t *testing.T) string {
-	t.Helper()
-	for _, candidate := range []string{"pwsh.exe", "pwsh", "powershell.exe", "powershell"} {
-		if path, err := exec.LookPath(candidate); err == nil {
-			return path
-		}
-	}
-	t.Skip("PowerShell is unavailable")
-	return ""
-}
-
 func realSmokeExecutable(t *testing.T, envKey string, fallbackName string) string {
 	t.Helper()
 	if path := os.Getenv(envKey); path != "" {
@@ -27,10 +27,13 @@ var fallbackSandboxRuntimes = struct {
 }{roots: make(map[string]string)}

 type SandboxRuntime struct {
-	Root  string `json:"root,omitempty"`
-	Cache string `json:"cache,omitempty"`
-	Data  string `json:"data,omitempty"`
-	Temp  string `json:"temp,omitempty"`
+	Root   string `json:"root,omitempty"`
+	Home   string `json:"home,omitempty"`
+	Cache  string `json:"cache,omitempty"`
+	Config string `json:"config,omitempty"`
+	Data   string `json:"data,omitempty"`
+	State  string `json:"state,omitempty"`
+	Temp   string `json:"temp,omitempty"`
 }

 func prepareSandboxRuntime(workspaceRoot string) (SandboxRuntime, func(), error) {
@@ -72,15 +75,21 @@ func prepareSandboxRuntime(workspaceRoot string) (SandboxRuntime, func(), error)
 		}
 	}()
 	runtimeState := SandboxRuntime{
-		Root:  root,
-		Cache: filepath.Join(root, "cache"),
-		Data:  filepath.Join(root, "data"),
-		Temp:  filepath.Join(root, "tmp"),
+		Root:   root,
+		Home:   filepath.Join(root, "home"),
+		Cache:  filepath.Join(root, "cache"),
+		Config: filepath.Join(root, "config"),
+		Data:   filepath.Join(root, "data"),
+		State:  filepath.Join(root, "state"),
+		Temp:   filepath.Join(root, "tmp"),
 	}
 	directories := []string{
 		runtimeState.Root,
+		runtimeState.Home,
 		runtimeState.Cache,
+		runtimeState.Config,
 		runtimeState.Data,
+		runtimeState.State,
 		runtimeState.Temp,
 		filepath.Join(runtimeState.Cache, "npm"),
 		filepath.Join(runtimeState.Cache, "yarn"),
@@ -198,11 +207,16 @@ func sandboxRuntimeEnvironment(env []string, runtimeState *SandboxRuntime) []str
 		return env
 	}
 	overrides := []string{
+		"HOME=" + runtimeState.Home,
 		"XDG_CACHE_HOME=" + runtimeState.Cache,
+		"XDG_CONFIG_HOME=" + runtimeState.Config,
+		"XDG_DATA_HOME=" + runtimeState.Data,
+		"XDG_STATE_HOME=" + runtimeState.State,
 		"TMPDIR=" + runtimeState.Temp,
 		"TMP=" + runtimeState.Temp,
 		"TEMP=" + runtimeState.Temp,
 		"npm_config_cache=" + filepath.Join(runtimeState.Cache, "npm"),
+		"NPM_CONFIG_USERCONFIG=" + filepath.Join(runtimeState.Config, "npmrc"),
 		"YARN_CACHE_FOLDER=" + filepath.Join(runtimeState.Cache, "yarn"),
 		"COREPACK_HOME=" + filepath.Join(runtimeState.Cache, "corepack"),
 		"PIP_CACHE_DIR=" + filepath.Join(runtimeState.Cache, "pip"),
@@ -2,9 +2,7 @@ package sandbox

 import (
 	"os"
-	"os/exec"
 	"path/filepath"
-	"strings"
 	"testing"
 	"time"
 )
@@ -24,18 +22,12 @@ func TestPrepareSandboxRuntimeStaysOutsideWorkspace(t *testing.T) {
 	if pathWithinRoot(workspace, runtimeState.Root) {
 		t.Fatalf("runtime root %q must stay outside workspace %q", runtimeState.Root, workspace)
 	}
-	for _, path := range []string{runtimeState.Cache, runtimeState.Data, runtimeState.Temp, filepath.Join(runtimeState.Data, "cargo")} {
+	for _, path := range []string{runtimeState.Home, runtimeState.Cache, runtimeState.Config, runtimeState.Data, runtimeState.State, runtimeState.Temp} {
 		info, err := os.Stat(path)
 		if err != nil || !info.IsDir() {
 			t.Fatalf("managed runtime directory %q was not prepared: %v", path, err)
 		}
 	}
-	for _, name := range []string{"home", "config", "state"} {
-		path := filepath.Join(runtimeState.Root, name)
-		if _, err := os.Stat(path); !os.IsNotExist(err) {
-			t.Fatalf("obsolete synthetic runtime directory %q exists: %v", path, err)
-		}
-	}
 }

 func TestPrepareSandboxRuntimeCleansExpiredSibling(t *testing.T) {
@@ -124,63 +116,34 @@ func TestCleanupSandboxRuntimeSkipsActiveLease(t *testing.T) {
 	}
 }

-func TestSandboxRuntimeEnvironmentPreservesUserConfiguration(t *testing.T) {
+func TestSandboxRuntimeEnvironmentUsesManagedState(t *testing.T) {
 	root := filepath.Join(t.TempDir(), "runtime")
 	runtimeState := SandboxRuntime{
-		Root:  root,
-		Cache: filepath.Join(root, "cache"),
-		Data:  filepath.Join(root, "data"),
-		Temp:  filepath.Join(root, "tmp"),
+		Root:   root,
+		Home:   filepath.Join(root, "home"),
+		Cache:  filepath.Join(root, "cache"),
+		Config: filepath.Join(root, "config"),
+		Data:   filepath.Join(root, "data"),
+		State:  filepath.Join(root, "state"),
+		Temp:   filepath.Join(root, "tmp"),
 	}
 	env := sandboxRuntimeEnvironment([]string{
-		"HOME=/home/user",
+		"HOME=/workspace",
 		"XDG_CACHE_HOME=/host/cache",
-		"XDG_CONFIG_HOME=/home/user/.config",
-		"XDG_DATA_HOME=/home/user/.local/share",
-		"XDG_STATE_HOME=/home/user/.local/state",
-		"NPM_CONFIG_USERCONFIG=/home/user/.npmrc",
 		"PATH=/usr/bin",
 	}, &runtimeState)

 	for key, want := range map[string]string{
-		"HOME":                  "/home/user",
-		"XDG_CONFIG_HOME":       "/home/user/.config",
-		"XDG_DATA_HOME":         "/home/user/.local/share",
-		"XDG_STATE_HOME":        "/home/user/.local/state",
-		"NPM_CONFIG_USERCONFIG": "/home/user/.npmrc",
-	} {
-		if got := envListValue(env, key, ""); got != want {
-			t.Fatalf("%s = %q, want %q; env=%#v", key, got, want, env)
-		}
-	}
-}
-
-func TestSandboxRuntimeEnvironmentUsesManagedWritableState(t *testing.T) {
-	root := filepath.Join(t.TempDir(), "runtime")
-	runtimeState := SandboxRuntime{
-		Root:  root,
-		Cache: filepath.Join(root, "cache"),
-		Data:  filepath.Join(root, "data"),
-		Temp:  filepath.Join(root, "tmp"),
-	}
-	env := sandboxRuntimeEnvironment([]string{
-		"XDG_CACHE_HOME=/host/cache",
-		"TMPDIR=/host/tmp",
-		"PATH=/usr/bin",
-	}, &runtimeState)
-
-	for key, want := range map[string]string{
-		"XDG_CACHE_HOME":    runtimeState.Cache,
-		"TMPDIR":            runtimeState.Temp,
-		"TMP":               runtimeState.Temp,
-		"TEMP":              runtimeState.Temp,
-		"npm_config_cache":  filepath.Join(runtimeState.Cache, "npm"),
-		"YARN_CACHE_FOLDER": filepath.Join(runtimeState.Cache, "yarn"),
-		"COREPACK_HOME":     filepath.Join(runtimeState.Cache, "corepack"),
-		"PIP_CACHE_DIR":     filepath.Join(runtimeState.Cache, "pip"),
-		"GOCACHE":           filepath.Join(runtimeState.Cache, "go-build"),
-		"GOMODCACHE":        filepath.Join(runtimeState.Data, "go-mod"),
-		"CARGO_HOME":        filepath.Join(runtimeState.Data, "cargo"),
+		"HOME":                  runtimeState.Home,
+		"XDG_CACHE_HOME":        runtimeState.Cache,
+		"XDG_CONFIG_HOME":       runtimeState.Config,
+		"XDG_DATA_HOME":         runtimeState.Data,
+		"XDG_STATE_HOME":        runtimeState.State,
+		"TMPDIR":                runtimeState.Temp,
+		"npm_config_cache":      filepath.Join(runtimeState.Cache, "npm"),
+		"NPM_CONFIG_USERCONFIG": filepath.Join(runtimeState.Config, "npmrc"),
+		"YARN_CACHE_FOLDER":     filepath.Join(runtimeState.Cache, "yarn"),
+		"COREPACK_HOME":         filepath.Join(runtimeState.Cache, "corepack"),
 	} {
 		if got := envListValue(env, key, ""); got != want {
 			t.Fatalf("%s = %q, want %q; env=%#v", key, got, want, env)
@@ -191,93 +154,9 @@ func TestSandboxRuntimeEnvironmentUsesManagedWritableState(t *testing.T) {
 	}
 }

-func TestSandboxRuntimeEnvironmentPreservesGitGlobalIgnore(t *testing.T) {
-	git, err := exec.LookPath("git")
-	if err != nil {
-		t.Skip("git is unavailable")
-	}
-	root := t.TempDir()
-	home := filepath.Join(root, "home")
-	configHome := filepath.Join(home, ".config")
-	repository := filepath.Join(root, "repository")
-	runtimeRoot := filepath.Join(root, "runtime")
-	for _, directory := range []string{
-		filepath.Join(configHome, "git"),
-		repository,
-		filepath.Join(runtimeRoot, "cache"),
-		filepath.Join(runtimeRoot, "data"),
-		filepath.Join(runtimeRoot, "tmp"),
-	} {
-		if err := os.MkdirAll(directory, 0o700); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := os.WriteFile(filepath.Join(configHome, "git", "ignore"), []byte("ignored.txt\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(repository, "ignored.txt"), []byte("ignored\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(repository, "visible.txt"), []byte("visible\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	runtimeState := SandboxRuntime{
-		Root:  runtimeRoot,
-		Cache: filepath.Join(runtimeRoot, "cache"),
-		Data:  filepath.Join(runtimeRoot, "data"),
-		Temp:  filepath.Join(runtimeRoot, "tmp"),
-	}
-	inherited := append(os.Environ(),
-		"GIT_CONFIG_GLOBAL="+filepath.Join(root, "missing-global-config"),
-		"GIT_DIR="+filepath.Join(root, "wrong-repository"),
-		"GIT_CONFIG_COUNT=1",
-		"GIT_CONFIG_KEY_0=core.excludesFile",
-		"GIT_CONFIG_VALUE_0="+filepath.Join(root, "missing-ignore"),
-	)
-	env := sandboxRuntimeEnvironment(upsertEnvList(withoutGitEnvironmentOverrides(inherited),
-		"HOME="+home,
-		"XDG_CONFIG_HOME="+configHome,
-		"GIT_CONFIG_NOSYSTEM=1",
-		"GIT_TERMINAL_PROMPT=0",
-	), &runtimeState)
-	runGit := func(args ...string) string {
-		t.Helper()
-		command := exec.Command(git, args...)
-		command.Dir = repository
-		command.Env = env
-		output, err := command.CombinedOutput()
-		if err != nil {
-			t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, output)
-		}
-		return string(output)
-	}
-	runGit("init", "--quiet")
-	status := runGit("status", "--short", "--untracked-files=all")
-	if strings.Contains(status, "ignored.txt") {
-		t.Fatalf("global ignore was not honored:\n%s", status)
-	}
-	if !strings.Contains(status, "visible.txt") {
-		t.Fatalf("non-ignored file is missing from status:\n%s", status)
-	}
-}
-
-func withoutGitEnvironmentOverrides(env []string) []string {
-	out := make([]string, 0, len(env))
-	for _, value := range env {
-		key, _, ok := strings.Cut(value, "=")
-		if ok && strings.HasPrefix(strings.ToUpper(key), "GIT_") {
-			continue
-		}
-		out = append(out, value)
-	}
-	return out
-}
-
 func TestEngineCommandPlanCarriesManagedRuntime(t *testing.T) {
 	workspace := t.TempDir()
 	cacheRoot := t.TempDir()
-	t.Setenv("HOME", filepath.Join(t.TempDir(), "home"))
 	original := sandboxUserCacheDir
 	sandboxUserCacheDir = func() (string, error) { return cacheRoot, nil }
 	t.Cleanup(func() { sandboxUserCacheDir = original })
@@ -310,8 +189,8 @@ func TestEngineCommandPlanCarriesManagedRuntime(t *testing.T) {
 	} else if !inUse {
 		t.Fatal("command plan runtime must be marked in use")
 	}
-	if got := envListValue(plan.Env, "HOME", ""); got != os.Getenv("HOME") {
-		t.Fatalf("HOME = %q, want caller home %q", got, os.Getenv("HOME"))
+	if got := envListValue(plan.Env, "HOME", ""); got != plan.PermissionProfile.Runtime.Home {
+		t.Fatalf("HOME = %q, want managed home %q", got, plan.PermissionProfile.Runtime.Home)
 	}
 	foundWriteRoot := false
 	for _, root := range plan.PermissionProfile.FileSystem.WriteRoots {
@@ -430,70 +430,25 @@ func shellDashCPayload(program string, fields []string) string {
 // name: it strips shell quoting/escaping characters (", ', `, \) wherever they
 // appear in the token (including embedded ones like `vi\m` or `v"i"m`), strips
 // leading command-substitution markers, removes any directory prefix (so
-// /usr/bin/vim and C:\tools\vim.exe match "vim"), removes Windows executable
-// suffixes, and lowercases. This closes path/quote/substitution evasions of the
-// detector and keeps curl.exe/npm.cmd equivalent to curl/npm for risk analysis.
+// /usr/bin/vim and C:\tools\vim.exe match "vim"), and lowercases. This closes
+// path/quote/substitution evasions of the detector.
 func normalizeProgramToken(field string) string {
 	token := strings.TrimSpace(field)
 	token = strings.TrimLeft(token, "$(")
 	token = strings.TrimRight(token, ")")
-	// PowerShell commonly invokes drive-letter, UNC, and relative paths. Extract
-	// their basename while backslashes still carry path-separator meaning;
-	// removing them first would turn C:\tools\curl.exe into c:toolscurl.exe and
-	// bypass the canonical curl risk entry.
-	pathToken := stripChars(token, "\"'`")
-	if windowsPathBasename, ok := windowsExecutablePathBasename(pathToken); ok {
-		token = windowsPathBasename
-	} else {
-		// Strip shell quoting/escaping characters (", ', `, \) wherever they
-		// appear in the token — surrounding, embedded, or as a mid-word escape
-		// — so "vim", v"i"m, 'v'im, and vi\m all collapse to the program name.
-		token = stripChars(token, "\"'`\\")
-		// Strip a directory prefix so /usr/bin/vim reduces to the basename.
-		if i := strings.LastIndex(token, "/"); i >= 0 {
-			token = token[i+1:]
-		}
+	// Strip shell quoting/escaping characters (", ', `, \) wherever they appear
+	// in the token — surrounding, embedded, or as a mid-word escape — so
+	// "vim", v"i"m, 'v'im, and vi\m all collapse to the program name. This is
+	// done BEFORE the directory-prefix trim so an escape can't masquerade as a
+	// path separator (e.g. vi\m must become vim, not m).
+	token = stripChars(token, "\"'`\\")
+	// Strip a directory prefix so /usr/bin/vim reduces to the basename. (A
+	// Windows-style backslash path separator is already removed above, so only
+	// the POSIX separator remains to split on.)
+	if i := strings.LastIndex(token, "/"); i >= 0 {
+		token = token[i+1:]
 	}
-	token = strings.ToLower(token)
-	for _, suffix := range []string{".exe", ".cmd", ".bat", ".com"} {
-		if strings.HasSuffix(token, suffix) {
-			return strings.TrimSuffix(token, suffix)
-		}
-	}
-	return token
-}
-
-func windowsExecutablePathBasename(token string) (string, bool) {
-	drivePath := len(token) >= 3 &&
-		((token[0] >= 'a' && token[0] <= 'z') || (token[0] >= 'A' && token[0] <= 'Z')) &&
-		token[1] == ':'
-	uncPath := strings.HasPrefix(token, `\\`)
-	explicitRelativePath := strings.HasPrefix(token, `.\`) || strings.HasPrefix(token, `..\`)
-	backslashRelativePath := strings.ContainsRune(token, '\\') && hasWindowsExecutableSuffix(token)
-	if !drivePath && !uncPath && !explicitRelativePath && !backslashRelativePath {
-		return "", false
-	}
-	index := strings.LastIndexAny(token, `\/`)
-	if index >= 0 {
-		if index+1 >= len(token) {
-			return "", false
-		}
-		return token[index+1:], true
-	}
-	if drivePath && len(token) > 2 {
-		return token[2:], true
-	}
-	return "", false
-}
-
-func hasWindowsExecutableSuffix(token string) bool {
-	token = strings.ToLower(token)
-	for _, suffix := range []string{".exe", ".cmd", ".bat", ".com"} {
-		if strings.HasSuffix(token, suffix) {
-			return true
-		}
-	}
-	return false
+	return strings.ToLower(token)
 }

 // stripChars returns s with every rune in cutset removed.
@@ -10,7 +10,7 @@ import (
 	"strings"
 )

-var ErrWindowsNetworkEnforcementUnavailable = errors.New("Windows sandbox network enforcement is not available") //nolint:staticcheck // Preserve the exported sentinel's established text.
+var ErrWindowsNetworkEnforcementUnavailable = errors.New("Windows sandbox network enforcement is not available")

 const (
 	windowsWFPProviderKey = "2e31d31c-3948-4753-9117-e5d1a6496f41"
@@ -1,422 +0,0 @@
-package sessions
-
-import (
-	"fmt"
-	"strings"
-	"unicode/utf8"
-)
-
-const (
-	GoalObjectiveMaxLength            = 4_000
-	GoalMaxConsecutiveContinuations   = 20
-	goalContinuationLimitStatusReason = "automatic continuation limit reached"
-)
-
-func validateGoalObjective(objective string) (string, error) {
-	objective = strings.TrimSpace(objective)
-	if objective == "" {
-		return "", fmt.Errorf("goal objective is required")
-	}
-	if utf8.RuneCountInString(objective) > GoalObjectiveMaxLength {
-		return "", fmt.Errorf("goal objective cannot exceed %d characters", GoalObjectiveMaxLength)
-	}
-	return objective, nil
-}
-
-// CreateGoal persists a new active goal for a session. It refuses to replace an
-// existing goal so callers must make replacement an explicit user decision.
-func (store *Store) CreateGoal(sessionID, objective string, tokenBudget int) (Metadata, Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, Event{}, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	var err error
-	objective, err = validateGoalObjective(objective)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if tokenBudget < 0 {
-		return Metadata{}, Event{}, fmt.Errorf("goal token budget cannot be negative")
-	}
-
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if session.Goal != nil {
-		return Metadata{}, Event{}, fmt.Errorf("session already has a goal")
-	}
-	now := store.timestamp()
-	session.Goal = &Goal{
-		Objective:         objective,
-		Status:            GoalStatusActive,
-		TokenBudget:       tokenBudget,
-		ContinuationLimit: GoalMaxConsecutiveContinuations,
-		CreatedAt:         now,
-		UpdatedAt:         now,
-	}
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, Event{}, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalCreated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	return loaded, event, nil
-}
-
-// UpdateGoal changes a goal's lifecycle state. Terminal goals remain available
-// for status/history until the user explicitly clears them.
-func (store *Store) UpdateGoal(sessionID string, status GoalStatus, reason string) (Metadata, Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, Event{}, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	if !validGoalStatus(status) {
-		return Metadata{}, Event{}, fmt.Errorf("invalid goal status %q", status)
-	}
-
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if session.Goal == nil {
-		return Metadata{}, Event{}, fmt.Errorf("session has no goal")
-	}
-	session.Goal.Status = status
-	session.Goal.StatusReason = strings.TrimSpace(reason)
-	if status == GoalStatusActive {
-		session.Goal.ContinuationCount = 0
-		if session.Goal.ContinuationLimit <= 0 {
-			session.Goal.ContinuationLimit = GoalMaxConsecutiveContinuations
-		}
-	}
-	session.Goal.UpdatedAt = store.timestamp()
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, Event{}, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalUpdated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	return loaded, event, nil
-}
-
-// EditGoal replaces the objective and optional budget without resetting usage or
-// lifecycle timestamps. User-facing command handling owns confirmation.
-func (store *Store) EditGoal(sessionID, objective string, tokenBudget int) (Metadata, Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, Event{}, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	var err error
-	objective, err = validateGoalObjective(objective)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if tokenBudget < 0 {
-		return Metadata{}, Event{}, fmt.Errorf("goal token budget cannot be negative")
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if session.Goal == nil {
-		return Metadata{}, Event{}, fmt.Errorf("session has no goal")
-	}
-	session.Goal.Objective = objective
-	session.Goal.TokenBudget = tokenBudget
-	session.Goal.Status = GoalStatusActive
-	session.Goal.StatusReason = ""
-	session.Goal.ContinuationCount = 0
-	if session.Goal.ContinuationLimit <= 0 {
-		session.Goal.ContinuationLimit = GoalMaxConsecutiveContinuations
-	}
-	if tokenBudget > 0 && session.Goal.TokensUsed >= tokenBudget {
-		session.Goal.Status = GoalStatusBudgetLimited
-		session.Goal.StatusReason = "token budget reached"
-	}
-	session.Goal.UpdatedAt = store.timestamp()
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, Event{}, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalUpdated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	return loaded, event, nil
-}
-
-// ResetGoalContinuations starts a fresh autonomous-run allowance after explicit
-// user input. It makes the safety bound consecutive rather than lifetime-wide.
-func (store *Store) ResetGoalContinuations(sessionID string) (Metadata, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, err
-	}
-	if session.Goal == nil || session.Goal.Status != GoalStatusActive {
-		return session, nil
-	}
-	changed := false
-	if session.Goal.ContinuationCount != 0 {
-		session.Goal.ContinuationCount = 0
-		changed = true
-	}
-	if session.Goal.ContinuationLimit <= 0 {
-		session.Goal.ContinuationLimit = GoalMaxConsecutiveContinuations
-		changed = true
-	}
-	if !changed {
-		return session, nil
-	}
-	session.Goal.UpdatedAt = store.timestamp()
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, err
-	}
-	return session, nil
-}
-
-// ReserveGoalContinuation atomically reserves one automatic continuation. Once
-// the persisted consecutive-run limit is exhausted it pauses the goal before
-// another provider request can start, even when the provider reports no usage.
-func (store *Store) ReserveGoalContinuation(sessionID string) (Metadata, *Event, bool, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, nil, false, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, nil, false, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, false, err
-	}
-	if session.Goal == nil || session.Goal.Status != GoalStatusActive {
-		return session, nil, false, nil
-	}
-	limit := session.Goal.ContinuationLimit
-	if limit <= 0 {
-		limit = GoalMaxConsecutiveContinuations
-		session.Goal.ContinuationLimit = limit
-	}
-	if session.Goal.ContinuationCount < limit {
-		session.Goal.ContinuationCount++
-		session.Goal.UpdatedAt = store.timestamp()
-		if err := store.writeMetadata(session); err != nil {
-			return Metadata{}, nil, false, err
-		}
-		return session, nil, true, nil
-	}
-
-	session.Goal.Status = GoalStatusPaused
-	session.Goal.StatusReason = goalContinuationLimitStatusReason
-	session.Goal.UpdatedAt = store.timestamp()
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, nil, false, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalUpdated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, nil, false, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, false, err
-	}
-	return loaded, &event, false, nil
-}
-
-// AddGoalUsage accounts tokens consumed while a goal is active. Reaching the
-// optional budget pauses the goal before another autonomous turn can start.
-func (store *Store) AddGoalUsage(sessionID string, tokens int) (Metadata, *Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, nil, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	if tokens < 0 {
-		return Metadata{}, nil, fmt.Errorf("goal token usage cannot be negative")
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	if session.Goal == nil || tokens == 0 {
-		return session, nil, nil
-	}
-	session.Goal.TokensUsed += tokens
-	session.Goal.UpdatedAt = store.timestamp()
-	budgetReached := false
-	if session.Goal.Status == GoalStatusActive &&
-		session.Goal.TokenBudget > 0 &&
-		session.Goal.TokensUsed >= session.Goal.TokenBudget {
-		session.Goal.Status = GoalStatusBudgetLimited
-		session.Goal.StatusReason = "token budget reached"
-		budgetReached = true
-	}
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, nil, err
-	}
-	if !budgetReached {
-		return session, nil, nil
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalUpdated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	return loaded, &event, nil
-}
-
-// PauseGoalIfActive pauses a goal only while it is still active. It is used by
-// cancellation paths where an in-flight agent may have completed or blocked the
-// goal immediately before the cancellation reached the runtime.
-func (store *Store) PauseGoalIfActive(sessionID, reason string) (Metadata, *Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, nil, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	if session.Goal == nil || session.Goal.Status != GoalStatusActive {
-		return session, nil, nil
-	}
-	session.Goal.Status = GoalStatusPaused
-	session.Goal.StatusReason = strings.TrimSpace(reason)
-	session.Goal.UpdatedAt = store.timestamp()
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, nil, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalUpdated,
-		Payload: session.Goal,
-	})
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, nil, err
-	}
-	return loaded, &event, nil
-}
-
-// ClearGoal removes the current goal while preserving an audit event.
-func (store *Store) ClearGoal(sessionID string) (Metadata, Event, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, Event{}, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	if session.Goal == nil {
-		return Metadata{}, Event{}, fmt.Errorf("session has no goal")
-	}
-	cleared := cloneGoal(session.Goal)
-	session.Goal = nil
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, Event{}, err
-	}
-	event, err := store.appendEventLocked(sessionID, AppendEventInput{
-		Type:    EventGoalCleared,
-		Payload: cleared,
-	})
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	loaded, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, Event{}, err
-	}
-	return loaded, event, nil
-}
-
-func validGoalStatus(status GoalStatus) bool {
-	switch status {
-	case GoalStatusActive, GoalStatusPaused, GoalStatusBlocked, GoalStatusBudgetLimited, GoalStatusUsageLimited, GoalStatusComplete:
-		return true
-	default:
-		return false
-	}
-}
-
-func cloneGoal(goal *Goal) *Goal {
-	if goal == nil {
-		return nil
-	}
-	copy := *goal
-	return &copy
-}
@@ -1,382 +0,0 @@
-package sessions
-
-import (
-	"os"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestGoalLifecyclePersistsInSessionMetadata(t *testing.T) {
-	now := time.Date(2026, 7, 24, 10, 0, 0, 0, time.UTC)
-	store := NewStore(StoreOptions{
-		RootDir: t.TempDir(),
-		Now: func() time.Time {
-			now = now.Add(time.Second)
-			return now
-		},
-	})
-	session, err := store.Create(CreateInput{SessionID: "goal_session"})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	created, event, err := store.CreateGoal(session.SessionID, "Ship the release", 1_000)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if event.Type != EventGoalCreated {
-		t.Fatalf("create event = %q, want %q", event.Type, EventGoalCreated)
-	}
-	if created.Goal == nil || created.Goal.Objective != "Ship the release" ||
-		created.Goal.Status != GoalStatusActive || created.Goal.TokenBudget != 1_000 {
-		t.Fatalf("created goal = %#v", created.Goal)
-	}
-
-	accounted, _, err := store.AddGoalUsage(session.SessionID, 250)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if accounted.Goal.TokensUsed != 250 || accounted.Goal.Status != GoalStatusActive {
-		t.Fatalf("accounted goal = %#v", accounted.Goal)
-	}
-
-	paused, event, err := store.UpdateGoal(session.SessionID, GoalStatusPaused, "user interrupted")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if event.Type != EventGoalUpdated || paused.Goal.Status != GoalStatusPaused ||
-		paused.Goal.StatusReason != "user interrupted" {
-		t.Fatalf("paused goal/event = %#v / %#v", paused.Goal, event)
-	}
-
-	loaded, err := store.Get(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if loaded == nil || loaded.Goal == nil || loaded.Goal.Status != GoalStatusPaused {
-		t.Fatalf("reloaded session = %#v", loaded)
-	}
-
-	cleared, event, err := store.ClearGoal(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if event.Type != EventGoalCleared || cleared.Goal != nil {
-		t.Fatalf("cleared goal/event = %#v / %#v", cleared.Goal, event)
-	}
-}
-
-func TestGoalBudgetPausesAtLimit(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "budget_session"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "Stay bounded", 100); err != nil {
-		t.Fatal(err)
-	}
-
-	updated, event, err := store.AddGoalUsage(session.SessionID, 100)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if updated.Goal.Status != GoalStatusBudgetLimited || updated.Goal.StatusReason != "token budget reached" {
-		t.Fatalf("budgeted goal = %#v", updated.Goal)
-	}
-	if event == nil || event.Type != EventGoalUpdated {
-		t.Fatalf("budget transition event = %#v", event)
-	}
-}
-
-func TestGoalContinuationLimitStopsWithoutProviderUsage(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "continuation_limit"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "Stay bounded without usage events", 0); err != nil {
-		t.Fatal(err)
-	}
-
-	for continuation := 1; continuation <= GoalMaxConsecutiveContinuations; continuation++ {
-		updated, event, reserved, err := store.ReserveGoalContinuation(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !reserved || event != nil {
-			t.Fatalf("continuation %d: reserved=%v event=%#v", continuation, reserved, event)
-		}
-		if updated.Goal.ContinuationCount != continuation {
-			t.Fatalf("continuation count = %d, want %d", updated.Goal.ContinuationCount, continuation)
-		}
-		if updated.Goal.TokensUsed != 0 {
-			t.Fatalf("provider-independent guard unexpectedly recorded tokens: %#v", updated.Goal)
-		}
-	}
-
-	stopped, event, reserved, err := store.ReserveGoalContinuation(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if reserved || event == nil || stopped.Goal.Status != GoalStatusPaused ||
-		stopped.Goal.StatusReason != goalContinuationLimitStatusReason {
-		t.Fatalf("unbounded continuation was not stopped: goal=%#v event=%#v reserved=%v", stopped.Goal, event, reserved)
-	}
-	reloaded, err := store.Get(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if reloaded.Goal.ContinuationCount != GoalMaxConsecutiveContinuations ||
-		reloaded.Goal.Status != GoalStatusPaused {
-		t.Fatalf("continuation guard did not persist: %#v", reloaded.Goal)
-	}
-
-	resumed, _, err := store.UpdateGoal(session.SessionID, GoalStatusActive, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if resumed.Goal.ContinuationCount != 0 {
-		t.Fatalf("explicit resume did not reset consecutive continuations: %#v", resumed.Goal)
-	}
-}
-
-func TestResetGoalContinuationsPersistsOnlyActiveChanges(t *testing.T) {
-	newStore := func(t *testing.T) (*Store, Metadata) {
-		t.Helper()
-		now := time.Date(2026, 7, 26, 10, 0, 0, 0, time.UTC)
-		store := NewStore(StoreOptions{
-			RootDir: t.TempDir(),
-			Now: func() time.Time {
-				now = now.Add(time.Second)
-				return now
-			},
-		})
-		session, err := store.Create(CreateInput{SessionID: "reset_goal"})
-		if err != nil {
-			t.Fatal(err)
-		}
-		return store, session
-	}
-	pinMetadataTime := func(t *testing.T, store *Store, sessionID string) time.Time {
-		t.Helper()
-		path := store.metadataPath(sessionID)
-		sentinel := time.Date(2001, 2, 3, 4, 5, 6, 0, time.UTC)
-		if err := os.Chtimes(path, sentinel, sentinel); err != nil {
-			t.Fatal(err)
-		}
-		info, err := os.Stat(path)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return info.ModTime()
-	}
-	assertMetadataTime := func(t *testing.T, store *Store, sessionID string, want time.Time) {
-		t.Helper()
-		info, err := os.Stat(store.metadataPath(sessionID))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !info.ModTime().Equal(want) {
-			t.Fatalf("metadata was rewritten: modtime=%s want=%s", info.ModTime(), want)
-		}
-	}
-
-	t.Run("no goal is a no-op", func(t *testing.T) {
-		store, session := newStore(t)
-		modTime := pinMetadataTime(t, store, session.SessionID)
-		updated, err := store.ResetGoalContinuations(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if updated.Goal != nil {
-			t.Fatalf("no-goal reset created a goal: %#v", updated.Goal)
-		}
-		assertMetadataTime(t, store, session.SessionID, modTime)
-	})
-
-	t.Run("inactive goal is a no-op", func(t *testing.T) {
-		store, session := newStore(t)
-		if _, _, err := store.CreateGoal(session.SessionID, "Pause safely", 0); err != nil {
-			t.Fatal(err)
-		}
-		if _, _, reserved, err := store.ReserveGoalContinuation(session.SessionID); err != nil || !reserved {
-			t.Fatalf("reserve continuation: reserved=%v err=%v", reserved, err)
-		}
-		paused, _, err := store.UpdateGoal(session.SessionID, GoalStatusPaused, "user paused")
-		if err != nil {
-			t.Fatal(err)
-		}
-		modTime := pinMetadataTime(t, store, session.SessionID)
-		updated, err := store.ResetGoalContinuations(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if updated.Goal.ContinuationCount != 1 || updated.Goal.UpdatedAt != paused.Goal.UpdatedAt {
-			t.Fatalf("inactive goal changed during reset: before=%#v after=%#v", paused.Goal, updated.Goal)
-		}
-		assertMetadataTime(t, store, session.SessionID, modTime)
-	})
-
-	t.Run("already reset active goal is a no-op", func(t *testing.T) {
-		store, session := newStore(t)
-		created, _, err := store.CreateGoal(session.SessionID, "Stay reset", 0)
-		if err != nil {
-			t.Fatal(err)
-		}
-		modTime := pinMetadataTime(t, store, session.SessionID)
-		updated, err := store.ResetGoalContinuations(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if updated.Goal.ContinuationCount != 0 ||
-			updated.Goal.ContinuationLimit != GoalMaxConsecutiveContinuations ||
-			updated.Goal.UpdatedAt != created.Goal.UpdatedAt {
-			t.Fatalf("already-reset goal changed: before=%#v after=%#v", created.Goal, updated.Goal)
-		}
-		assertMetadataTime(t, store, session.SessionID, modTime)
-	})
-
-	t.Run("active goal reset persists", func(t *testing.T) {
-		store, session := newStore(t)
-		if _, _, err := store.CreateGoal(session.SessionID, "Reset progress", 0); err != nil {
-			t.Fatal(err)
-		}
-		reserved, _, ok, err := store.ReserveGoalContinuation(session.SessionID)
-		if err != nil || !ok {
-			t.Fatalf("reserve continuation: reserved=%v err=%v", ok, err)
-		}
-		updated, err := store.ResetGoalContinuations(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if updated.Goal.ContinuationCount != 0 ||
-			updated.Goal.ContinuationLimit != GoalMaxConsecutiveContinuations ||
-			updated.Goal.UpdatedAt == reserved.Goal.UpdatedAt {
-			t.Fatalf("active reset did not persist: before=%#v after=%#v", reserved.Goal, updated.Goal)
-		}
-		reloaded, err := store.Get(session.SessionID)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if reloaded.Goal == nil || *reloaded.Goal != *updated.Goal {
-			t.Fatalf("active reset was not durable: updated=%#v reloaded=%#v", updated.Goal, reloaded.Goal)
-		}
-	})
-}
-
-func TestGoalObjectiveLengthIsBounded(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "objective_limit"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	tooLong := strings.Repeat("g", GoalObjectiveMaxLength+1)
-	if _, _, err := store.CreateGoal(session.SessionID, tooLong, 0); err == nil ||
-		!strings.Contains(err.Error(), "cannot exceed") {
-		t.Fatalf("oversized objective error = %v", err)
-	}
-}
-
-func TestEditGoalUpdatesStateAndRejectsInvalidInputWithoutMutation(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "edit_goal"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "Original objective", 1_000); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.AddGoalUsage(session.SessionID, 250); err != nil {
-		t.Fatal(err)
-	}
-
-	edited, event, err := store.EditGoal(session.SessionID, "Updated objective", 500)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if event.Type != EventGoalUpdated {
-		t.Fatalf("edit event = %q, want %q", event.Type, EventGoalUpdated)
-	}
-	if edited.Goal == nil ||
-		edited.Goal.Objective != "Updated objective" ||
-		edited.Goal.TokenBudget != 500 ||
-		edited.Goal.TokensUsed != 250 ||
-		edited.Goal.Status != GoalStatusActive ||
-		edited.Goal.StatusReason != "" {
-		t.Fatalf("edited goal = %#v", edited.Goal)
-	}
-
-	limited, _, err := store.EditGoal(session.SessionID, "Stay within budget", 200)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if limited.Goal == nil ||
-		limited.Goal.Status != GoalStatusBudgetLimited ||
-		limited.Goal.StatusReason != "token budget reached" ||
-		limited.Goal.TokensUsed != 250 {
-		t.Fatalf("budget-limited goal = %#v", limited.Goal)
-	}
-
-	before := *limited.Goal
-	eventsBefore, err := store.ReadEvents(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.EditGoal(session.SessionID, "   ", 200); err == nil {
-		t.Fatal("EditGoal should reject an empty objective")
-	}
-	if _, _, err := store.EditGoal(session.SessionID, "Invalid budget", -1); err == nil {
-		t.Fatal("EditGoal should reject a negative token budget")
-	}
-	after, err := store.Get(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if after == nil || after.Goal == nil || *after.Goal != before {
-		t.Fatalf("invalid edit mutated goal: before=%#v after=%#v", before, after)
-	}
-	eventsAfter, err := store.ReadEvents(session.SessionID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(eventsAfter) != len(eventsBefore) {
-		t.Fatalf("invalid edit appended events: before=%d after=%d", len(eventsBefore), len(eventsAfter))
-	}
-}
-
-func TestCreateGoalRefusesImplicitReplacement(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "replace_session"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "First", 0); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "Second", 0); err == nil {
-		t.Fatal("CreateGoal should require an explicit clear before replacement")
-	}
-}
-
-func TestPauseGoalIfActiveDoesNotOverwriteTerminalState(t *testing.T) {
-	store := NewStore(StoreOptions{RootDir: t.TempDir()})
-	session, err := store.Create(CreateInput{SessionID: "terminal_session"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.CreateGoal(session.SessionID, "Finish", 0); err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := store.UpdateGoal(session.SessionID, GoalStatusComplete, ""); err != nil {
-		t.Fatal(err)
-	}
-
-	updated, event, err := store.PauseGoalIfActive(session.SessionID, "cancelled")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if event != nil || updated.Goal.Status != GoalStatusComplete {
-		t.Fatalf("terminal goal changed during cancellation: goal=%#v event=%#v", updated.Goal, event)
-	}
-}
@@ -43,7 +43,7 @@ func TestUpdateTitle(t *testing.T) {
 		t.Fatalf("title not trimmed/stored: %q", updated.Title)
 	}
 	if updated.UpdatedAt != before.UpdatedAt {
-		t.Fatalf("UpdatedAt must not change on rename: before=%q after=%q", before.UpdatedAt, updated.UpdatedAt)
+		t.Fatalf("UpdatedAt must not change on retitle: before=%q after=%q", before.UpdatedAt, updated.UpdatedAt)
 	}
 	if updated.EventCount != before.EventCount {
 		t.Fatalf("EventCount changed: before=%d after=%d", before.EventCount, updated.EventCount)
@@ -67,7 +67,7 @@ func TestUpdateTitle(t *testing.T) {

 	// An unchanged title is a no-op (still succeeds).
 	if _, err := store.UpdateTitle(session.SessionID, "Clean Generated Title"); err != nil {
-		t.Fatalf("no-op rename should succeed: %v", err)
+		t.Fatalf("no-op retitle should succeed: %v", err)
 	}

 	// An invalid session id is rejected.
@@ -76,30 +76,6 @@ func TestUpdateTitle(t *testing.T) {
 	}
 }

-func TestUpdateTitleIfCurrent(t *testing.T) {
-	store := newTitleTestStore(t)
-	session, err := store.Create(CreateInput{Title: "Automatic title"})
-	if err != nil {
-		t.Fatalf("create: %v", err)
-	}
-
-	updated, applied, err := store.UpdateTitleIfCurrent(session.SessionID, "Automatic title", "Generated title")
-	if err != nil || !applied || updated.Title != "Generated title" {
-		t.Fatalf("matching update = (%#v, %v, %v)", updated, applied, err)
-	}
-
-	if _, err := store.UpdateTitle(session.SessionID, "Manual title"); err != nil {
-		t.Fatalf("manual rename: %v", err)
-	}
-	updated, applied, err = store.UpdateTitleIfCurrent(session.SessionID, "Generated title", "Late generated title")
-	if err != nil {
-		t.Fatalf("stale update: %v", err)
-	}
-	if applied || updated.Title != "Manual title" {
-		t.Fatalf("stale update should preserve manual title: (%#v, %v)", updated, applied)
-	}
-}
-
 func TestUpdateModel(t *testing.T) {
 	store := newTitleTestStore(t)
 	session, err := store.Create(CreateInput{ModelID: "model-a"})
@@ -45,9 +45,6 @@ const (
 	EventSpecDraft          EventType = "spec_draft"
 	EventSpecApproved       EventType = "spec_approved"
 	EventSpecRejected       EventType = "spec_rejected"
-	EventGoalCreated        EventType = "goal_created"
-	EventGoalUpdated        EventType = "goal_updated"
-	EventGoalCleared        EventType = "goal_cleared"
 )

 type SessionKind string
@@ -68,29 +65,6 @@ const (
 	SpecStatusRejected SpecStatus = "rejected"
 )

-type GoalStatus string
-
-const (
-	GoalStatusActive        GoalStatus = "active"
-	GoalStatusPaused        GoalStatus = "paused"
-	GoalStatusBlocked       GoalStatus = "blocked"
-	GoalStatusBudgetLimited GoalStatus = "budget_limited"
-	GoalStatusUsageLimited  GoalStatus = "usage_limited"
-	GoalStatusComplete      GoalStatus = "complete"
-)
-
-type Goal struct {
-	Objective         string     `json:"objective"`
-	Status            GoalStatus `json:"status"`
-	StatusReason      string     `json:"statusReason,omitempty"`
-	TokenBudget       int        `json:"tokenBudget,omitempty"`
-	TokensUsed        int        `json:"tokensUsed,omitempty"`
-	ContinuationCount int        `json:"continuationCount,omitempty"`
-	ContinuationLimit int        `json:"continuationLimit,omitempty"`
-	CreatedAt         string     `json:"createdAt"`
-	UpdatedAt         string     `json:"updatedAt"`
-}
-
 type Metadata struct {
 	SessionID           string      `json:"sessionId"`
 	SessionKind         SessionKind `json:"sessionKind,omitempty"`
@@ -117,7 +91,6 @@ type Metadata struct {
 	SpecRejectReason    string      `json:"specRejectReason,omitempty"`
 	SpecSourceSessionID string      `json:"specSourceSessionId,omitempty"`
 	SpecImplSessionID   string      `json:"specImplSessionId,omitempty"`
-	Goal                *Goal       `json:"goal,omitempty"`
 	CreatedAt           string      `json:"createdAt"`
 	UpdatedAt           string      `json:"updatedAt"`
 	EventCount          int         `json:"eventCount"`
@@ -150,7 +123,6 @@ type CreateInput struct {
 	SpecRejectReason    string
 	SpecSourceSessionID string
 	SpecImplSessionID   string
-	Goal                *Goal
 }

 type ForkInput struct {
@@ -307,7 +279,6 @@ func (store *Store) Create(input CreateInput) (Metadata, error) {
 		SpecRejectReason:    strings.TrimSpace(input.SpecRejectReason),
 		SpecSourceSessionID: strings.TrimSpace(input.SpecSourceSessionID),
 		SpecImplSessionID:   strings.TrimSpace(input.SpecImplSessionID),
-		Goal:                cloneGoal(input.Goal),
 		CreatedAt:           timestamp,
 		UpdatedAt:           timestamp,
 		EventCount:          0,
@@ -719,7 +690,7 @@ func (store *Store) appendPreparedEventsLocked(sessionID string, inputs []prepar
 // serialized under the same per-session lock as AppendEvent and re-reads the
 // latest metadata under that lock before rewriting, so a concurrent append can't
 // clobber the new title (nor the title clobber a concurrent append's event
-// count/timestamp). UpdatedAt is deliberately left untouched: a rename is not
+// count/timestamp). UpdatedAt is deliberately left untouched: a retitle is not
 // activity, so it must not reorder the session in the resumable list. A blank
 // title is rejected so a failed model generation can never erase a useful
 // first-message title, and an unchanged title is a no-op (no rewrite/fsync).
@@ -751,40 +722,6 @@ func (store *Store) UpdateTitle(sessionID string, title string) (Metadata, error
 	return session, nil
 }

-// UpdateTitleIfCurrent replaces a session title only when it still matches
-// expected. It lets background automatic naming avoid overwriting a newer manual
-// rename while keeping the check and write under the same per-session lock.
-func (store *Store) UpdateTitleIfCurrent(sessionID string, expected string, title string) (Metadata, bool, error) {
-	if !ValidSessionID(sessionID) {
-		return Metadata{}, false, fmt.Errorf("invalid zero session id %q", sessionID)
-	}
-	trimmed := strings.TrimSpace(title)
-	if trimmed == "" {
-		return Metadata{}, false, fmt.Errorf("zero session title is required")
-	}
-	unlock, err := store.lockSession(sessionID)
-	if err != nil {
-		return Metadata{}, false, err
-	}
-	defer unlock()
-
-	session, err := store.readMetadata(sessionID)
-	if err != nil {
-		return Metadata{}, false, err
-	}
-	if session.Title != strings.TrimSpace(expected) {
-		return session, false, nil
-	}
-	if session.Title == trimmed {
-		return session, true, nil
-	}
-	session.Title = trimmed
-	if err := store.writeMetadata(session); err != nil {
-		return Metadata{}, false, err
-	}
-	return session, true, nil
-}
-
 // UpdateModel replaces a session's selected model without changing its activity
 // timestamp or event counters. An empty model clears the session override.
 func (store *Store) UpdateModel(sessionID string, modelID string) (Metadata, error) {
@@ -17,7 +17,6 @@ func Info(dir string, name string) (SkillInfo, bool) {
 			info.Hash = entry.Hash
 		}
 	}
-	info.HashDrift = skillHashDrift(skill, info.Hash)
 	return info, true
 }

@@ -76,10 +76,9 @@ type LockEntry struct {
 // SkillInfo bundles a discovered skill with its recorded source and hash, for
 // `skill info`.
 type SkillInfo struct {
-	Skill     Skill  `json:"skill"`
-	Source    string `json:"source,omitempty"`
-	Hash      string `json:"hash,omitempty"`
-	HashDrift bool   `json:"hashDrift"`
+	Skill  Skill  `json:"skill"`
+	Source string `json:"source,omitempty"`
+	Hash   string `json:"hash,omitempty"`
 }

 // Install fetches the skill at options.Source and copies its SKILL.md into
@@ -276,7 +275,6 @@ func InfoFromRoots(primaryDir string, roots []string, name string) (SkillInfo, b
 			info.Hash = entry.Hash
 		}
 	}
-	info.HashDrift = skillHashDrift(skill, info.Hash)
 	return info, true
 }

@@ -483,19 +481,3 @@ func hashContent(data []byte) string {
 	sum := sha256.Sum256(data)
 	return "sha256:" + hex.EncodeToString(sum[:])
 }
-
-// skillHashDrift reports whether the on-disk SKILL.md no longer matches the
-// lockfile hash recorded at install time. Missing lock hashes never count as
-// drift (agents-only / unlocked skills). A locked skill whose SKILL.md cannot
-// be read is treated as drifted — not as a clean match.
-func skillHashDrift(skill Skill, lockHash string) bool {
-	lockHash = strings.TrimSpace(lockHash)
-	if lockHash == "" {
-		return false
-	}
-	data, err := os.ReadFile(skill.Path)
-	if err != nil {
-		return true
-	}
-	return hashContent(data) != lockHash
-}
@@ -407,28 +407,4 @@ func TestInfoReturnsFrontmatterSourceAndHash(t *testing.T) {
 	if info.Hash != installed.Hash {
 		t.Fatalf("Info hash = %q, want %q", info.Hash, installed.Hash)
 	}
-	if info.HashDrift {
-		t.Fatal("expected no hash drift immediately after install")
-	}
-
-	if err := os.WriteFile(info.Skill.Path, []byte("---\nname: demo\ndescription: described\n---\nedited body\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	info, ok = Info(destDir, "demo")
-	if !ok {
-		t.Fatal("Info(demo) not found after edit")
-	}
-	if !info.HashDrift {
-		t.Fatal("expected hash drift after SKILL.md edit")
-	}
-}
-
-func TestSkillHashDriftUnreadableLockedPath(t *testing.T) {
-	missing := filepath.Join(t.TempDir(), "missing", "SKILL.md")
-	if !skillHashDrift(Skill{Path: missing}, "sha256:deadbeef") {
-		t.Fatal("expected drift when locked SKILL.md cannot be read")
-	}
-	if skillHashDrift(Skill{Path: missing}, "") {
-		t.Fatal("missing lock hash must not count as drift")
-	}
 }
@@ -827,7 +827,7 @@ func runChildProcess(ctx context.Context, binaryPath string, args []string, prog
 				// ExitCode() is -1 when the child was terminated by a signal rather
 				// than exiting. ProcessState.String() is the portable description
 				// (e.g. "signal: killed") — capture it so the failure isn't opaque.
-				signalDesc = exitErr.String()
+				signalDesc = exitErr.ProcessState.String()
 			}
 		} else {
 			return ChildRunResult{Events: events, Stderr: stderr.String(), ExitCode: -1, Started: started}, fmt.Errorf("run specialist child: %w", err)
@@ -12,12 +12,6 @@ import (
 // team is at its slot cap the member is queued and launches when a slot frees
 // (it stays pending in the coordinator until then).
 func (s *Swarm) Spawn(pol Policy, teamName, agentType, task, cwd string) (string, error) {
-	release, err := s.beginLifecycleAdmission()
-	if err != nil {
-		return "", err
-	}
-	defer release()
-
 	def, err := s.registry.Lookup(agentType)
 	if err != nil {
 		return "", err
@@ -29,44 +23,15 @@ func (s *Swarm) Spawn(pol Policy, teamName, agentType, task, cwd string) (string
 	}
 	s.rememberCwd(id, cwd)
 	spec := s.buildSpec(pol, id, id, team, def, task, cwd)
-	s.dispatchAdmitted(spec)
+	s.dispatch(spec)
 	return id, nil
 }

-// beginLifecycleAdmission admits one unit of lifecycle work if shutdown has not
-// begun. On success it returns a release func the caller MUST call exactly once
-// (a deferred call is the norm) — Close blocks until every admitted unit has
-// released. On shutdown it returns a nil func and ErrSwarmClosed, and there is
-// nothing to release.
-//
-// It deliberately does NOT keep lifecycleMu held for the caller's duration, which
-// an earlier revision did. Close needs the write lock before it can cancel, so a
-// launcher that blocks in Launch until its context is cancelled would deadlock
-// against every Close caller: the launch holds the read lock while Close waits
-// for the write lock to issue the cancellation neither side can reach. Holding the
-// lock only across the flag check and the counter increment keeps the ordering
-// guarantee (no admission once closed is set) without letting external launcher
-// code sit inside the critical section.
-//
-// The read lock is enough to make the WaitGroup safe: Close flips closed under
-// the write lock, so an Add here either completes before Close acquires it (and is
-// therefore visible to the later Wait) or observes closed and is refused.
-func (s *Swarm) beginLifecycleAdmission() (func(), error) {
-	s.lifecycleMu.RLock()
-	defer s.lifecycleMu.RUnlock()
-	if s.closed {
-		return nil, ErrSwarmClosed
-	}
-	s.lifecycleWork.Add(1)
-	return s.lifecycleWork.Done, nil
-}
-
 // dispatch admits a spec to its team (launching now or queuing for a slot).
-// The caller must hold an admission ticket from beginLifecycleAdmission.
-func (s *Swarm) dispatchAdmitted(spec MemberSpec) {
+func (s *Swarm) dispatch(spec MemberSpec) {
 	t := s.team(spec.Team)
 	if t.admit(spec) {
-		s.launchAdmitted(t, spec)
+		s.launch(t, spec)
 	}
 	// Otherwise the spec is queued; the coordinator task stays pending until a
 	// slot frees and afterExit launches it.
@@ -74,73 +39,17 @@ func (s *Swarm) dispatchAdmitted(spec MemberSpec) {

 // launch starts a member for spec and supervises it. A synchronous launch
 // failure fails the task and frees the slot.
-// The caller must hold an admission ticket from beginLifecycleAdmission.
-func (s *Swarm) launchAdmitted(t *Team, spec MemberSpec) {
-	handle, err := s.launchMemberAdmitted(spec)
+func (s *Swarm) launch(t *Team, spec MemberSpec) {
+	handle, err := s.launcher.Launch(s.baseCtx, spec)
 	if err != nil {
 		_ = s.coord.Fail(spec.TaskID, "launch: "+err.Error())
-		if err == ErrSwarmClosed {
-			t.releaseSlot()
-			return
-		}
-		s.afterExitAdmitted(t)
+		s.afterExit(t)
 		return
 	}
-
-	committed := s.commitLaunch(handle, func() {
-		m := &Member{ID: spec.ID, AgentType: spec.AgentType, TaskID: spec.TaskID, handle: handle}
-		t.addMember(m)
-		_ = s.coord.SetStatus(spec.TaskID, StatusRunning)
-		s.watchers.Add(1)
-		go func() {
-			defer s.watchers.Done()
-			s.watch(t, m, spec)
-		}()
-	})
-	if !committed {
-		_ = s.coord.Fail(spec.TaskID, "launch: "+ErrSwarmClosed.Error())
-		t.releaseSlot()
-	}
-}
-
-// commitLaunch closes the window between MemberLauncher.Launch returning and the
-// swarm taking ownership of the handle it produced. Launch is external code and
-// therefore runs without lifecycleMu held, so Close may have won after
-// launchMemberAdmitted's pre-check but before Launch returned. adopt runs under
-// the read lock so the shutdown check and everything the caller does to take
-// ownership (registration, status transition, watcher Add, handle swap) are
-// atomic with respect to Close setting closed and beginning its waits.
-//
-// It reports whether the handle was adopted. When shutdown won, the handle is
-// reaped before returning false: its launch context was already cancelled by
-// Close, and MemberHandle has no separate cancellation operation — Launch's
-// context is its cancellation contract — so waiting is how a
-// successfully-created process/goroutine avoids being abandoned. The caller
-// records the terminal outcome for the task it was launching.
-func (s *Swarm) commitLaunch(handle MemberHandle, adopt func()) bool {
-	s.lifecycleMu.RLock()
-	if s.closed {
-		s.lifecycleMu.RUnlock()
-		_, _ = handle.Wait()
-		return false
-	}
-	defer s.lifecycleMu.RUnlock()
-	adopt()
-	return true
-}
-
-// launchMemberAdmitted re-checks shutdown at the last internal boundary before
-// invoking the external launcher. A lifecycle ticket proves the operation won
-// admission before Close, but the caller may not reach its launch until after
-// Close has set closed; in that case no new member should be started.
-func (s *Swarm) launchMemberAdmitted(spec MemberSpec) (MemberHandle, error) {
-	s.lifecycleMu.RLock()
-	closed := s.closed
-	s.lifecycleMu.RUnlock()
-	if closed {
-		return nil, ErrSwarmClosed
-	}
-	return s.launcher.Launch(s.baseCtx, spec)
+	m := &Member{ID: spec.ID, AgentType: spec.AgentType, TaskID: spec.TaskID, handle: handle}
+	t.addMember(m)
+	_ = s.coord.SetStatus(spec.TaskID, StatusRunning)
+	go s.watch(t, m, spec)
 }

 // watch awaits a member, applies bounded relaunch on temporary failures, records
@@ -151,98 +60,42 @@ func (s *Swarm) launchMemberAdmitted(spec MemberSpec) (MemberHandle, error) {
 // life (Member.ID == MemberSpec.ID); a retry never reuses the struct for a
 // different spec.
 func (s *Swarm) watch(t *Team, m *Member, spec MemberSpec) {
-	for {
-		res, err := m.handle.Wait()
-		if err != nil {
-			if isRetryable(err) && m.restarts < maxMemberRestarts && s.relaunchAdmitted(m, spec) {
-				continue
+	res, err := m.handle.Wait()
+	if err != nil {
+		if isRetryable(err) && m.restarts < maxMemberRestarts {
+			if nh, relErr := s.launcher.Launch(s.baseCtx, spec); relErr == nil {
+				m.restarts++
+				m.handle = nh
+				go s.watch(t, m, spec)
+				return
 			}
-			// Fall through if shutdown started or the relaunch failed.
-			// res.SessionID is preserved by the handle even on error, so a member that
-			// ran then failed stays drillable; a pure launch error carries an empty id.
-			_ = s.coord.FailWithSession(m.TaskID, memberError(err), res.SessionID)
-		} else {
-			_ = s.coord.CompleteWithSession(m.TaskID, res.Result, res.SessionID)
+			// fall through to record the original error if relaunch fails
 		}
-		break
+		// res.SessionID is preserved by the handle even on error, so a member that
+		// ran then failed stays drillable; a pure launch error carries an empty id.
+		_ = s.coord.FailWithSession(m.TaskID, memberError(err), res.SessionID)
+	} else {
+		_ = s.coord.CompleteWithSession(m.TaskID, res.Result, res.SessionID)
 	}
 	t.removeMember(m.ID)
 	s.afterExit(t)
 }

-// relaunchAdmitted performs one bounded relaunch of an existing member's spec,
-// reporting whether the member was relaunched and its new handle adopted. A
-// relaunch is lifecycle work like any other, so it runs the same three gates an
-// initial launch does: admission (refused outright once shutdown began), the
-// pre-Launch re-check, and the post-Launch commit — the last of which matters
-// because the production FuncLauncher returns a live handle immediately without
-// consulting its context, so a Close landing between the pre-check and the return
-// would otherwise resume supervising a member started after shutdown. When any
-// gate refuses, the caller records the member's terminal failure instead.
-func (s *Swarm) relaunchAdmitted(m *Member, spec MemberSpec) bool {
-	release, err := s.beginLifecycleAdmission()
-	if err != nil {
-		return false
-	}
-	defer release()
-	handle, err := s.launchMemberAdmitted(spec)
-	if err != nil {
-		return false
-	}
-	return s.commitLaunch(handle, func() {
-		m.restarts++
-		m.handle = handle
-	})
-}
-
 // afterExit releases the just-vacated slot and launches the next queued spec, if
 // any. Each exit drains at most one queued member; that member's own exit drains
 // the next, so the queue empties one-per-slot without unbounded recursion.
 func (s *Swarm) afterExit(t *Team) {
-	release, err := s.beginLifecycleAdmission()
-	if err != nil {
-		t.releaseSlot()
-		return
-	}
-	defer release()
-	s.afterExitAdmitted(t)
-}
-
-// afterExitAdmitted drains at most one queued spec while lifecycle admission is
-// held open. The caller must hold an admission ticket from beginLifecycleAdmission.
-func (s *Swarm) afterExitAdmitted(t *Team) {
 	next, ok := t.onExit()
 	if !ok {
 		return
 	}
-	// This call's own ticket only proves shutdown hadn't begun when it was
-	// granted; Close may have set closed in the meantime, and t.onExit above
-	// already removed next from t.queue, so Close's clearQueue sweep can no
-	// longer see it (nor will it wait for one, since this ticket is what Close's
-	// lifecycleWork.Wait() is blocked on). Re-check before launching so a dequeue
-	// that straddles the shutdown boundary fails the task in place of a launch a
-	// shutting-down swarm never wanted started.
-	s.lifecycleMu.RLock()
-	closed := s.closed
-	s.lifecycleMu.RUnlock()
-	if closed {
-		t.releaseSlot()
-		_ = s.coord.Fail(next.TaskID, ErrSwarmClosed.Error())
-		return
-	}
-	s.launchAdmitted(t, next)
+	s.launch(t, next)
 }

 // Handoff transfers a task to a fresh member of toAgentType, delivering a note to
 // the new member's inbox and marking the original task handed-off. It returns the
 // new task id. A handoff of an already-terminal task is rejected (fail closed).
 func (s *Swarm) Handoff(pol Policy, teamName, taskID, toAgentType, note string) (string, error) {
-	release, err := s.beginLifecycleAdmission()
-	if err != nil {
-		return "", err
-	}
-	defer release()
-
 	task, ok := s.coord.Get(taskID)
 	if !ok {
 		return "", fmt.Errorf("%w: %s", ErrUnknownTask, taskID)
@@ -278,7 +131,7 @@ func (s *Swarm) Handoff(pol Policy, teamName, taskID, toAgentType, note string)
 	// Retire the original task (it has been re-delegated).
 	_ = s.coord.SetStatus(taskID, StatusHandedOff)
 	spec := s.buildSpec(pol, newID, newID, team, def, handoffTask, cwd)
-	s.dispatchAdmitted(spec)
+	s.dispatch(spec)
 	return newID, nil
 }

@@ -286,12 +139,6 @@ func (s *Swarm) Handoff(pol Policy, teamName, taskID, toAgentType, note string)
 // (e.g. a crashed worker) onto fresh members of toAgentType, returning the
 // adopted task ids. Terminal tasks and tasks with a live owner are left alone.
 func (s *Swarm) AdoptOrphans(pol Policy, teamName, toAgentType string) ([]string, error) {
-	release, err := s.beginLifecycleAdmission()
-	if err != nil {
-		return nil, err
-	}
-	defer release()
-
 	def, err := s.registry.Lookup(toAgentType)
 	if err != nil {
 		return nil, err
@@ -314,7 +161,7 @@ func (s *Swarm) AdoptOrphans(pol Policy, teamName, toAgentType string) ([]string
 		cwd := s.cwdFor(task.ID)
 		s.rememberCwd(task.ID, cwd)
 		spec := s.buildSpec(pol, newAgent, task.ID, team, def, task.Description, cwd)
-		s.dispatchAdmitted(spec)
+		s.dispatch(spec)
 		adopted = append(adopted, task.ID)
 	}
 	return adopted, nil
@@ -2,7 +2,6 @@ package swarm

 import (
 	"context"
-	"errors"
 	"strings"
 	"sync"
 	"testing"
@@ -218,141 +217,6 @@ func TestPermanentErrorNoRetry(t *testing.T) {
 	}
 }

-func TestLifecycleAdmissionRejectedAfterClose(t *testing.T) {
-	l := newLauncher(okFor)
-	sw := newSwarmFor(t, l)
-	sw.Close()
-
-	if _, err := sw.Spawn(Policy{}, "team", "teammate", "task", ""); !errors.Is(err, ErrSwarmClosed) {
-		t.Fatalf("Spawn after Close error = %v, want ErrSwarmClosed", err)
-	}
-	if _, err := sw.Handoff(Policy{}, "team", "task", "teammate", "note"); !errors.Is(err, ErrSwarmClosed) {
-		t.Fatalf("Handoff after Close error = %v, want ErrSwarmClosed", err)
-	}
-	if _, err := sw.AdoptOrphans(Policy{}, "team", "teammate"); !errors.Is(err, ErrSwarmClosed) {
-		t.Fatalf("AdoptOrphans after Close error = %v, want ErrSwarmClosed", err)
-	}
-	if got := len(l.recorded()); got != 0 {
-		t.Fatalf("launches after Close = %d, want 0", got)
-	}
-}
-
-func TestCloseDoesNotLaunchQueuedMembers(t *testing.T) {
-	gate := make(chan struct{})
-	l := newLauncher(okFor)
-	l.gate = gate
-	sw := newSwarmFor(t, l)
-
-	var ids []string
-	for i := 0; i < 3; i++ {
-		id, err := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-		if err != nil {
-			t.Fatalf("Spawn %d: %v", i, err)
-		}
-		ids = append(ids, id)
-	}
-	if got := len(l.recorded()); got != 2 {
-		t.Fatalf("initial launches = %d, want 2 with one queued", got)
-	}
-
-	sw.Close()
-	if got := len(l.recorded()); got != 2 {
-		t.Fatalf("launches after Close = %d, want queued member not launched", got)
-	}
-	for _, id := range ids {
-		task, ok := sw.Coordinator().Get(id)
-		if !ok || !task.Status.terminal() {
-			t.Fatalf("task %s after Close = %+v, want terminal", id, task)
-		}
-	}
-}
-
-func TestClosePreventsMemberRetry(t *testing.T) {
-	started := make(chan struct{}, maxMemberRestarts+1)
-	release := make(chan struct{})
-	l := FuncLauncher{Run: func(context.Context, MemberSpec) (MemberResult, error) {
-		started <- struct{}{}
-		<-release
-		return MemberResult{}, ErrMemberTemporary
-	}}
-	sw := newSwarmFor(t, l)
-	_, err := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-	if err != nil {
-		t.Fatalf("Spawn: %v", err)
-	}
-	select {
-	case <-started:
-	case <-time.After(3 * time.Second):
-		t.Fatal("initial member did not start")
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	waitFor(t, "swarm closed state", func() bool {
-		sw.lifecycleMu.RLock()
-		defer sw.lifecycleMu.RUnlock()
-		return sw.closed
-	})
-	close(release)
-	select {
-	case <-closed:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Close did not return after retryable member exit")
-	}
-	select {
-	case <-started:
-		t.Fatal("member retried after Close")
-	default:
-	}
-}
-
-func TestCloseWaitsForMemberWatchers(t *testing.T) {
-	release := make(chan struct{})
-	l := FuncLauncher{Run: func(context.Context, MemberSpec) (MemberResult, error) {
-		<-release
-		return MemberResult{Result: "done"}, nil
-	}}
-	sw := newSwarmFor(t, l)
-	id, err := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-	if err != nil {
-		t.Fatalf("Spawn: %v", err)
-	}
-	waitFor(t, "task running", func() bool {
-		task, ok := sw.Coordinator().Get(id)
-		return ok && task.Status == StatusRunning
-	})
-
-	const callers = 3
-	closing := make(chan struct{}, callers)
-	closed := make(chan struct{}, callers)
-	for i := 0; i < callers; i++ {
-		go func() {
-			closing <- struct{}{}
-			sw.Close()
-			closed <- struct{}{}
-		}()
-	}
-	for i := 0; i < callers; i++ {
-		<-closing
-	}
-	select {
-	case <-closed:
-		t.Fatal("a Close caller returned before the member watcher exited")
-	case <-time.After(50 * time.Millisecond):
-	}
-	close(release)
-	for i := 0; i < callers; i++ {
-		select {
-		case <-closed:
-		case <-time.After(3 * time.Second):
-			t.Fatal("all Close callers did not return after the member watcher exited")
-		}
-	}
-}
-
 func TestHandoffDeliversNoteAndRetiresOriginal(t *testing.T) {
 	gate := make(chan struct{})
 	l := newLauncher(okFor)
@@ -500,587 +364,3 @@ func TestSpawnUnknownAgentType(t *testing.T) {
 		t.Fatal("Spawn with unknown agent type must error")
 	}
 }
-
-// blockingLauncher blocks inside Launch until its context is cancelled — the
-// shape of a real launcher that waits on a slot, a daemon connection, or a
-// sandbox handshake before it can return a handle.
-type blockingLauncher struct {
-	entered chan struct{}
-	once    sync.Once
-}
-
-func (l *blockingLauncher) Launch(ctx context.Context, spec MemberSpec) (MemberHandle, error) {
-	l.once.Do(func() { close(l.entered) })
-	<-ctx.Done()
-	return nil, ctx.Err()
-}
-
-// TestCloseCancelsLauncherBlockedInLaunch is the regression test for holding
-// lifecycle admission across MemberLauncher.Launch. When admission was a read lock
-// held for the caller's whole duration, this deadlocked: the spawn sat inside
-// Launch waiting for its context, while Close waited for the write lock it needed
-// before it could cancel that very context. Neither side could progress, so both
-// the spawn and every Close caller hung.
-//
-// Admission is now a counted ticket, so Close can flip the flag, cancel, and then
-// wait the ticket out.
-func TestCloseCancelsLauncherBlockedInLaunch(t *testing.T) {
-	launcher := &blockingLauncher{entered: make(chan struct{})}
-	sw := newSwarmFor(t, launcher)
-
-	spawned := make(chan error, 1)
-	go func() {
-		_, err := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-		spawned <- err
-	}()
-	select {
-	case <-launcher.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("launcher never entered Launch")
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	select {
-	case <-closed:
-	case <-time.After(5 * time.Second):
-		t.Fatal("Close deadlocked against a launcher blocked in Launch")
-	}
-	select {
-	case <-spawned:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Spawn never returned after Close cancelled the launch context")
-	}
-}
-
-// TestCloseWaitsForAdmittedSpawn pins the other half of the contract: Close is a
-// barrier, so it must not return while an admitted spawn is still running. Without
-// the lifecycleWork wait, Close could finish while this launch was mid-flight.
-func TestCloseWaitsForAdmittedSpawn(t *testing.T) {
-	entered := make(chan struct{})
-	finish := make(chan struct{})
-	launcher := &gatedLaunchLauncher{entered: entered, finish: finish}
-	sw := newSwarmFor(t, launcher)
-
-	go func() {
-		_, _ = sw.Spawn(Policy{}, "team", "teammate", "task", "")
-	}()
-	select {
-	case <-entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("launcher never entered Launch")
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	select {
-	case <-closed:
-		t.Fatal("Close returned while an admitted spawn was still in flight")
-	case <-time.After(200 * time.Millisecond):
-	}
-	close(finish)
-	select {
-	case <-closed:
-	case <-time.After(5 * time.Second):
-		t.Fatal("Close did not return after the admitted spawn finished")
-	}
-}
-
-// TestAdmittedDispatchDoesNotLaunchAfterClose covers an operation that won a
-// lifecycle ticket before shutdown but did not reach dispatch until after Close
-// set closed. The ticket keeps Close from returning early, but it must not permit
-// a new external launch with the already-cancelled swarm context.
-func TestAdmittedDispatchDoesNotLaunchAfterClose(t *testing.T) {
-	l := newLauncher(okFor)
-	sw := newSwarmFor(t, l)
-	sw.maxTeamSize = 1
-
-	if _, err := sw.coord.Register("late-task", "late-agent", "team", "late work"); err != nil {
-		t.Fatalf("Register late task: %v", err)
-	}
-	release, err := sw.beginLifecycleAdmission()
-	if err != nil {
-		t.Fatalf("beginLifecycleAdmission: %v", err)
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	waitFor(t, "swarm closed state", func() bool {
-		sw.lifecycleMu.RLock()
-		defer sw.lifecycleMu.RUnlock()
-		return sw.closed
-	})
-
-	sw.dispatchAdmitted(MemberSpec{
-		ID: "late-agent", TaskID: "late-task", AgentType: "teammate", Team: "team",
-	})
-	release()
-
-	select {
-	case <-closed:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Close did not return after the admitted dispatch finished")
-	}
-	if got := len(l.recorded()); got != 0 {
-		t.Fatalf("launches after closed was set = %d, want 0", got)
-	}
-	team := sw.team("team")
-	if got := team.Running(); got != 0 {
-		t.Fatalf("team running after rejected launch = %d, want 0", got)
-	}
-	task, ok := sw.Coordinator().Get("late-task")
-	if !ok {
-		t.Fatal("late task vanished")
-	}
-	if task.Status != StatusFailed || !strings.Contains(task.Err, ErrSwarmClosed.Error()) {
-		t.Fatalf("late task after Close = %+v, want failed with ErrSwarmClosed", task)
-	}
-}
-
-// TestCloseBetweenLaunchPrecheckAndReturn rejects and reaps a handle created by
-// a Launch that straddles shutdown. The launch has passed the pre-check when it
-// enters the gate; Close then sets closed and cancels its context before the
-// launcher is allowed to return successfully.
-func TestCloseBetweenLaunchPrecheckAndReturn(t *testing.T) {
-	launcher := &closeRaceLauncher{
-		entered: make(chan struct{}),
-		finish:  make(chan struct{}),
-		waited:  make(chan struct{}),
-	}
-	sw := newSwarmFor(t, launcher)
-
-	spawned := make(chan string, 1)
-	go func() {
-		id, _ := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-		spawned <- id
-	}()
-	select {
-	case <-launcher.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("launcher never entered Launch")
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	waitFor(t, "swarm closed state", func() bool {
-		sw.lifecycleMu.RLock()
-		defer sw.lifecycleMu.RUnlock()
-		return sw.closed
-	})
-	close(launcher.finish)
-
-	var id string
-	select {
-	case id = <-spawned:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Spawn did not return after Launch")
-	}
-	select {
-	case <-closed:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Close did not return after late handle was reaped")
-	}
-	select {
-	case <-launcher.waited:
-	default:
-		t.Fatal("late handle was not reaped")
-	}
-
-	team := sw.team("team")
-	if got := team.Running(); got != 0 {
-		t.Fatalf("team running after close-raced Launch = %d, want 0", got)
-	}
-	if got := len(team.liveAgents()); got != 0 {
-		t.Fatalf("registered members after close-raced Launch = %d, want 0", got)
-	}
-	task, ok := sw.Coordinator().Get(id)
-	if !ok {
-		t.Fatal("task vanished")
-	}
-	if task.Status != StatusFailed || !strings.Contains(task.Err, ErrSwarmClosed.Error()) {
-		t.Fatalf("task after close-raced Launch = %+v, want failed with ErrSwarmClosed", task)
-	}
-}
-
-type closeRaceLauncher struct {
-	entered chan struct{}
-	finish  chan struct{}
-	waited  chan struct{}
-	once    sync.Once
-}
-
-func (l *closeRaceLauncher) Launch(ctx context.Context, spec MemberSpec) (MemberHandle, error) {
-	l.once.Do(func() { close(l.entered) })
-	<-l.finish
-	return &closeRaceHandle{id: spec.ID, ctx: ctx, waited: l.waited}, nil
-}
-
-type closeRaceHandle struct {
-	id     string
-	ctx    context.Context
-	waited chan struct{}
-	once   sync.Once
-}
-
-func (h *closeRaceHandle) ID() string { return h.id }
-
-func (h *closeRaceHandle) Wait() (MemberResult, error) {
-	<-h.ctx.Done()
-	h.once.Do(func() { close(h.waited) })
-	return MemberResult{}, h.ctx.Err()
-}
-
-// TestCloseBetweenRetryLaunchPrecheckAndReturn is the retry counterpart of
-// TestCloseBetweenLaunchPrecheckAndReturn: a bounded relaunch wins admission and
-// passes the pre-check, then Close lands while the launcher is inside Launch. The
-// relaunched handle must be reaped rather than adopted, so the watcher never
-// resumes supervising a member started after shutdown began — a relaunch whose
-// member goes on to succeed must not be recorded as the task's outcome.
-func TestCloseBetweenRetryLaunchPrecheckAndReturn(t *testing.T) {
-	launcher := &retryCloseRaceLauncher{
-		entered: make(chan struct{}),
-		finish:  make(chan struct{}),
-		late:    &retryLateHandle{id: "teammate-1"},
-	}
-	sw := newSwarmFor(t, launcher)
-
-	id, err := sw.Spawn(Policy{}, "team", "teammate", "task", "")
-	if err != nil {
-		t.Fatalf("Spawn: %v", err)
-	}
-	// The first member exits retryable, so the watcher is now inside the relaunch.
-	select {
-	case <-launcher.entered:
-	case <-time.After(3 * time.Second):
-		t.Fatal("launcher never entered the relaunch Launch")
-	}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	waitFor(t, "swarm closed state", func() bool {
-		sw.lifecycleMu.RLock()
-		defer sw.lifecycleMu.RUnlock()
-		return sw.closed
-	})
-	close(launcher.finish)
-
-	select {
-	case <-closed:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Close did not return after the late relaunch handle was reaped")
-	}
-	if got := launcher.launchCount(); got != 2 {
-		t.Fatalf("launch attempts = %d, want 2 (initial + one relaunch)", got)
-	}
-	if got := launcher.late.waitCount(); got != 1 {
-		t.Fatalf("late relaunch handle waits = %d, want 1 (reaped, not supervised)", got)
-	}
-
-	team := sw.team("team")
-	if got := team.Running(); got != 0 {
-		t.Fatalf("team running after close-raced relaunch = %d, want 0", got)
-	}
-	if got := len(team.liveAgents()); got != 0 {
-		t.Fatalf("registered members after close-raced relaunch = %d, want 0", got)
-	}
-	task, ok := sw.Coordinator().Get(id)
-	if !ok {
-		t.Fatal("task vanished")
-	}
-	if task.Status != StatusFailed {
-		t.Fatalf("task after close-raced relaunch = %+v, want failed, not the late member's outcome", task)
-	}
-	if task.Result != "" {
-		t.Fatalf("task result after close-raced relaunch = %q, want the late member's result discarded", task.Result)
-	}
-}
-
-// retryCloseRaceLauncher fails its first member with a retryable error, then
-// blocks inside the relaunch's Launch until the test releases it.
-type retryCloseRaceLauncher struct {
-	mu      sync.Mutex
-	calls   int
-	entered chan struct{}
-	finish  chan struct{}
-	late    *retryLateHandle
-	once    sync.Once
-}
-
-func (l *retryCloseRaceLauncher) Launch(_ context.Context, spec MemberSpec) (MemberHandle, error) {
-	l.mu.Lock()
-	l.calls++
-	first := l.calls == 1
-	l.mu.Unlock()
-	if first {
-		return &temporaryHandle{id: spec.ID}, nil
-	}
-	l.once.Do(func() { close(l.entered) })
-	<-l.finish
-	return l.late, nil
-}
-
-func (l *retryCloseRaceLauncher) launchCount() int {
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	return l.calls
-}
-
-// temporaryHandle exits immediately with a retryable error, driving the watcher
-// into its bounded relaunch path.
-type temporaryHandle struct{ id string }
-
-func (h *temporaryHandle) ID() string { return h.id }
-
-func (h *temporaryHandle) Wait() (MemberResult, error) {
-	return MemberResult{}, ErrMemberTemporary
-}
-
-// retryLateHandle models a member whose work does not consult the cancelled
-// launch context and reports success. Adopting it after shutdown would record a
-// post-close result on the task, so a correct shutdown reaps it exactly once and
-// discards what it returns.
-type retryLateHandle struct {
-	id    string
-	mu    sync.Mutex
-	waits int
-}
-
-func (h *retryLateHandle) ID() string { return h.id }
-
-func (h *retryLateHandle) Wait() (MemberResult, error) {
-	h.mu.Lock()
-	h.waits++
-	h.mu.Unlock()
-	return MemberResult{Result: "late result", SessionID: "late-session"}, nil
-}
-
-func (h *retryLateHandle) waitCount() int {
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	return h.waits
-}
-
-func TestCloseRacesLifecycleAdmission(t *testing.T) {
-	gate := make(chan struct{})
-	l := newLauncher(okFor)
-	l.gate = gate
-	sw := newSwarmFor(t, l)
-
-	const spawns = 64
-	start := make(chan struct{})
-	results := make(chan struct {
-		id  string
-		err error
-	}, spawns)
-	var callers sync.WaitGroup
-	callers.Add(spawns)
-	for i := 0; i < spawns; i++ {
-		go func() {
-			defer callers.Done()
-			<-start
-			id, err := sw.Spawn(Policy{}, "team", "teammate", "racing task", "")
-			results <- struct {
-				id  string
-				err error
-			}{id: id, err: err}
-		}()
-	}
-	closed := make(chan struct{})
-	go func() {
-		<-start
-		sw.Close()
-		close(closed)
-	}()
-
-	close(start)
-	callers.Wait()
-	<-closed
-	close(results)
-
-	for result := range results {
-		if result.err != nil {
-			if !errors.Is(result.err, ErrSwarmClosed) {
-				t.Fatalf("Spawn racing Close error = %v, want ErrSwarmClosed", result.err)
-			}
-			continue
-		}
-		task, ok := sw.Coordinator().Get(result.id)
-		if !ok || !task.Status.terminal() {
-			t.Fatalf("admitted task %q after Close = %+v, want terminal", result.id, task)
-		}
-	}
-	for _, task := range sw.Coordinator().List() {
-		if !task.Status.terminal() {
-			t.Fatalf("task %q remained %s after Close", task.ID, task.Status)
-		}
-	}
-}
-
-// TestCloseFailsQueuedSpecOnLateCreatedTeam is the regression test for queue
-// sweeping after shutdown begins. Spawn/Handoff/AdoptOrphans calls that obtained
-// tickets before closed flipped can still create a team and append to its queue.
-// Close must wait for those calls before both snapshotting teams and sweeping
-// their queues, or a late-created team's queued task remains pending forever.
-//
-// This drives that interleaving directly: two operations obtain tickets before
-// Close, then the first creates and fills a previously unseen one-slot team and
-// the second queues behind it after Close has flipped closed.
-func TestCloseFailsQueuedSpecOnLateCreatedTeam(t *testing.T) {
-	sw := newSwarmFor(t, newLauncher(okFor))
-	sw.maxTeamSize = 1
-
-	if _, err := sw.coord.Register("late-task", "late-agent", "team", "late work"); err != nil {
-		t.Fatalf("Register late task: %v", err)
-	}
-	firstRelease, err := sw.beginLifecycleAdmission()
-	if err != nil {
-		t.Fatalf("first beginLifecycleAdmission: %v", err)
-	}
-	secondRelease, err := sw.beginLifecycleAdmission()
-	if err != nil {
-		firstRelease()
-		t.Fatalf("second beginLifecycleAdmission: %v", err)
-	}
-	runningSpec := MemberSpec{ID: "running-agent", TaskID: "running-task", AgentType: "teammate", Team: "team"}
-	queuedSpec := MemberSpec{ID: "late-agent", TaskID: "late-task", AgentType: "teammate", Team: "team"}
-
-	closed := make(chan struct{})
-	go func() {
-		sw.Close()
-		close(closed)
-	}()
-	waitFor(t, "swarm closed state", func() bool {
-		sw.lifecycleMu.RLock()
-		defer sw.lifecycleMu.RUnlock()
-		return sw.closed
-	})
-	select {
-	case <-closed:
-		t.Fatal("Close returned while an admitted ticket was still open")
-	default:
-	}
-
-	// Neither operation touched a team before Close took its old, buggy snapshot.
-	// Finish the team-admission portion of both operations while their tickets are
-	// still held: the first creates the team and fills its only slot; the second
-	// appends to that late-created team's queue.
-	team := sw.team("team")
-	if !team.admit(runningSpec) {
-		t.Fatal("first spec should take the late-created team's only slot")
-	}
-	firstRelease()
-	if team.admit(queuedSpec) {
-		t.Fatal("second spec should queue on the late-created team")
-	}
-	secondRelease()
-
-	select {
-	case <-closed:
-	case <-time.After(3 * time.Second):
-		t.Fatal("Close did not return after the admitted ticket released")
-	}
-
-	if got := team.QueueDepth(); got != 0 {
-		t.Fatalf("queue depth after Close = %d, want 0 (late spec swept)", got)
-	}
-	task, ok := sw.Coordinator().Get("late-task")
-	if !ok {
-		t.Fatal("late-queued task vanished")
-	}
-	if task.Status != StatusFailed {
-		t.Fatalf("late-queued task status = %v, want %v (failed, not stranded)", task.Status, StatusFailed)
-	}
-	if !strings.Contains(task.Err, ErrSwarmClosed.Error()) {
-		t.Fatalf("late-queued task err = %q, want it to mention %q", task.Err, ErrSwarmClosed.Error())
-	}
-}
-
-// TestAfterExitAdmittedFailsDequeuedSpecAfterClose is the regression test for
-// jatmn's second #776 finding: afterExitAdmitted used to dequeue a queued spec
-// (t.onExit) and launch it unconditionally once its own ticket was granted,
-// even though Close can flip closed in the gap between that dequeue — which
-// makes the spec invisible to Close's clearQueue sweep — and the launch. A
-// launcher that performs work before honoring its cancelled context could then
-// start a brand new worker after shutdown had already begun.
-func TestAfterExitAdmittedFailsDequeuedSpecAfterClose(t *testing.T) {
-	l := newLauncher(okFor)
-	sw := newSwarmFor(t, l)
-
-	if _, err := sw.coord.Register("queued-task", "queued-agent", "team", "queued work"); err != nil {
-		t.Fatalf("Register: %v", err)
-	}
-	spec := MemberSpec{ID: "queued-agent", TaskID: "queued-task", AgentType: "teammate", Team: "team"}
-
-	// Occupy the only slot, then queue spec behind it.
-	team := &Team{Name: "team", members: map[string]*Member{}, maxSize: 1}
-	if !team.admit(MemberSpec{ID: "running-agent", TaskID: "running-task"}) {
-		t.Fatal("first spec should take the only slot")
-	}
-	if team.admit(spec) {
-		t.Fatal("second spec should queue, not launch, over the cap")
-	}
-
-	// Simulate shutdown racing in between this call's ticket admission (already
-	// granted, hence no beginLifecycleAdmission call here) and its dequeue+launch,
-	// exactly like the finding describes: closed is already set by the time
-	// afterExitAdmitted's post-dequeue check runs.
-	sw.lifecycleMu.Lock()
-	sw.closed = true
-	sw.lifecycleMu.Unlock()
-
-	sw.afterExitAdmitted(team) // running-agent "exits" -> dequeues spec
-
-	if got := team.Running(); got != 0 {
-		t.Fatalf("team running after close-raced drain = %d, want 0 (slot released, not held for a launch)", got)
-	}
-	task, ok := sw.Coordinator().Get("queued-task")
-	if !ok {
-		t.Fatal("dequeued task vanished")
-	}
-	if task.Status != StatusFailed {
-		t.Fatalf("dequeued task status = %v, want %v (failed, not launched)", task.Status, StatusFailed)
-	}
-	if !strings.Contains(task.Err, ErrSwarmClosed.Error()) {
-		t.Fatalf("dequeued task err = %q, want it to mention %q", task.Err, ErrSwarmClosed.Error())
-	}
-	for _, s := range l.recorded() {
-		if s.ID == "queued-agent" {
-			t.Fatal("a spec dequeued after shutdown began must never launch")
-		}
-	}
-}
-
-// gatedLaunchLauncher blocks in Launch until the test releases it, ignoring
-// context cancellation so the test controls exactly when the admitted work ends.
-type gatedLaunchLauncher struct {
-	entered chan struct{}
-	finish  chan struct{}
-	once    sync.Once
-}
-
-func (l *gatedLaunchLauncher) Launch(_ context.Context, spec MemberSpec) (MemberHandle, error) {
-	l.once.Do(func() { close(l.entered) })
-	<-l.finish
-	return &funcHandle{id: spec.ID, done: closedChan()}, nil
-}
-
-func closedChan() chan struct{} {
-	ch := make(chan struct{})
-	close(ch)
-	return ch
-}
@@ -121,12 +121,11 @@ type Scheduler struct {
 	ctx    context.Context
 	cancel context.CancelFunc

-	mu        sync.Mutex
-	jobs      map[string]*scheduledJob
-	closed    bool
-	seq       atomic.Uint64
-	wg        sync.WaitGroup
-	closeOnce sync.Once
+	mu     sync.Mutex
+	jobs   map[string]*scheduledJob
+	closed bool
+	seq    atomic.Uint64
+	wg     sync.WaitGroup
 }

 // newScheduler builds a Scheduler bound to sw. Its context derives from the
@@ -230,13 +229,15 @@ func (s *Scheduler) List() []JobStatus {
 // Close cancels every job and waits for their loops to exit. Safe to call more
 // than once.
 func (s *Scheduler) Close() {
-	s.closeOnce.Do(func() {
-		s.mu.Lock()
-		s.closed = true
-		s.cancel()
+	s.mu.Lock()
+	if s.closed {
 		s.mu.Unlock()
-		s.wg.Wait()
-	})
+		return
+	}
+	s.closed = true
+	s.cancel()
+	s.mu.Unlock()
+	s.wg.Wait()
 }

 // run is one job's timing loop. It requests a fresh one-shot ticker per interval