Audit: async ticket / rendezvous lifecycle in fleetd msg package

.claude-plugin/marketplace.json

@@ -1,15 +1,15 @@
 {
-  "name": "fleetd",
+  "name": "claude-bridge",
   "description": "Tooling for orchestrating a fleet of delegated coding agents through the fleetd MCP gateway.",
   "owner": {
     "name": "LTMS"
   },
   "plugins": [
     {
-      "name": "fleet",
+      "name": "claude-bridge",
       "source": "./plugin",
-      "description": "Mount the fleetd MCP gateway and apply standard Claude Code settings so a session can orchestrate delegated workers. Ships no credentials.",
-      "version": "0.2.0",
+      "description": "Make a project bridge-ready: mount the fleetd MCP gateway and apply standard Claude Code settings so a session can orchestrate delegated workers. Ships no credentials.",
+      "version": "0.1.0",
       "author": {
         "name": "LTMS"
       }

.claude/skills/hunter/SKILL.md

@@ -1,102 +0,0 @@
----
-name: hunter
-description: Defect-hunt procedure for a fleetd worker — sweep an assigned package for real bugs and report several ranked findings without fixing anything. Load this when the lead asks you to hunt or audit a scope rather than review one diff. Do NOT load `reviewer` for this; the two want different output.
----
-
-# Hunter worker — procedure
-
-The turn contract (one `fleet_reply`, `fleet_ask` for the lead's decisions, honest reporting,
-never merge) is in **`CLAUDE.md` → Bridge communication → Worker** and already applies.
-
-**This skill is not `reviewer`.** `reviewer` judges one diff and reports the *single* most
-important issue in about 90 words. A hunt sweeps a whole package and reports *several* findings
-in a long structured form. Loading both gives you two contradictory output contracts, and the
-usual result is a worker that writes a good report into its terminal and ends the turn without
-sending it. Load exactly one.
-
-## 0. Read this before you read code: how the report gets home
-
-Your terminal reaches nobody. The lead sees **only** the text inside your `fleet_reply` call.
-
-A long report is exactly the case where this goes wrong, so plan for it:
-
-- **Write the report into the `fleet_reply` argument itself.** Do not compose it in your terminal
-  and then summarise it into the call.
-- If the report is long, **send it anyway** — one `fleet_reply` with everything.
-- If you end the turn without replying, the bridge scrapes your pane instead. That scrape carries
-  at most the last 4000 characters, and on a hunt it usually captures the tail of the lead's own
-  brief rather than your findings. The lead then has nothing and has to ask you again.
-
-## 1. Change nothing
-
-A hunt is read-only. Do not edit a production file, do not "quickly fix" what you find, and do
-not run a formatter. You may run the build and tests to *check* a claim, and you should say so
-when you did.
-
-## 2. Read the whole scope first
-
-Read every file in the assigned package before you judge any of it. A defect that a caller
-elsewhere in the same package makes unreachable is not a defect, and you cannot know that from
-one file.
-
-Stay inside the scope. If a defect there depends on a class outside it, read that class to
-confirm — but the defect itself must live in the scope you were given.
-
-## 3. The bar — this matters more than the count
-
-**Name the path into the bad state.** Say which caller, in which state, reaches it. A defect on
-paper is not a reachable defect. If you cannot name that path, keep the finding but mark it
-`unproven` and say exactly what you could not check. Do not drop it, and do not dress it up.
-
-**Say which direction the harm goes.** Data loss, privilege escalation and silent wrong answers
-are worth reporting even when the window is narrow. A finding whose worst outcome is a worse log
-line is not worth a block.
-
-Two workers once ran the same scope: the one that applied the direction-of-harm filter found ten
-real defects, the one that did not found none. Fewer findings the lead can act on beat many the
-lead has to triage.
-
-## 4. Shapes that have produced real merged fixes here
-
-Read for these first:
-
-1. **A one-way gate.** A guard added after an incident closes only the direction that incident
-   came from. Do not only ask what closes the gate — ask **which states still open it**.
-2. **A value read once, then used later to authorise something destructive**, after something
-   else has had a chance to change it.
-3. **A failure downgraded to a value that looks like a legitimate result** — `-1`, `null`, an
-   empty list, `false` — which a caller then trusts.
-4. **A lock held for one half of a read-modify-write and not the other**, or two collections
-   updated under different locks.
-5. **A comment or javadoc stating an invariant the code no longer keeps.** Comments are
-   load-bearing in this repo; a stale one has already caused a bug.
-
-## 5. What you cannot check, and must not claim you did
-
-- `fleetd/fleetd.yaml` is gitignored and **absent from your worktree**. You cannot read it. If a
-  finding depends on live configuration, name the key and say you could not check it.
-- `.mcp.json`, `opencode.json` and `.autoenv` in your worktree are neutralised stubs, not the
-  repo's real files.
-- The `wiki/` submodule pointer is months old. Do not cite it.
-
-Reporting a fact you took from the lead's brief as something you measured yourself is a false
-report, even when the fact is correct. Say where each fact came from.
-
-## 6. The report — what goes in `fleet_reply`
-
-One block per finding, most severe first:
-
-```
-FINDING N — <one line>
-file:line
-Path in:        <which caller, in which state, reaches this>
-Direction:      <data loss | escalation | silent wrong answer | outage | ...>
-Window/trigger: <when it actually happens>
-Confidence:     <confirmed by reading | unproven — say what you could not check>
-Why nothing else catches it: <the guard or test you checked, and why it misses>
-```
-
-End with one line naming every file you read, so the lead knows the denominator.
-
-**Nothing clears the bar?** Reply `NO FINDINGS`, name the files you read, and say what you ruled
-out. A clean sweep is a valid result; an invented defect is worse than none.

.claude/skills/reviewer/SKILL.md

@@ -10,11 +10,6 @@ never merge) is in **`CLAUDE.md` → Bridge communication → Worker** and alrea
 skill is only the *review procedure*: how to work the scope, and the exact shape of what you
 send back.
 
-**Wrong skill for a sweep.** This one reviews *one* diff or scope and reports the *single* most
-important issue. If the lead asked you to hunt or audit a whole package for several defects, load
-`hunter` instead and ignore this file — the two want different output, and following both is how a
-worker ends its turn with a good report that never gets sent.
-
 ## 1. Read the whole scope before you judge
 
 The delegation names your scope — a file, a diff, a PR, a function. **Read all of it first.**

.gitea/workflows/ci.yml

@@ -87,18 +87,12 @@ jobs:
           apt-get update && apt-get install -y --no-install-recommends maven
           mvn -version
 
-      # The `contract` profile clears the default-excludes group, so `-Dgroups=contract` runs every
-      # @Tag("contract") test and nothing from the unit suite the `build` job already covered — a
-      # tag selects the whole group, so a test added to it later runs here automatically. A prior
-      # version of this step pinned `-Dtest=AmqpReplyInboxContractTest` by class name instead: that
-      # silently excluded every other contract test (including the herdr ones) from CI, and nobody
-      # noticed until the herdr protocol drifted out from under a test that never ran here
-      # (fleetd #449). If this runner has no herdr socket, the herdr-backed tests in the group
-      # skip on their own `assumeTrue` and only the broker-backed ones actually run — check the
-      # step output rather than assuming which.
+      # The `contract` profile clears the default-excludes group, so the @Tag("contract") AMQP test
+      # runs against the RabbitMQ service container (AMQP_URI). Pinned to the one contract test to
+      # avoid re-running the unit suite already covered by the `build` job.
       - name: Contract tests
         working-directory: fleetd
-        run: mvn -B -Pcontract test -Dgroups=contract
+        run: mvn -B -Pcontract test -Dtest=AmqpReplyInboxContractTest
 
       - name: Failing test output
         if: failure()

AUDIT.md

@@ -0,0 +1,96 @@
+# Audit: async ticket / rendezvous lifecycle (`fleetd/src/main/java/dev/ltms/fleet/msg/`)
+
+Scope: `Rendezvous.java` and `MessageService.java` — the lifecycle of an async ticket
+(`Task`) and a rendezvous waiter: create, send, ask, answer, resolve, timeout, abandon, prune.
+
+## Main finding
+
+```
+1. fleetd/src/main/java/dev/ltms/fleet/msg/MessageService.java:938
+2. issue: answer() completes an async ticket's future with a QUESTION outcome when the worker
+   asks a second fleet_ask in the same resumed turn, permanently mislabeling a live delegation
+   as failed and losing its real reply to fleet_poll.
+3. fix: guard the finishAsyncTask(turnId, result) call at line 938 the same way sendAsync's
+   lambda already guards its own call (lines 999-1005): skip it when result.outcome() ==
+   Outcome.QUESTION, and instead re-associate the task with the new turnId (as markAsyncQuestion
+   does on the first ask).
+4. severity: high
+```
+
+### Call sequence that reaches it
+
+1. Lead: `fleet_send{sessionId: W, content: "task", wait:false}` → `sendAsync` creates `task1`
+   / `ticket1`. Its worker thread calls `send(W, content, ASYNC_TIMEOUT_MS, onAccepted, task1)`,
+   which does `asyncTasksByWaiter.put(reply, task1)` (line 802) before blocking on
+   `reply.get()`.
+2. Worker `W` calls `fleet_ask{"Q1"}` → `ask(W, "Q1", t)`. `markAsyncQuestion` finds `task1`
+   via `asyncTasksByWaiter`, stamps `task1.turnId = turnId1`,
+   `asyncTasksByTurn[turnId1] = task1`. `resolveQuestion` wakes step 1's `send()`, which returns
+   `Outcome.QUESTION`; `sendAsync`'s lambda sees `QUESTION` and deliberately does **not** call
+   `finishAsyncTask` (lines 1000-1005) — `ticket1` correctly polls `Phase.ASKING`.
+3. Lead polls, sees `ASKING`, answers: `fleet_send{turnId: turnId1, content: "A1"}` →
+   `answer(turnId1, "A1", t)`. This opens a **new** waiter via `rendezvous.open(workerSession)`
+   (line 929) but — unlike `send()` — never puts it into `asyncTasksByWaiter`.
+   `answerAsk(turnId1, "A1")` unblocks the worker's `ask()` call.
+   `clearAsyncQuestion(turnId1, false)` clears `task1.question` but keeps
+   `asyncTasksByTurn[turnId1] = task1` (deliberate, per its own javadoc). `answer()` then blocks
+   on its own `reply.get()` (line 936).
+4. Worker `W`, still in the same resumed turn, calls `fleet_ask{"Q2"}` again before replying →
+   a second `ask(W, "Q2", t)`. `openAsk` mints `turnId2`. `markAsyncQuestion` looks up
+   `asyncTasksByWaiter.get(waiter)` for the waiter `answer()` opened in step 3 — **not found**
+   (never registered), so `task == null`; `task1.turnId` stays `turnId1`, no
+   `asyncTasksByTurn[turnId2]` entry is ever created. `resolveQuestion` still succeeds (it only
+   needs a live waiter, not a `Task`) and wakes `answer(turnId1,...)`'s blocked `reply.get()`
+   with `Resolution(QUESTION, "Q2", turnId2)`.
+5. `answer(turnId1,...)` (line 936-939): `result = Reply(Outcome.QUESTION, "Q2", turnId2)`;
+   `finishAsyncTask(turnId1, result)` looks up `task1` by the **original** `turnId1` (still
+   stamped from step 3) and unconditionally does `task1.future.complete(result)` — completing
+   `ticket1`'s future with a **QUESTION** outcome, then removes `asyncTasksByTurn[turnId1]`.
+   `answer()` returns `Outcome.QUESTION` to the lead's own `fleet_send{turnId1,...}` call
+   (correct, and separately answerable via `turnId2`), but `ticket1` is now terminally done.
+
+### What goes wrong
+
+- `fleet_poll{ticket1}` now hits the `f.isDone()` branch in `poll()` permanently. `Outcome.QUESTION`
+  is not `REPLIED`/`COMPLETED_UNREPLIED` (`r.completed()` is false) and carries no
+  `WORKER_FAILED`/`BACKEND_EXHAUSTED` reason, so it falls through to
+  `Phase.FAILED`, `detail = "no reply — question"` — even though the worker is alive and only
+  waiting on `turnId2`.
+- `asyncTasksByTurn` no longer has any entry for `task1`/`target`, so
+  `hasAsyncQuestion(target)` goes back to `false` immediately, and `hasOrphanedDelegation`
+  no longer excludes this target's real state correctly either.
+- If the worker's eventual real `fleet_reply` (after `turnId2` is answered, or times out and it
+  finishes on its own) is not captured by a chained direct `answer(turnId2,...)` call,
+  `reply()`'s fast path (`rendezvous.resolve`) finds no live waiter, `askAnsweredAsyncTasks`
+  finds no candidate (`task1.future.isDone()` is already true, so it is excluded), and the reply
+  is silently dropped into the inbox as a **stranded reply** — unreachable from `ticket1` and
+  from `abandon()`'s stranded-reply recovery (no open `matching` task exists any more).
+
+### Confidence
+
+High. I traced this with no races or interleavings assumed beyond the documented, deterministic
+CB-205 chained-ask protocol that `outcomeOf`/`answer()` already generically support (mapping
+`Kind.QUESTION` through `answer()`'s own return value is clearly intentional — see the
+`Reply.turnId()` javadoc). I did not run the suite, but grepped
+`src/test/java/dev/ltms/fleet/msg/MessageServiceTest.java` for a test exercising a *second*
+`fleet_ask` inside one resumed (answered) turn and found none — `asyncQuestionBelongsToTheTaskThatOwnsItsForwardWaiter`
+and `askSurfacesAsAQuestionAndTheAnswerResumesTheSameTurn` both cover only a single ask per
+turn. A `git log -p` on this file also turned up the CB-588 comment (now at
+`sendAsync`, describing the `whenComplete` hook) which explicitly frames
+`answer()`'s `finishAsyncTask(turnId, result)` as firing "once a QUESTION is resolved" —
+i.e. the author modeled that call as inherently terminal, which is exactly the assumption this
+bug violates when the resumed turn asks again.
+
+## Secondary (much shorter)
+
+1. **Root-cause detail, same defect as above** — `answer()` (line 929) never puts its freshly
+   opened waiter into `asyncTasksByWaiter`, unlike `send()` (line 802). Even if the outcome
+   guard above is added, a chained second ask still can't be re-attached to `task1` via the
+   normal `markAsyncQuestion` path without also fixing this registration gap.
+2. **Low / shape only** — `pruneTerminalTickets()` (line ~1092) is only invoked from inside
+   `sendAsync()`. A fleet whose sessions stop receiving new async sends (e.g. everything now
+   goes through blocking `send()`, or the target churns and workers are torn down) never prunes
+   its already-terminal `tasks` entries past `TICKET_TTL_NANOS`. Not reachable as a "stuck"
+   ticket (tickets still resolve correctly), only as unbounded `tasks`/`asyncTasksByWaiter`-adjacent
+   memory growth over a long-lived daemon with no further `sendAsync` traffic; did not verify
+   this is realistic in production traffic patterns, flagging as a shape only.

CLAUDE.md

@@ -7,14 +7,6 @@
 > wiki ([Use Cases](https://git.ltms.dev/fleet/fleetd/wiki/7-Use-Cases) → *The portable
 > CLAUDE.md block*); improvements go to the template first, then out to each project. Anything
 > specific to *this* repo lives under §Project addendum below, never inline above it.
->
-> **Anything you measure in an addendum is perishable.** Date it, give the command that
-> re-measures it and what each outcome means, and tell the reader to delete the section once
-> it stops reproducing. The four parts work together: deciding what would falsify a claim is
-> the expensive step, and a reader in the middle of another task will not pay it, so a bare
-> "verify before relying on this" costs the same space and does nothing. The case this is for
-> is a note that goes stale as a live restriction — it will tell a future session it cannot do
-> the thing at the moment doing it becomes the job.
 
 If no `fleet_*` MCP tools are mounted in this session, this section does not apply — skip it.
 
@@ -79,11 +71,8 @@ below are the procedure — run them in order, every task, not only the big ones
    the final judgment call, verification, merges, and anything that depends on context only you
    hold. Nothing else is yours by default.
 3. **Spawn every delegated unit first** — `fleet_spawn{profile, worktree:true, ticket}`, one per
-   unit, *before* sending any. Pass `profile` explicitly: profiles differ in model, cost and
-   LIVENESS, not in tier, so the default is rarely what you want. The default is whatever the
-   daemon reports, and on a host where it sits on an exhausted or withdrawn credential every
-   unqualified spawn fails — sometimes loudly, sometimes as a member that spawns fine and then
-   produces nothing. `fleet_profiles` reports the default; check it once per session.
+   unit, *before* sending any. Pass `profile` explicitly: profiles differ in model and cost, not in
+   tier, so the default is rarely what you want.
 4. **Then send them all** — `fleet_send{sessionId, content, wait:false}`. Line 1 of every brief is
    `Load the <name> skill.` naming the worker's playbook; those skills are opt-in and that line is
    what makes them reliable. Where the project ships no such skill, spell the procedure out in the
@@ -105,18 +94,6 @@ below are the procedure — run them in order, every task, not only the big ones
 8. **Adjudicate, merge, tear down — yours alone.** Read the diff yourself: fully if it is small,
    targeted at the reported findings and the risky paths if it is large. Reviewer findings direct
    your attention; they never substitute for it. Then merge, then `fleet_stop{paneId}`.
-   **If the forge refuses you the merge** — a protected branch, a token without the grant — the
-   adjudication is still yours. Read the diff, decide, and hand the operator a merge-ready queue
-   with the refusal quoted. Never report a PR as merged, and never call one "ready to merge"
-   without having read the diff yourself. A refusal is exactly when that shortcut is tempting,
-   because no action is left that forces you to look, and taking it turns this step into
-   forwarding a reviewer's verdict — which is delegating the merge by proxy, two lines above.
-   **Test a refusal; do not read it off a permissions field.** A protected branch holds its merge
-   rights separately from the repository permissions, so that field can say yes while the merge is
-   refused, and still say no after a grant makes it work. Probe instead, with a request that cannot
-   succeed on its merits, so a rejection can only mean the refusal. Treat a transport failure as a
-   third answer that proves nothing: a timeout, a DNS error or a bad URL is not a refusal, and
-   counting it as one makes you sure of something you never measured.
 
 **Steps 3 and 4 are separate on purpose** — spawning and sending in one loop is how parallel work
 silently becomes serial, and it is the most common way this layer is wasted. For the same reason,
@@ -137,8 +114,7 @@ the merge — and merging on a reviewer's word is delegating it by proxy.
 | Answer a member's `fleet_ask` | `fleet_send{turnId, content}` — **not** `sessionId` |
 | Message a **peer lead** on this host | `fleet_send{sessionId: <their terminal>, content}` — `fleet_list` → `leads` reports it. Coordination only, **never** a task |
 | Message a **peer lead** on another daemon or host | `fleet_send{coordId: <their coord-id>, content}` — needs a `coordinator:` block; your own coord-id is in `fleet_list`. Coordination only, **never** a task |
-| Answer a peer lead that messaged you | `fleet_send{coordId}` — or `{sessionId}` if they are on this host. **Not** `fleet_reply`: it has no peer route and the publish is refused |
-| Read your own held lead-to-lead mail (no ack) | `fleet_poll{coordId: <your own coord-id, from fleet_list's coordinator.selfId>}` — primary-only; never acks, so `fleet_list`'s `held[]` still shows it after. `fleet_list`'s `held[]` gives only a truncated preview — this is the only way to read the full body |
+| Answer a peer lead that messaged you | `fleet_reply{content}` — the one case a lead replies |
 | Collect a held reply | `fleet_poll{target}` · then `fleet_ack{target, msgId}` |
 | Tear down a member | `fleet_stop{paneId}` |
 
@@ -164,21 +140,10 @@ The traffic between leads is coordination and nothing else:
 3. **Verify a peer exactly as you verify yourself.** Peer status buys nothing: check the claim
    against the code, and re-run the build. A peer's correction gets the same treatment — right or
    wrong on the evidence, not on who said it. Neither of you merges the other's work unreviewed.
-   **N observations are N data points only if they differ in the axis you are trusting.** This cuts
-   both ways. N *failures* blamed on one cause are one data point when the cases share what you are
-   not varying. N *agreeing measurements* are also one data point when they share an instrument —
-   two hosts, two operators and the same formula is one formula, not two confirmations.
-4. **Ask a peer to read your project addendum.** Your addendum is instruction surface: every future
-   session on your host obeys it, and a wrong one is obeyed just as faithfully as a right one. The
-   author is the worst reader of their own qualifier placement — measured here, one addendum carried
-   two defects and a non-author found both. If you have no peer, at least re-read it asking "which
-   sentence goes false first, and would a reader reach the caveat before acting?"
 
-Being messaged by a peer does not make you its worker: answer the way you would open —
-`fleet_send{coordId}` for another daemon, `fleet_send{sessionId}` on this host — and push back on
-the substance if it is wrong. `fleet_reply` resolves a member's blocked `fleet_send`; a peer's
-coord-id message is durable and non-blocking, so there is nothing for it to resolve. A peer that
-simply complies has thrown away the reason there are two of you.
+Being messaged by a peer does not make you its worker: answer with `fleet_reply`, and push back on
+the substance if it is wrong. A peer that simply complies has thrown away the reason there are two of
+you.
 
 ### Member (worker or architect) — the turn contract
 
@@ -235,27 +200,11 @@ must obey belongs in the charter, not here.
   adapter, with a message naming the credential and the remaining seconds ("cooling off after
   repeated backend errors") — distinct wording from a quarantine refusal, so don't conflate the
   two when reading a spawn failure.
-- **Skills available to delegate:** `implementer` (worktree → commit → push → own PR),
-  `reviewer` (one diff → one structured finding) and `hunter` (sweep a package → several ranked
-  findings, change nothing). Name exactly one in every delegation. **`reviewer` and `hunter` are
-  not interchangeable** — `reviewer` caps the answer at one finding in about 90 words, so naming
-  it for a multi-finding sweep hands the worker two contradictory output contracts. That has
-  already cost three workers' turns: each wrote a good report to its terminal and ended the turn
-  with no `fleet_reply`, and the scrape returned the tail of the brief instead.
+- **Skills available to delegate:** `implementer` (worktree → commit → push → own PR) and
+  `reviewer` (scoped review → one structured finding). Name one in every delegation.
 - **Primary-side skills** (not delegation playbooks — a worker cannot use them):
   `port-to-opencode` (make an OpenCode session a participant in this workspace) and
   `fleets-status` (report every fleet that shares one LavinMQ instance).
-- **This repo is also a Claude Code marketplace, and ships a plugin.** `.claude-plugin/marketplace.json`
-  points at `plugin/`, which carries the MCP mount and the `setup` skill
-  (`/claude-bridge:setup` — make any project bridge-ready). It was added in CB-527 and then went
-  unmentioned by every instruction file, so it drifted and a later session planned it from scratch
-  (#362). **Read `plugin/` before designing anything about onboarding a project.** Two limits are
-  structural, not bugs: a plugin cannot carry the role agent files, because
-  `ClaudeCodeLauncher.java:371` requires `<cwd>/.claude/agents/<role>.md` in the member's own
-  worktree; and a plugin cannot deliver anything to members at all, because
-  `ClaudeCodeLauncher.java:285` exports `CLAUDE_CONFIG_DIR` and every Claude profile here sets it,
-  so a member never reads the operator's plugin store. **The plugin is the lead-side surface;
-  member-facing assets travel in the worktree.**
 - **Never commit** `.mcp.json` (the primary's local copy, flagged `--skip-worktree`) or `wiki/`
   (a submodule with its own remote).
 - **A provisioned worktree neutralizes `.mcp.json`, `opencode.json` and `.autoenv`** — the repo's

deploy/fleetd.service

@@ -1,80 +1,72 @@
 # CB-504 — systemd unit for fleetd (Linux).
 #
-# fleetd #360: the previous version of this file started clean and broke the daemon in three ways
-# that nothing logs (see the DO NOT block and the ExecStart/PrivateTmp comments below for what and
-# why). The unit below, plus its companion deploy/herdr.service, is the version that has actually
-# run on fleet01 without those failures. Do not "improve" it back toward the old shape without
-# re-reading why each line is the way it is.
+# The macOS launchd agent (deploy/dev.ltms.fleetd.plist) is the supervision target for the
+# current single-host deployment. This unit exists for the per-host gateways CB-308 introduces,
+# which will run on Linux.
 #
 # Install (user service — fleetd drives the user's herdr, not a system daemon):
 #   mkdir -p ~/.config/systemd/user
-#   cp deploy/fleetd.service deploy/herdr.service ~/.config/systemd/user/
-#   # edit WorkingDirectory / ExecStart below for your host's paths and java location
+#   cp deploy/fleetd.service ~/.config/systemd/user/
+#   # edit ExecStart / WorkingDirectory / Environment below, then:
 #   systemctl --user daemon-reload
-#   systemctl --user enable --now herdr fleetd
-#   loginctl enable-linger $USER      # REQUIRED -- see below
+#   systemctl --user enable --now fleetd
 #   journalctl --user -u fleetd -f
-#
-# `loginctl enable-linger` is not optional and is easy to miss, because leaving it out looks like
-# success: `systemctl --user enable` reports "enabled" and both units run for as long as you stay
-# logged in. A user manager without lingering starts at your first login and stops at your last
-# logout, so the fleet simply does not come back after a reboot -- which is the whole reason to
-# use systemd here rather than the setsid scripts these units replaced. Check it with
-# `loginctl show-user $USER -p Linger`; the answer must be `Linger=yes`.
-#
-# Secrets (AI_GATEWAY_TOKEN, WORKER_GITEA_TOKEN, LAVINMQ_URI, COORD_AMQP_URI, ...) are not set
-# here and need no systemd drop-in: ExecStart runs a login shell, so they come from wherever your
-# login shell already sources them (this host: ~/.fleet/secrets.sh via ~/.zprofile). If a token is
-# missing there, fleetd still starts — the daemon reports every secret a configured profile
-# references, by name, never by value:
-#   journalctl --user -u fleetd | grep 'startup secret'
-# A resolved one logs "startup secret NAME: set (profile 'x' tokenEnv)"; a missing one logs
-# "startup secret NAME: MISSING" at WARN and the daemon starts anyway — the first visible symptom
-# is a member that cannot open a pull request, hours later and in a different component.
 
 [Unit]
-Description=fleetd — fleet message server
+Description=fleetd — claude-bridge message server
 Documentation=https://git.ltms.dev/fleet/fleetd/wiki
-# Ordering only. fleetd retries the herdr socket rather than exiting, which is what actually makes
-# a late socket survivable. Do NOT add Requires=: a herdr restart must not take fleetd down too.
+# Ordering only: herdr is a user process and its socket may appear after us. This is advisory —
+# fleetd retries the herdr socket rather than exiting, which is what actually makes a late
+# socket survivable. Do NOT add Requires=: a herdr restart must not take fleetd down with it.
 After=herdr.service
 Wants=herdr.service
 
 [Service]
 Type=simple
-WorkingDirectory=%h/LTMS/fleetd/fleetd
+WorkingDirectory=%h/src/claude-bridge/fleetd
+ExecStart=/usr/lib/jvm/temurin-25-jdk/bin/java -jar target/fleetd.jar fleetd.yaml
 
-# A LOGIN shell, not java directly. Every secret this daemon needs (AI_GATEWAY_TOKEN,
-# WORKER_GITEA_TOKEN, LAVINMQ_URI, COORD_AMQP_URI) lives in ~/.fleet/secrets.sh, which only
-# ~/.zprofile sources. systemd runs no login shell. Started any other way the daemon boots fine
-# and looks healthy, and the failure appears hours later as a member that cannot open a pull
-# request. exec keeps it one process, so systemd tracks the right PID.
-# This also avoids a SECOND copy of the secrets in a systemd drop-in: one source of truth.
-ExecStart=/bin/zsh -lc "exec java -jar target/fleetd.jar fleetd.yaml"
-
-# PrivateTmp MUST stay false -- see herdr.service. fleetd creates the member ZDOTDIR scrub dir and
-# the opencode config dir under java.io.tmpdir, and the member pane (a herdr child, a different
-# unit) has to read them. A private /tmp turns the credential scrub into a silent no-op.
-PrivateTmp=false
+Environment=HERDR_SOCKET_PATH=%h/.config/herdr/herdr.sock
+# PATH matters more than it looks (CB-511): fleetd propagates its own PATH to every worker it
+# spawns, so this line decides whether the fleet can run a build at all. systemd does not source a
+# login shell, so without it the daemon — and every worker — gets a bare default with no JDK/Maven.
+Environment=PATH=/usr/lib/jvm/temurin-25-jdk/bin:/usr/share/maven/bin:/usr/local/bin:/usr/bin:/bin
+# Secrets are NOT set here — this file is committed. Put ALL three tokens in a private drop-in
+# that systemd reads with restrictive permissions. In `systemctl --user edit fleetd`, add:
+#   [Service]
+#   Environment=FLEETD_API_TOKEN=...
+#   Environment=WORKER_GITEA_TOKEN=...
+#   Environment=AI_GATEWAY_TOKEN=...
+# FLEETD_API_TOKEN protects fleetd's API. WORKER_GITEA_TOKEN lets members open pull requests; if
+# it is missing, fleetd still starts, but a member fails when it later tries to open a pull request.
+# AI_GATEWAY_TOKEN authenticates gateway profiles; if it is missing, fleetd still starts, but a
+# gateway profile later returns HTTP 401. Or, put the same three variables in a 0600 file and add:
+# EnvironmentFile=%h/.config/fleetd/env
+# After starting, check which of them actually resolved. The daemon reports every secret a
+# configured profile references, by name, never by value:
+#   journalctl --user -u fleetd | grep 'startup secret'
+# A resolved one logs "startup secret NAME: set (profile 'x' tokenEnv)". A missing one logs
+# "startup secret NAME: MISSING" at WARN — and the daemon starts anyway, which is the whole
+# problem: without this grep the first sign is a member that cannot open a pull request, hours
+# later and in a different component.
+# Note what the report can and cannot tell you. It lists only names some profile actually
+# references (tokenEnv, gitTokenEnv, and the broker uriEnv). A secret nothing references is never
+# reported, because nothing needs it.
 
 Restart=on-failure
 RestartSec=10s
-# A bad config makes fleetd fail fast by design. Give up rather than restart-loop forever.
+# A bad config (e.g. a non-loopback bind without token auth) makes fleetd fail fast by design.
+# Give up rather than restart-loop on a permanent error.
 StartLimitBurst=5
 StartLimitIntervalSec=120
 
-# DO NOT add ProtectSystem=, ProtectHome=, ProtectKernelTunables= or ProtectControlGroups=.
-# Measured on fleet01 2026-09-05: each of those gives the unit its own mount namespace, and
-# fleetd resolves a caller role by running lsof to find the loopback peer PID
-# (mcp/LsofPeerPidLookup). Inside such a namespace lsof returns nothing, every caller falls back
-# to ANONYMOUS, and the primary is refused every orchestration call with
-# "unauthenticated: anonymous may not SPAWN".
-# The daemon still starts, healthz still returns ok and the secrets still resolve - the only
-# symptom is that the fleet cannot be driven at all. Verified by bisecting the directives:
-#   no sandbox 3 lsof lines | ProtectSystem=strict 0 | ProtectHome=read-only 0
-#   ProtectKernelTunables 0 | ProtectControlGroups 0 | RestrictSUIDSGID 3 | NoNewPrivileges 3
-# The two below add no mount namespace and are safe.
+# The daemon reads the repo, writes worktrees, and talks to a Unix socket — it needs no more.
 NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=read-write
+ProtectKernelTunables=true
+ProtectControlGroups=true
 RestrictSUIDSGID=true
 
 StandardOutput=journal

deploy/herdr-inner.sh

@@ -1,19 +0,0 @@
-#!/bin/zsh
-# fleetd #360 — template for the script deploy/herdr.service's ExecStart wraps in a pty.
-#
-# `script -qfec <this> /dev/null` needs a real command to run, and that command has to be a LOGIN
-# shell script: herdr itself needs the same secrets fleetd.service's login shell picks up (this
-# host: ~/.fleet/secrets.sh via ~/.zprofile), because members it spawns inherit its environment.
-# systemd's own Environment= lines in herdr.service are not enough for that -- they set TERM and a
-# bare PATH so the pty starts at all, nothing more.
-#
-# Copy this file to the path deploy/herdr.service's ExecStart names
-# (%h/LTMS/fleetd/fleetd-run/herdr-inner.sh by default) and `chmod +x` it. Not committed under
-# that path itself because the session name below is host-specific.
-
-# A 0x0 pty makes every pane spawn fail with "ghostty error -2" (see herdr-multi-instance-facts /
-# fleet01-headless-herdr-standup) -- give it a real size before herdr ever touches it.
-stty rows 50 cols 200
-
-# -l: login shell, so herdr and everything it spawns gets the real secrets and PATH.
-exec zsh -lc 'exec herdr --session <name>'

deploy/herdr.service

@@ -1,40 +0,0 @@
-# fleetd #360 — systemd unit for herdr (Linux), the terminal multiplexer fleetd drives.
-#
-# This is fleetd.service's companion: fleetd.service's After=/Wants=herdr.service assumes this
-# unit exists. Before this ticket it did not, so on a fresh host fleetd started against a herdr
-# that systemd never supervised at all.
-#
-# Install: see deploy/fleetd.service's header comment (both units install the same way).
-#
-# ExecStart below runs deploy/herdr-inner.sh (copy the template of that name from this directory
-# to the path in ExecStart, or point ExecStart at wherever you keep it, and make it executable).
-# It is a separate file rather than an inline command because it must itself be a login shell (see
-# its own header for why) and systemd's ExecStart does not run one.
-
-[Unit]
-Description=herdr terminal multiplexer (fleet session)
-Documentation=https://git.ltms.dev/fleet/fleetd/wiki
-
-[Service]
-Type=simple
-# script(1) gives herdr a real pty. Without it the client reports a 0x0 window and every pane
-# spawn fails with "ghostty error -2" -- which surfaces as a fleetd spawn failure, not a herdr one.
-ExecStart=/usr/bin/script -qfec %h/LTMS/fleetd/fleetd-run/herdr-inner.sh /dev/null
-StandardInput=null
-Environment=TERM=xterm-256color
-Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
-
-# PrivateTmp MUST stay false. fleetd writes the member ZDOTDIR scrub dir and the opencode config
-# dir under its own java.io.tmpdir, and the member pane -- a child of THIS process -- has to read
-# them. A private /tmp here silently breaks the credential scrub instead of failing loudly.
-PrivateTmp=false
-
-Restart=on-failure
-RestartSec=5s
-
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=herdr
-
-[Install]
-WantedBy=default.target

docs/CB-5xx-Hardening.md

@@ -192,7 +192,7 @@ Deliberately small; every one maps to a failure mode we have actually hit.
 | `fleet_send_duration_seconds` | histogram | delegated turn latency |
 | `fleet_replies_total{path}` | counter | path ∈ rendezvous\|inbox — how often a reply strands (CB-307's whole reason to exist) |
 | `fleet_inbox_depth{target}` | gauge | undrained replies; steady-state should be 0 |
-| `fleet_push_nudges_total{outcome}` | counter | outcome ∈ sent\|exhausted — a rising `exhausted` means the primary is not draining. `sent` was called `delivered` until fleetd #365; it counts the herdr paste-and-submit call returning, never a confirmation the pane read it |
+| `fleet_push_nudges_total{outcome}` | counter | outcome ∈ delivered\|exhausted — a rising `exhausted` means the primary is not draining |
 | `fleet_spawns_total{kind,outcome}` | counter | outcome ∈ ready\|timeout\|guard_rejected; per peer kind (CB-402) |
 | `fleet_sessions{state}` | gauge | SPAWNING/READY/BUSY/DONE census |
 | `fleet_herdr_calls_total{method,outcome}` | counter | socket health — the dependency everything rests on |

fleetd/fleetd.example.yaml

@@ -110,14 +110,6 @@ bind:
 #   notifications:
 #     mode: disabled
 
-# Idle-sleep guard: while at least one member is live, hold an OS-level assertion against idle
-# sleep (macOS only — a `caffeinate -i` child; a no-op elsewhere or if caffeinate is missing), so
-# an unattended host does not idle-sleep out from under a member's long turn. Unlike health/
-# configReload above, this is ON BY DEFAULT — omitting the block entirely leaves it enabled, the
-# same as `enabled: true`. Uncomment only to turn it off:
-# idleSleepGuard:
-#   enabled: false
-
 # herdr Unix socket. Omit to use the client default
 # (${HERDR_SOCKET_PATH:-~/.config/herdr/herdr.sock}).
 herdrSocket: ~/.config/herdr/herdr.sock
@@ -782,19 +774,6 @@ guard:
 # so fleetd falls back to the weaker CB-596 sentinel overlay instead (a WARN names the gap).
 # worktreeGroup: fleet-workers
 
-# fleetd #362: a directory of skill folders (each a subdirectory holding a SKILL.md, the same
-# shape as this repo's own .claude/skills/) copied into every PROVISIONED worktree's
-# .claude/skills/, so a member spawned against ANY repo — not only one that already ships its own
-# copy — can load a bridge skill (e.g. implementer). Unset (the default): no worktree is touched
-# beyond today's behaviour. A skill folder the target repo already carries under
-# .claude/skills/<name> is never overwritten — the repo's own copy always wins. Claude Code
-# members only; an opencode member reads a different path (.opencode/agent) this key does not
-# touch. Best-effort like worktreeGroup above: a missing/unreadable directory here is logged and
-# skipped, never a failed spawn. Every non-hidden subdirectory of this directory is copied
-# wholesale, with no per-file allowlist — don't park scratch files or drafts alongside the real
-# skill folders, they will be copied into every provisioned worktree too.
-# memberSkills: /path/to/fleetd/checkout/.claude/skills
-
 # Session lifecycle limits (CB-303). All knobs are opt-in; omit or set to null to keep
 # the feature disabled. By default the daemon never reaps, caps, or drains sessions.
 #   idleTtlSeconds     → reap READY/DONE sessions idle longer than this (never BUSY/SPAWNING)
@@ -842,17 +821,10 @@ guard:
 #              across every daemon sharing this vhost.
 #   prefetch → consumer basicQos, capping how many unacked messages the mailbox holds in-heap.
 #              Default 32 when omitted.
-#   peers    → fleetd #361: the coord-ids of the OTHER daemons on this vhost, declared by the
-#              operator (the daemon never guesses). fleet_list reports each one's live reachability
-#              (a passive queue check, never a presence protocol) alongside this daemon's own
-#              mailbox state. Omit, or leave empty, for a daemon with no known peers yet — an
-#              undeclared peer can still reach you and be reached by fleet_send, it just will not
-#              show up as a row in fleet_list.
 # coordinator:
 #   uriEnv: LEAD_COORD_URI
 #   selfId: mac-opus
 #   prefetch: 32
-#   peers: [fleet01-lead]
 
 # Active push-to-primary (CB-307 Stage 3). When a worker reply lands with no open fleet_send,
 # the ReplyPushLoop injects a *drain nudge* (never the payload) into the primary's own herdr
@@ -877,32 +849,3 @@ guard:
 #   terminal: term_65619bd6174568
 #   pushReminders: 5
 #   pushBackoffMs: 15000
-
-# Central allow-list of models any profiles: entry may name. Nothing checked a profile's model:
-# value before this block existed — it was a free-form string handed straight to the backend
-# adapter, and a withdrawn or misspelled name failed silently instead of at config load (opencode
-# falls back to a default model rather than erroring on an unknown -m).
-#
-# Absent, or present with an empty allow:, is OFF: no profile's model: is checked, exactly like
-# before this block existed. fleetd.yaml is gitignored on every host, so an upgrade must not force
-# every operator to enumerate their models before the daemon will start.
-#
-# The list is the authority; profiles: is checked against it, never the reverse — adding or
-# editing a profiles: entry cannot, by itself, widen what is permitted here.
-#
-# Enforcement is at CONFIG LOAD only (a bad model: fails the daemon at startup, naming both the
-# model and the profile). There is no spawn-time enforcement, no runtime on/off switch, and no
-# interaction with BackendQuarantine — those are separate, later units.
-#
-#   allow → the permitted models. Each entry is its own block (not a bare string) so a later unit
-#           can add an on/off state or a load limit per model without changing this shape.
-#     model → the model id exactly as a profiles: entry's model: field would write it. One flat,
-#             opaque-string namespace: a bare Claude id (claude-sonnet-5) and an opencode
-#             provider-prefixed id (openai/gpt-5.6-terra) both fit here unchanged — the check is a
-#             plain string match, never a parse of the provider prefix or a branch on kind:.
-# models:
-#   allow:
-#     - model: claude-sonnet-5
-#     - model: claude-opus-5
-#     - model: openai/gpt-5.6-terra
-#     - model: amazon.nova-pro-v1:0

fleetd/src/main/java/dev/ltms/fleet/Fleetd.java

@@ -55,8 +55,6 @@ import dev.ltms.fleet.member.MemberCredentialPolicyView;
 import dev.ltms.fleet.member.OpenCodeLauncher;
 import dev.ltms.fleet.placement.BackendOutagePolicy;
 import dev.ltms.fleet.placement.BackendQuarantine;
-import dev.ltms.fleet.power.CaffeinateSleepAssertionMechanism;
-import dev.ltms.fleet.power.IdleSleepGuard;
 import io.javalin.Javalin;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -69,7 +67,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.TreeSet;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -124,21 +121,12 @@ public final class Fleetd {
         // else can fail on a silently-empty one. A daemon started without a login shell (launchd)
         // boots fine either way — this is the only thing that says so out loud.
         reportRequiredSecrets(cfg);
-        // fleetd #377: the git host value a member receives as GITEA_HOST is often a full URL
-        // (scheme and trailing slash), not a host name. A member that assumes a bare host then
-        // builds https://https://... and the request never leaves the machine. Report the shape
-        // next to the secret report — shape only, never the value.
-        reportGitHostShape(cfg);
         reportMemberTrustModel(cfg);
         // CB-596: an absent (or empty) memberCredentials: block blocks NOTHING — no credential
         // name is hardcoded any more to fall back on. Say so loudly, the same way a missing
         // secret is reported above, so upgrading past this commit never silently drops CB-592's
         // protection.
         reportMemberCredentialsGap(cfg);
-        // fleetd #395: an unset exhaustedPattern is a silent opt-out of usage-limit detection for
-        // that profile — say so loudly, the same way the two reports above do, rather than let an
-        // operator discover it only when a limit goes undetected.
-        reportExhaustedPatternGap(cfg);
         // CB-559: `cfg` stays the startup snapshot — every validation and every piece of one-time
         // wiring below reads it, and must, because those decisions cannot be unmade. `config` is the
         // live reference the hot paths read per use. Which keys can actually move is ConfigRef's
@@ -149,16 +137,19 @@ public final class Fleetd {
         SubscriptionGuard guard = new SubscriptionGuard(cfg.guard().hostSet());
         guard.assertPrimaryClean(System.getenv());
 
-        // Every FleetConfig.validateXxx() the operator's config can fail — CB-501's auth-exposure
-        // check, CB-531's lead-tab-prefix check, CB-542's subscription-profile check, the charter
-        // and member-slot checks, and the "central allow-list of usable models" check — must run
-        // here, at load, before anything below opens a socket or spawns a member. fleetd ticket
-        // "central allow-list of usable models" follow-up: mutation testing found six individual
-        // calls here with nothing proving any of them still ran (deleting one left the full suite
-        // green). validateAll() replaces them with the one call that FleetConfigValidateAllTest
-        // and the Fleetd-startup tests actually pin — see FleetConfig#validateAll's javadoc for
-        // why a name-by-name list here would have the same defect it replaces.
-        cfg.validateAll();
+        // CB-501: refuse to start if the bind is wider than the auth mode can defend. Under
+        // loopback-trust, "not a known worker" means "the primary" — sound only because the OS
+        // refuses remote connections to a loopback socket. This throws rather than warns so the
+        // dangerous configuration cannot be reached by ignoring a log line.
+        cfg.validateAuthExposure();
+        cfg.validateLeadTabPrefixes();
+        // CB-542: a subscription:true profile whose env: reseats ANTHROPIC_BASE_URL/AUTH_TOKEN would
+        // reach an unguarded endpoint (the launcher skips SubscriptionGuard for it). Refuse at load.
+        cfg.validateSubscriptionProfiles();
+        cfg.validateCharters();
+        // CB-548: every architect slot must name a configured workers: profile — the strong-model
+        // backend the future spawn lifecycle would read. A stale reference dies here, not later.
+        cfg.validateMembers();
 
         Path socket = cfg.herdrSocket() != null && !cfg.herdrSocket().isBlank()
                 ? Path.of(cfg.herdrSocket())
@@ -232,13 +223,6 @@ public final class Fleetd {
                 profileName -> liveCountRef.get().apply(profileName),
                 quarantine,
                 outagePolicy);
-        // fleetd #422 follow-up: say which of the three model-gate states the daemon booted into —
-        // no models: block at all, a block armed with nothing off, or a block with N off — the same
-        // way exhaustedPatternCoverageLine/errorPatternCoverageLine report CB-578 stage A/fleetd
-        // #201 Unit 5 coverage just below. Read from workers.modelGateState() (never a separate
-        // config.get().models() here) so this line and fleet_profiles' modelGateArmed can never
-        // disagree about what CompositePeerLauncher's spawn gate actually enforces.
-        log.info("model gate (fleetd #422): {}", modelGateCoverageLine(workers.modelGateState()));
         // CB-504: under supervision (launchd/systemd) fleetd can start before herdr's socket
         // exists. The client itself is lazy — it connects per call — but the orphan reap below is
         // the first thing that actually talks to herdr, so without this wait a boot-order race
@@ -264,30 +248,11 @@ public final class Fleetd {
             contextCap = cfg.lifecycle().contextCap();
         }
         boolean clearAfterTurn = cfg.lifecycle() != null && cfg.lifecycle().clearAfterTurn();
-        SessionManager sessions = new SessionManager(workers,
-                new GitWorktrees(cfg.worktreeRoot(), cfg.worktreeGroup(), cfg.memberSkills()),
+        SessionManager sessions = new SessionManager(workers, new GitWorktrees(cfg.worktreeRoot(), cfg.worktreeGroup()),
                 System::nanoTime, contextCap, clearAfterTurn);
-        liveCountRef.set(profileName -> liveSessionCount(sessions.roster(), profileName));
-
-        // Idle-sleep guard: hold an OS-level assertion against idle sleep while at least one
-        // member is live, so an unattended host does not idle-sleep out from under a member's
-        // long turn (see FleetConfig.IdleSleepGuard / dev.ltms.fleet.power.IdleSleepGuard for the
-        // measurement that motivated this). Opt-out via idleSleepGuard.enabled: false; on by
-        // default. Hangs off SessionManager's own onAcquire/onRelease hooks (CB-520/CB-516,
-        // previously wired only to the reply inbox) and SessionManager#size() — the exact registry
-        // fleet_list's live/capacity numbers are themselves computed from — rather than tracking
-        // members a second way. No-op (never constructed) off macOS or when idleSleepGuard.enabled
-        // is explicitly false; the mechanism itself is additionally a no-op if 'caffeinate' cannot
-        // be started, so this can never fail a spawn, a release, or startup.
-        boolean idleSleepGuardEnabled = cfg.idleSleepGuard() == null || cfg.idleSleepGuard().isEnabled();
-        final IdleSleepGuard idleSleepGuard;
-        if (idleSleepGuardEnabled) {
-            idleSleepGuard = new IdleSleepGuard(new CaffeinateSleepAssertionMechanism(), sessions::size);
-            sessions.onAcquire(_ -> idleSleepGuard.recheck());
-            sessions.onRelease(_ -> idleSleepGuard.recheck());
-        } else {
-            idleSleepGuard = null;
-        }
+        liveCountRef.set(profileName -> (int) sessions.roster().stream()
+                .filter(s -> profileName.equals(s.profile()))
+                .count());
 
         // CB-303 part 1: idle-ttl reaper — only when configured, defaults to disabled.
         final SessionReaper reaper;
@@ -360,11 +325,7 @@ public final class Fleetd {
         // pane resolves to an architect until the later spawn lifecycle binds one. The registry is
         // what CallerResolver resolves against and what that lifecycle will read profiles from;
         // nothing here spawns a slot.
-        // fleetd #424: MemberRegistry.live re-reads fleet.architects through `config` on every
-        // reserve/requireSlotFor call, so a reload that removes or adds an architect slot governs
-        // the next spawn with no restart — the frozen `new MemberRegistry(cfg.fleet())` this used
-        // to be let a "revoked" slot keep granting new architect spawns forever.
-        MemberRegistry members = MemberRegistry.live(() -> config.get().fleet());
+        MemberRegistry members = new MemberRegistry(cfg.fleet());
         sessions.setMemberLifecycle(members);
         if (!members.slots().isEmpty()) {
             log.info("member slots: {} configured {} — none bound yet (a slot is idle until the "
@@ -392,7 +353,8 @@ public final class Fleetd {
                 .map(session -> exhaustedPatternsByProfile.get(session.profile()))
                 .orElse(null);
         log.info("backend-exhausted classification (CB-578 stage A): {}",
-                exhaustedPatternCoverageLine(cfg.profiles().keySet(), exhaustedPatternsByProfile.keySet()));
+                CompletionResolver.coverage("exhaustedPattern", cfg.profiles().keySet(),
+                        exhaustedPatternsByProfile.keySet()));
         // fleetd #201 Unit 5: classify a completion-fallback scrape that matches a profile's
         // configured backend-error refusal (a credential outage, a provider 5xx) as a backend error
         // rather than handing it back as a real answer. Compiled once at startup, keyed by profile
@@ -412,7 +374,8 @@ public final class Fleetd {
         BackendErrorPatternLookup backendErrorPatterns = backendErrorPatternLookup(sessions::roster,
                 errorPatternsByProfile);
         log.info("backend-error classification (fleetd #201 Unit 5): {}",
-                errorPatternCoverageLine(cfg.profiles().keySet(), errorPatternsByProfile.keySet()));
+                CompletionResolver.coverage("errorPattern", cfg.profiles().keySet(),
+                        errorPatternsByProfile.keySet()));
         // CB-578 stage B: on a classification that actually wins, quarantine the exhausted profile's
         // CREDENTIAL — not the profile name — so a profile sharing that credential (e.g. two models
         // on one OpenAI account) is refused too, not just the one that happened to report it. Reads
@@ -595,12 +558,8 @@ public final class Fleetd {
         if (cfg.health() != null && cfg.health().isEnabled()) {
             // CB-580: a member found GONE/NEVER_READY must fail whatever ticket is waiting on it,
             // through the same idempotent target-wide operation CB-516 already uses on release.
-            // fleetd #386: System::nanoTime freezes across a macOS sleep, so the stall check also
-            // gets a wall-clock source to detect and correct for that freeze. Every other decision
-            // in FleetHealthMonitor stays on the monotonic clock, unchanged.
             healthMonitor = new FleetHealthMonitor(agents, sessions::roster, messages, healthScheduler,
-                    System::nanoTime, () -> TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis()),
-                    cfg.health().intervalOrDefault(),
+                    System::nanoTime, cfg.health().intervalOrDefault(),
                     cfg.health().workingSuspectAfterOrDefault(), messages::abandon);
             String coverage = FleetHealthMonitor.coverage(true,
                     cfg.health().notifications() != null && cfg.health().notifications().configured());
@@ -668,34 +627,27 @@ public final class Fleetd {
             log.info("auth: loopback-trust (any loopback non-worker caller is the primary)");
         }
 
-        // fleetd #297: named once and reused verbatim below for FleetApp's GET /profiles, rather than
-        // built a second time — two independently-constructed sources reading the SAME BackendQuarantine
-        // / BackendOutagePolicy would still be able to drift (e.g. a future edit to the credentialIdFor
-        // closure in only one of the two places), exactly the shape #284 was.
-        FleetMcp.QuarantineSource quarantineSource = quarantineSource(config, quarantine,
-                exhaustedPatternsByProfile);
-        FleetMcp.OutageSource outageSource = new FleetMcp.OutageSource(profile -> {
-            var configured = config.get().profiles().get(profile);
-            return configured == null ? null : configured.effectiveCredentialId();
-        }, outagePolicy);
-
         FleetMcp mcp = new FleetMcp(messages, workers, sessions, identity, presence,
-                primaryRegistry, callers, metrics,
-                capacitySource(config, cfg, profile -> liveCountRef.get().apply(profile)),
+                primaryRegistry, callers, metrics, new FleetMcp.CapacitySource(profile -> liveCountRef.get().apply(profile),
+                profile -> {
+                    var configured = config.get().profiles().get(profile);
+                    return configured == null ? null : configured.maxLoad();
+                }, () -> config.get().profiles().keySet(), System::nanoTime),
                 new FleetMcp.HealthCoverageSource(() -> {
                     var health = config.get().health();
                     return FleetHealthMonitor.coverage(health != null && health.isEnabled(),
                             health != null && health.notifications() != null && health.notifications().configured());
                 }),
-                quarantineSource,
+                new FleetMcp.QuarantineSource(profile -> {
+                    var configured = config.get().profiles().get(profile);
+                    return configured == null ? null : configured.effectiveCredentialId();
+                }, quarantine),
                 leadMailbox,
-                outageSource,
-                new FleetMcp.LeadSeatSource(leadSeatLookup(() -> config.get().profiles(), leaders, leads)),
-                // fleetd #361: the operator-declared peers this daemon's fleet_list should try to
-                // reach. Read from the SAME snapshot leadMailbox itself opened from (cfg.coordinator()),
-                // not the live config.get() — coordinator wiring is already boot-time-fixed (see
-                // leadMailbox above), so peers follows the same rule rather than half hot-reloading.
-                cfg.coordinator() == null ? List.of() : cfg.coordinator().peers());
+                new FleetMcp.OutageSource(profile -> {
+                    var configured = config.get().profiles().get(profile);
+                    return configured == null ? null : configured.effectiveCredentialId();
+                }, outagePolicy),
+                new FleetMcp.LeadSeatSource(leadSeatLookup(() -> config.get().profiles(), leaders, leads)));
 
         // CB-637: the receive half. Only constructed when a lead mailbox actually opened — with no
         // coordinator (or an unreachable one) there is nothing to deliver, so no scheduler is
@@ -741,11 +693,6 @@ public final class Fleetd {
             if (configWatcher != null) configWatcher.stop(); // CB-559: stop polling the config file
             mcp.close();
             if (reaper != null) reaper.stop();
-            // Idle-sleep guard: release unconditionally, even though sessions.close() above already
-            // drained every session (and each release already drove the live count to 0, which
-            // releases the guard's assertion on its own) — this is the backstop for a drain that was
-            // itself interrupted or threw, so no caffeinate child ever outlives the daemon.
-            if (idleSleepGuard != null) idleSleepGuard.close();
             // Release the broker connection last among message resources (no-op for the in-memory inbox).
             if (replyInbox instanceof AutoCloseable closeable) {
                 try {
@@ -770,12 +717,9 @@ public final class Fleetd {
         // GET /sessions must merge across both, or a down/unpolled member daemon is invisible.
         // fleetd #111: live (re-read-per-request) memberCredentials view for GET /member-credentials —
         // same hot-reload shape as the memberCredentials supplier passed to ClaudeCodeLauncher above.
-        // fleetd #297: quarantineSource/outageSource are the SAME instances passed to FleetMcp above —
-        // GET /profiles must report the identical quarantine/cool-off facts as fleet_profiles.
         Javalin app = new FleetApp(herdr, memberHerdr, workers, sessions, messages, presence, mcp.servlet(),
                 callers, metrics, deliverable,
-                () -> MemberCredentialPolicyView.of(config.get().memberCredentials()),
-                quarantineSource, outageSource).build();
+                () -> MemberCredentialPolicyView.of(config.get().memberCredentials())).build();
         app.start(cfg.bind().host(), cfg.bind().port());
         log.info("fleetd listening on {}:{}, herdr socket {}",
                 cfg.bind().host(), cfg.bind().port(), socket);
@@ -804,106 +748,6 @@ public final class Fleetd {
         return target -> presence.isPresent(target) || leads.get().containsKey(target);
     }
 
-    /**
-     * fleetd #404: production source for quarantine reporting. Credential IDs are hot, but
-     * exhausted patterns are compiled once at startup for {@link CompletionResolver}, so the armed
-     * field must use that same compiled map until restart.
-     */
-    static FleetMcp.QuarantineSource quarantineSource(ConfigRef config, BackendQuarantine quarantine,
-            Map<String, Pattern> startupExhaustedPatterns) {
-        return new FleetMcp.QuarantineSource(profile -> {
-            var configured = config.get().profiles().get(profile);
-            return configured == null ? null : configured.effectiveCredentialId();
-        }, quarantine, profile -> startupExhaustedPatterns.containsKey(profile));
-    }
-
-    /**
-     * fleetd #415 (review follow-up): package-private factory for the CB-578 stage A {@code
-     * exhaustedPattern} startup coverage line, paired explicitly with {@link
-     * CompletionResolver.UnsetMeaning#OFF} — {@code exhaustedPattern} has no fallback, so a
-     * profile with none configured really does have the classification off.
-     *
-     * <p>Extracted out of {@code main} for the same reason {@link #capacitySource} and {@link
-     * #worktreeBranchLookup} were: {@code coverage()}'s own tests ({@code CompletionResolverTest})
-     * prove it words {@code OFF} and {@link CompletionResolver.UnsetMeaning#BUILT_IN_DEFAULT}
-     * correctly when a test supplies the meaning itself — they cannot prove {@code main} pairs the
-     * right meaning with the right key, which is the actual fleetd #415 defect. <b>Measured:</b>
-     * swapping the {@code UnsetMeaning} arguments between this method and {@link
-     * #errorPatternCoverageLine} — recreating #415's defect with the two keys exchanged — compiled
-     * with 0 errors and left all 1506 existing tests green before {@code
-     * FleetdPatternCoverageLineTest} was added to catch exactly that swap.
-     */
-    static String exhaustedPatternCoverageLine(Set<String> allProfiles, Set<String> configuredProfiles) {
-        return CompletionResolver.coverage("exhaustedPattern", CompletionResolver.UnsetMeaning.OFF,
-                allProfiles, configuredProfiles);
-    }
-
-    /**
-     * fleetd #415 (review follow-up): the {@code errorPattern} counterpart of {@link
-     * #exhaustedPatternCoverageLine}, paired explicitly with {@link
-     * CompletionResolver.UnsetMeaning#BUILT_IN_DEFAULT} — an unset {@code errorPattern} still runs
-     * backend-error classification against {@code CompletionResolver}'s built-in {@code
-     * BACKEND_ERROR} pattern, so the empty case is not "off". See {@link
-     * #exhaustedPatternCoverageLine}'s javadoc for the measured swap mutation this pairing guards
-     * against.
-     */
-    static String errorPatternCoverageLine(Set<String> allProfiles, Set<String> configuredProfiles) {
-        return CompletionResolver.coverage("errorPattern", CompletionResolver.UnsetMeaning.BUILT_IN_DEFAULT,
-                allProfiles, configuredProfiles);
-    }
-
-    /**
-     * fleetd #422 follow-up: package-private factory for the startup line reporting which of the
-     * three central {@code models.allow:} gate states the daemon booted into. Extracted the same
-     * way {@link #exhaustedPatternCoverageLine}/{@link #errorPatternCoverageLine} are, so a
-     * dedicated test can call it directly rather than parsing log output, and so {@code main}'s
-     * only source for this line is {@link PeerLauncher#modelGateState()} — never a second,
-     * independently-derived read of {@code cfg.models()} that could disagree with what {@code
-     * CompositePeerLauncher}'s spawn gate actually enforces (the fleetd #404 lesson).
-     *
-     * <p>Unlike the two pattern-key lines above, there is no {@code UnsetMeaning} choice to make
-     * here: {@link PeerLauncher.ModelGateState#configured()} already states, unambiguously, whether
-     * an empty {@link PeerLauncher.ModelGateState#off()} means "no {@code models:} block to gate
-     * with" or "a block armed and currently reporting zero off" — the exact two states a bare
-     * {@code disabledModels()} read could not tell apart before this ticket.
-     */
-    static String modelGateCoverageLine(PeerLauncher.ModelGateState state) {
-        if (!state.configured()) {
-            return "not configured (no models: block — nothing is gated, and nothing can be)";
-        }
-        Set<String> off = state.off();
-        return off.isEmpty()
-                ? "armed (models: block present; 0 models currently turned off)"
-                : "armed (" + off.size() + " model(s) turned off: " + new TreeSet<>(off) + ")";
-    }
-
-    /**
-     * fleetd #416: production source for {@code fleet_list}'s per-profile capacity facts.
-     *
-     * <p>The profile <em>set</em> ({@code configuredProfiles}) must come from {@code cfg} — the
-     * startup snapshot — not the live {@code config.get()}. {@code profiles} as a whole is a
-     * {@code DEFERRED} key ({@link ConfigRef#DEFERRED_KEYS}): {@code HerdrPeerLauncher} takes
-     * {@code Map.copyOf(profiles)} once at construction and a profile only added to the
-     * hot-reloaded map can never actually be spawned, so enumerating it live made {@code fleet_list}
-     * report a profile as available when {@code fleet_spawn} on that same profile fails with
-     * {@code unknown worker profile}. {@code fleet_list}'s own contract for {@code free} is "the
-     * same check the spawn gate itself runs" — the set the spawn gate can see is the startup one,
-     * so this must enumerate that one too, the same shape as {@code coordinator.peers} above.
-     *
-     * <p>{@code maxLoad} stays live on purpose: it is read off {@code config.get()} exactly like
-     * {@code credentialId} ({@link ConfigRef} documents both as hot), so an existing profile's
-     * {@code maxLoad} edit must still change what {@code fleet_list} reports without a restart.
-     */
-    static FleetMcp.CapacitySource capacitySource(ConfigRef config, FleetConfig cfg,
-            Function<String, Integer> liveCount) {
-        return new FleetMcp.CapacitySource(liveCount,
-                profile -> {
-                    var configured = config.get().profiles().get(profile);
-                    return configured == null ? null : configured.maxLoad();
-                },
-                cfg.profiles()::keySet, System::nanoTime);
-    }
-
     /**
      * fleetd #248: package-private factory for the member worktree/branch lookup {@link
      * CompletionResolver} uses to name a fallback report's worktree and branch (fleetd#241).
@@ -1015,19 +859,6 @@ public final class Fleetd {
                 .orElse(null);
     }
 
-    /**
-     * Count sessions that occupy a profile's spawn capacity. A {@code BACKEND_ERROR} or
-     * {@code FAILED} session stays in the roster so {@code fleet_list} can show its failure, but a
-     * member that cannot accept another delivery does not use a seat.
-     */
-    static int liveSessionCount(List<MemberSession> roster, String profileName) {
-        return (int) roster.stream()
-                .filter(session -> profileName.equals(session.profile()))
-                .filter(session -> session.state() != MemberSession.State.BACKEND_ERROR)
-                .filter(session -> session.state() != MemberSession.State.FAILED)
-                .count();
-    }
-
     /**
      * fleetd #248 / fleetd#201 Unit 5: factory for the production {@link BackendErrorSink} — the
      * collaborator {@link CompletionResolver} notifies when a pane-scrape classification actually
@@ -1310,76 +1141,6 @@ public final class Fleetd {
         });
     }
 
-    /**
-     * fleetd #377: the env var names holding the git host value that members receive as
-     * {@code GITEA_HOST}. {@code HerdrPeerLauncher.applyGitToken} injects {@code GITEA_HOST}
-     * only for profiles that opted in via {@code gitTokenEnv} (CB-302), reading the value from
-     * that profile's {@code gitHostEnv} (default {@code GITEA_HOST}), so the shape only matters
-     * where a git token is opted in. A var used by more than one profile is one entry naming
-     * every profile that reads it, the same shape as {@link #requiredSecretEnvVars}.
-     *
-     * <p>Package-private and pure (no I/O, no logging) so the derivation is unit-testable
-     * without capturing log output; {@link #reportGitHostShape(FleetConfig)} is the logging caller.
-     */
-    static Map<String, List<String>> gitHostEnvVars(FleetConfig cfg) {
-        Map<String, List<String>> hostsBy = new LinkedHashMap<>();
-        cfg.profiles().forEach((name, profile) -> {
-            if (profile.hasGitToken()) {
-                hostsBy.computeIfAbsent(profile.gitHostEnv(), _ -> new ArrayList<>())
-                        .add("profile '" + name + "' gitHostEnv");
-            }
-        });
-        return hostsBy;
-    }
-
-    /**
-     * True when the value already starts with a URI scheme ({@code https://...}, {@code
-     * http://...}). A bare host name and a host:port must both report {@code false} — the shape
-     * this ticket exists for is a value that <em>looks like</em> a host but is a full URL, and
-     * confusing those in the report would move the failure to the log instead of the network.
-     */
-    static boolean startsWithScheme(String value) {
-        return value.matches("[A-Za-z][A-Za-z0-9+.-]*://.*");
-    }
-
-    /**
-     * fleetd #377: log, on the same startup path as {@link #reportRequiredSecrets}, the SHAPE of
-     * each git host value that members receive as {@code GITEA_HOST}: set or unset, its length,
-     * whether it starts with a scheme, whether it ends with a slash. Never the value itself — the
-     * same discipline as {@link #reportRequiredSecrets}, which logs by name only. Either shape is
-     * legitimate: the value is passed to members unchanged, and a line that quietly rewrites it
-     * would change what works on one host and breaks on another. The shape line only tells the
-     * operator which URL form to expect from a member that builds on {@code GITEA_HOST}. An
-     * unset variable is logged at INFO — useful information, not an error — and the daemon
-     * starts on either way.
-     *
-     * <p>The env read lives in the overload below so a test can drive the line with a known
-     * value and prove that value never reaches the log.
-     */
-    static void reportGitHostShape(FleetConfig cfg) {
-        reportGitHostShape(cfg, System.getenv());
-    }
-
-    static void reportGitHostShape(FleetConfig cfg, Map<String, String> env) {
-        Map<String, List<String>> hostsBy = gitHostEnvVars(cfg);
-        if (hostsBy.isEmpty()) {
-            log.info("startup git host: no profile sets a gitTokenEnv — nothing to check");
-            return;
-        }
-        hostsBy.forEach((varName, sources) -> {
-            String value = env.get(varName);
-            if (value == null || value.isBlank()) {
-                log.info("startup git host {}: unset ({}) — a member gets GITEA_TOKEN but no "
-                        + "GITEA_HOST value", varName, String.join(", ", sources));
-            } else {
-                log.info("startup git host {}: set ({}) — length={}, startsWithScheme={}, "
-                                + "trailingSlash={}",
-                        varName, String.join(", ", sources),
-                        value.length(), startsWithScheme(value), value.endsWith("/"));
-            }
-        });
-    }
-
     /**
      * fleetd #184: state the member trust model at startup. Environment controls and worktrees do
      * not make a sandbox when fleetd and its members use the same OS user. A separate herdr may
@@ -1429,52 +1190,6 @@ public final class Fleetd {
                 + "fleetd.yaml — see fleetd.example.yaml — and restart.");
     }
 
-    /**
-     * fleetd #395: {@code exhaustedPattern} (see {@link FleetConfig.Profile#exhaustedPattern}) is
-     * deliberately opt-in — {@code null}/blank means a backend refusal on that profile is never
-     * classified as {@code BACKEND_EXHAUSTED}, so its credential is never quarantined. That is a
-     * legitimate choice (guessing the vendor's wording would be worse), but an operator who never
-     * opted a profile in should not discover the gap only when a usage limit silently goes
-     * undetected. Warn once at startup, naming every unarmed profile, exactly like {@link
-     * #reportMemberCredentialsGap} — never refuse to start over it.
-     *
-     * <p>A {@code subscription: true} profile that is unarmed gets a SECOND, louder WARN of its
-     * own: it bills the operator's metered Claude plan, the case where an undetected usage limit
-     * costs the most.
-     *
-     * <p>Package-private so a test can capture the real log via a {@link
-     * ch.qos.logback.core.read.ListAppender}, the same pattern {@link
-     * #reportMemberCredentialsGap}'s own test uses.
-     */
-    static void reportExhaustedPatternGap(FleetConfig cfg) {
-        List<String> unarmedSubscription = new ArrayList<>();
-        List<String> unarmedOther = new ArrayList<>();
-        cfg.profiles().forEach((name, profile) -> {
-            if (!profile.hasExhaustedPattern()) {
-                (profile.isSubscription() ? unarmedSubscription : unarmedOther).add(name);
-            }
-        });
-        if (unarmedSubscription.isEmpty() && unarmedOther.isEmpty()) {
-            log.info("exhaustedPattern: every configured profile has usage-limit detection armed");
-            return;
-        }
-        List<String> allUnarmed = new ArrayList<>(unarmedSubscription);
-        allUnarmed.addAll(unarmedOther);
-        allUnarmed = allUnarmed.stream().sorted().toList();
-        log.warn("exhaustedPattern: profile(s) {} have no exhaustedPattern configured — a "
-                        + "usage-limit refusal on any of them is never detected and never "
-                        + "quarantines its credential. Set exhaustedPattern (see "
-                        + "fleetd.example.yaml) to arm detection for a profile.",
-                allUnarmed);
-        if (!unarmedSubscription.isEmpty()) {
-            List<String> sortedSubscription = unarmedSubscription.stream().sorted().toList();
-            log.warn("exhaustedPattern: subscription profile(s) {} run on the operator's metered "
-                            + "Claude plan and have NO usage-limit detection armed — this is the "
-                            + "case where a missed usage limit costs the most.",
-                    sortedSubscription);
-        }
-    }
-
     /**
      * Poll herdr's {@code ping} until it answers or {@link #HERDR_WAIT_SECONDS} elapses (CB-504).
      *

fleetd/src/main/java/dev/ltms/fleet/auth/Authz.java

@@ -30,16 +30,6 @@ public final class Authz {
         DRAIN,
         /** Read-only observation: status, roster, profiles, task polling. */
         READ,
-        /**
-         * Read (never ack) this daemon's own held lead-to-lead coordination mail (fleetd #421).
-         *
-         * <p>Deliberately <strong>not</strong> folded into {@link #READ}. {@code READ}'s grant
-         * rests on "the roster carries no secrets" (see its case below) — a lead-to-lead body is
-         * not the roster; it is where leads discuss host shapes, credentials and unmerged work.
-         * Mapping this to {@code READ} would let any worker read every peer lead's mail in full
-         * and would silently falsify that comment for every other {@code READ} caller.
-         */
-        COORD_READ,
         /** Scrape the metrics endpoint. */
         METRICS
     }
@@ -78,11 +68,6 @@ public final class Authz {
             // Observation is open to every authenticated role: a worker legitimately polls its own
             // status, and the roster carries no secrets.
             case READ, METRICS -> caller.isPrimary() || caller.isWorker() || caller.isArchitect();
-
-            // fleetd #421: reading held lead-to-lead mail is the primary's alone. An architect
-            // holds READ today (CB-548), so "not primary" must mean not-architect here too — this
-            // is coordination between leads, not observation of the roster.
-            case COORD_READ -> caller.isPrimary();
         };
     }
 

fleetd/src/main/java/dev/ltms/fleet/auth/CallerResolver.java

@@ -236,15 +236,7 @@ public final class CallerResolver {
         // loopback-trust: same-host callers that are not workers are the primary. A non-loopback
         // caller is anonymous even here — and startup refuses that combination anyway
         // (FleetConfig.validateAuthExposure), so this is defence in depth, not the control.
-        //
-        // fleetd #317: "not a worker" must not be conflated with "identity unresolved". The real
-        // primary is a real process — its pid resolves (c.resolved()), it just owns no herdr pane.
-        // A caller whose peer-PID lookup failed (LsofPeerPidLookup's -1 sentinel — on any failure,
-        // silently including "lsof found no match") has no such pid, and PaneLocator's own javadoc
-        // already names what happens if that case is handed the primary role: a worker→primary
-        // escalation. So an unresolved caller is refused (ANONYMOUS — the same clean, already-tested
-        // "authenticated as nothing" outcome used everywhere else in this method), never promoted.
-        return isLoopback(remoteAddr) && c.resolved() ? Principal.primary(c.pid()) : Principal.anonymous();
+        return isLoopback(remoteAddr) ? Principal.primary(c.pid()) : Principal.anonymous();
     }
 
     private boolean presentedTokenMatches(String authorizationHeader) {
@@ -270,15 +262,11 @@ public final class CallerResolver {
         return token.isEmpty() ? null : token;
     }
 
-    /**
-     * fleetd #305: delegates to {@link ConnectionIdentity#isLoopback}. This used to be a second,
-     * independent copy of the same rule, and the two drifted: this one accepted all of
-     * {@code 127.0.0.0/8}, {@code ConnectionIdentity}'s accepted only {@code 127.0.0.1}. A caller
-     * from {@code 127.0.0.2} therefore had its identity skipped (so it had no terminal) and was
-     * then read as loopback here — which under loopback-trust is the primary. Sharing the inputs
-     * would not have prevented that; only sharing the computation does.
-     */
     private static boolean isLoopback(String remoteAddr) {
-        return ConnectionIdentity.isLoopback(remoteAddr);
+        if (remoteAddr == null) {
+            return false;
+        }
+        return remoteAddr.equals("127.0.0.1") || remoteAddr.equals("::1")
+                || remoteAddr.equals("0:0:0:0:0:0:0:1") || remoteAddr.startsWith("127.");
     }
 }

fleetd/src/main/java/dev/ltms/fleet/auth/MemberRegistry.java

@@ -11,7 +11,6 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.function.Supplier;
 
 /**
  * The architect-slot registry (CB-548): every gateway-local architect name and the strong-model
@@ -20,43 +19,16 @@ import java.util.function.Supplier;
  *
  * <p>Two halves, split by who owns each:
  * <ul>
- *   <li><b>slots</b> — read from {@code fleet.architects}/{@code developers}/{@code reviewers}
- *       (see {@link #slots()}), each carrying the {@code profile} reference the spawn lifecycle
- *       reads when it stands the slot up. <strong>Live, since fleetd #424</strong>: {@link #live}
- *       re-reads {@code fleet:} on every call, through a supplier the same shape as
- *       {@code CompositePeerLauncher}'s (see {@code ConfigRef}'s class doc) — so a config reload
- *       that removes or adds an architect slot governs the <em>next</em> spawn with no restart.
- *       Only {@link #MemberRegistry(FleetConfig.Fleet)} freezes the pool at construction, and that
- *       constructor exists for tests and for the (rare) case of wiring a fixed, code-built config.</li>
- *   <li><b>terminal bindings</b> — owned by this registry, initially <em>empty</em>, and
- *       <strong>never</strong> touched by a reload. Config declares no architect terminal, so at
- *       startup every slot is idle and nothing resolves to an architect; a session only becomes one
- *       when the spawn lifecycle {@linkplain #bind(String, String) binds} its terminal to a slot.
- *       {@link CallerResolver} reads this through {@link #snapshot()} to turn a pane into an
- *       {@link Role#ARCHITECT}.</li>
+ *   <li><b>slots</b> — configured once, keyed by the gateway-local unique name; each carries the
+ *       {@code profile} reference the spawn lifecycle reads when it stands the slot up. A read-only
+ *       snapshot taken at construction.</li>
+ *   <li><b>terminal bindings</b> — owned by this registry and initially <em>empty</em>. Config
+ *       declares no architect terminal, so at startup every slot is idle and nothing resolves to an
+ *       architect; a session only becomes one when the spawn lifecycle {@linkplain #bind(String,
+ *       String) binds} its terminal to a slot. {@link CallerResolver} reads this through
+ *       {@link #snapshot()} to turn a pane into an {@link Role#ARCHITECT}.</li>
  * </ul>
  *
- * <p><strong>The binding rule (fleetd #424): config governs what a bound slot still grants, as
- * well as what may be bound next.</strong> Removing a slot from config revokes it — that is the
- * ticket's entire point ("Revoking an architect slot does not revoke it"). Revoking it means an
- * architect already bound to that slot loses the ARCHITECT privilege on its very next request:
- * {@link #roleForSlot} and {@link #nameForSlot} read {@link #slots()} directly, with no cache, so
- * the moment a slot drops out of config, {@link CallerResolver#resolve} (which calls both on every
- * request from a bound pane, {@code CallerResolver.java:220}) can no longer confirm the pane's slot
- * is an architect slot, and the pane falls through to {@code Principal.worker(...)}. What does
- * <em>not</em> change is the {@code terminalToSlot} <em>occupancy</em> — the binding created by
- * {@link #bind} is untouched by a reload, on purpose: unbinding it here would double-book the slot
- * key (a second terminal could then bind to the "freed" key while the first is still the terminal
- * the operator actually meant to demote) and would silently break {@link #unbind}'s compare-safe
- * contract, which needs the original {@code terminal → slot} pair intact to remove it cleanly. So
- * the demoted session keeps occupying its slot — {@link #slotForTerminal} and {@link #snapshot()}
- * still name it — it just no longer resolves as an architect through that occupancy, and a fresh
- * spawn still cannot bind to the same key while it is occupied ({@link #reserve}/
- * {@link #requireSlotFor} refuse it anyway, since it is gone from {@link #slots()}). The demoted
- * session's own turn is unaffected: {@code fleet_reply}'s authorization
- * ({@code Authz.Action.REPLY}) is {@code caller.ownsSession(targetSession)} — identity by terminal,
- * not by role — so a demoted architect can still end its own turn normally.
- *
  * <p>Spawning/lifecycle is deliberately a separate unit: this class only owns the bindings and
  * exposes the map the resolver resolves against plus the profile lookup lifecycle will call.
  * Nothing here creates or manages an architect session.
@@ -83,42 +55,14 @@ public final class MemberRegistry implements MemberLifecycle {
         }
     }
 
-    private final Supplier<FleetConfig.Fleet> fleet;
+    private final Map<String, Entry> slots;
     /** Live {@code terminal_id → qualified slot key}; guarded by {@code terminalToSlot}. */
     private final Map<String, String> terminalToSlot = new HashMap<>();
     /** Slot keys held between reservation and the terminal binding. Guarded by terminalToSlot. */
     private final java.util.Set<String> reservedSlots = new java.util.HashSet<>();
 
-    /**
-     * Freeze the pool at construction — for tests, and for the rare case of wiring a fixed,
-     * code-built config. Production wiring should prefer {@link #live}, which re-reads
-     * {@code fleet:} on every call.
-     */
+    /** Flatten every role pool in {@code fleet} into one registry. Leaders are not members. */
     public MemberRegistry(FleetConfig.Fleet fleet) {
-        this(() -> fleet);
-    }
-
-    private MemberRegistry(Supplier<FleetConfig.Fleet> fleet) {
-        this.fleet = fleet;
-    }
-
-    /**
-     * Live variant (fleetd #424): {@code fleet} is read fresh on every {@link #slots()} call — pass
-     * {@code () -> config.get().fleet()}, the same supplier shape {@code CompositePeerLauncher}
-     * already uses for placement — so a reload that adds or removes an architect slot governs the
-     * next spawn's {@link #reserve}/{@link #requireSlotFor} check with no restart. A separate,
-     * private constructor rather than a same-arity public overload of
-     * {@link #MemberRegistry(FleetConfig.Fleet)}: a {@code FleetConfig.Fleet} and a
-     * {@code Supplier<FleetConfig.Fleet>} overload are ambiguous for a literal {@code null} — the
-     * same reason {@code CallerResolver.withLeads} is a static factory rather than a fourth
-     * constructor overload.
-     */
-    public static MemberRegistry live(Supplier<FleetConfig.Fleet> fleet) {
-        return new MemberRegistry(Objects.requireNonNull(fleet, "fleet"));
-    }
-
-    /** Flatten every role pool in {@code fleet} into one map. Leaders are not members. */
-    private static Map<String, Entry> flatten(FleetConfig.Fleet fleet) {
         Map<String, Entry> flat = new LinkedHashMap<>();
         if (fleet != null) {
             for (MemberRole role : MemberRole.values()) {
@@ -130,22 +74,18 @@ public final class MemberRegistry implements MemberLifecycle {
                 });
             }
         }
-        return Collections.unmodifiableMap(flat);
+        this.slots = Collections.unmodifiableMap(flat);
     }
 
-    /**
-     * The configured slots, keyed by qualified {@link Entry#key()}. Unmodifiable snapshot of
-     * {@code fleet:} <em>as of this call</em> — see the class doc for which constructor makes that
-     * live versus frozen.
-     */
+    /** The configured slots, keyed by qualified {@link Entry#key()}. Unmodifiable snapshot. */
     public Map<String, Entry> slots() {
-        return flatten(fleet.get());
+        return slots;
     }
 
-    /** The slots belonging to {@code role}, in definition order, as of this call. */
+    /** The slots belonging to {@code role}, in definition order. */
     public Map<String, Entry> slotsFor(MemberRole role) {
         Map<String, Entry> out = new LinkedHashMap<>();
-        slots().forEach((key, e) -> {
+        slots.forEach((key, e) -> {
             if (e.role() == role) {
                 out.put(key, e);
             }
@@ -177,49 +117,31 @@ public final class MemberRegistry implements MemberLifecycle {
     }
 
     /**
-     * The strong-model profile a slot runs under, as of this call.
-     *
-     * <p>Nothing in {@code src/main} calls this (fleetd #431 — grepped both the {@code
-     * .profileForSlot(} and the {@code ::profileForSlot} form). This javadoc used to say "what the
-     * spawn lifecycle reads", and that seam does not exist: the spawn lifecycle takes its profile
-     * from the {@link MemberLifecycle.SlotReservation} that {@code reserve} returns, never from
-     * here. Kept and pinned rather than deleted because it is the natural accessor for that seam
-     * if one is added; live for the same reason as {@link #roleForSlot}, so a reload cannot leave
-     * it answering for the old config.
+     * The strong-model profile a slot runs under — what the spawn lifecycle reads.
      *
      * @return the slot's configured {@code profile}, or {@code null} if the slot is unknown or
      *         declares none
      */
     public String profileForSlot(String slotName) {
-        Entry e = slots().get(slotName);
+        Entry e = slots.get(slotName);
         return (e == null || e.profile() == null) ? null : e.profile();
     }
 
-    /**
-     * The role a qualified slot key belongs to, or {@code null} when the key is not currently
-     * configured. Deliberately live, with no cache (fleetd #424, see the class doc's binding rule):
-     * removing a slot from config must make {@link CallerResolver#resolve} stop granting the
-     * ARCHITECT role for it on the very next request from a terminal that was bound to it, which is
-     * the ticket's whole point — revoking a slot must actually revoke it, not just refuse the next
-     * spawn.
-     */
+    /** The role a qualified slot key belongs to, or {@code null} when the key is unknown. */
     public MemberRole roleForSlot(String slotName) {
-        Entry e = slots().get(slotName);
+        Entry e = slots.get(slotName);
         return e == null ? null : e.role();
     }
 
-    /**
-     * The unqualified configured name for a slot, or {@code null} if it is not currently configured.
-     * Live for the same reason as {@link #roleForSlot} — see the class doc's binding rule.
-     */
+    /** The unqualified configured name for a slot, or {@code null} if it is unknown. */
     public String nameForSlot(String slotName) {
-        Entry e = slots().get(slotName);
+        Entry e = slots.get(slotName);
         return e == null ? null : e.name();
     }
 
     /** True when {@code slotName} is a configured architect slot. */
     public boolean isSlot(String slotName) {
-        return slots().containsKey(slotName);
+        return slots.containsKey(slotName);
     }
 
     /**

fleetd/src/main/java/dev/ltms/fleet/config/ConfigRef.java

@@ -22,179 +22,46 @@ import java.util.function.Supplier;
  * choice rather than an accident of where the field was initialised.
  *
  * <h2>Not every key can change under a running daemon</h2>
- * Keys fall into four classes, and the difference is about what already exists when the reload
+ * Keys fall into three classes, and the difference is about what already exists when the reload
  * happens — not about how important the key is.
  *
  * <ul>
  *   <li><strong>Hot</strong> — re-read per use, so a reload takes effect on the next spawn:
- *       {@code placement:}, and an existing profile's {@code weight} / {@code maxLoad}. Both are
- *       read through a supplier on {@code CompositePeerLauncher}, which is what makes them hot —
- *       not the fact that they are config. Most of {@code fleet:} — every role pool
- *       ({@code architects}/{@code developers}/{@code reviewers}), {@code charters}, and
- *       {@code tabLabel} — is read the same live way, through the same supplier
- *       ({@code () -> config.get().fleet()}). {@code architects} in particular is hot for
- *       <strong>two independent consumers</strong> (fleetd #424): {@code CompositePeerLauncher}
- *       reads it live for placement (which profile an unqualified architect spawn may land on), and
- *       {@code MemberRegistry} separately reads it live, through its own instance of the same
- *       supplier shape, for identity — both which slot a spawn may bind to <em>and</em> what a slot
- *       already bound still grants. Removing an architect slot from config therefore revokes the
- *       {@link dev.ltms.fleet.auth.Role#ARCHITECT} role on the bound pane's very next request; only
- *       the slot <em>occupancy</em> survives, so the demoted session still holds its slot key until
- *       it unbinds. See {@code MemberRegistry}'s class doc for that binding rule.
- *       <strong>But {@code fleet:} as a whole is NOT in this class</strong>: {@code fleet.leaders}
- *       inside the same key is frozen, which is exactly what makes {@code fleet:} split rather than
- *       hot — see below. {@code models:} (fleetd #422) joined this class whole: {@link
- *       FleetConfig#validateModels()} re-runs fully against the fresh config on every {@link
- *       #reload()} (via {@link FleetConfig#validateAll()}), refusing a bad edit outright rather than
- *       caching a stale copy anywhere, and the on/off half added by fleetd #422 is read live both by
- *       {@code CompositePeerLauncher}'s spawn gate ({@code enforceModelEnabled} and its candidate
- *       filter) and by {@code fleet_profiles}/{@code GET /profiles} (via
- *       {@code PeerLauncher.disabledModels()}). Nothing about {@code models:} is baked into an
- *       object built at startup, so — unlike the deferred keys below — there is no frozen half left
- *       to report; it moved here from deferred rather than joining split.</li>
+ *       {@code fleet:} (every role pool, {@code charters}, and {@code tabLabel}),
+ *       {@code placement:}, and an existing profile's {@code weight} / {@code maxLoad}. Those
+ *       three are read through a supplier on {@code CompositePeerLauncher}, which is what makes
+ *       them hot — not the fact that they are config. <strong>This does NOT include
+ *       {@code fleet.leaders}</strong>: {@code Fleetd.main} reads {@code cfg.fleet().leaders()}
+ *       once at startup to build the {@code LeadTabScanner} and the {@code LeadLauncher}, and
+ *       neither is reconstructed on reload — so a lead added, removed, or re-{@code tab}'d under
+ *       {@code fleet.leaders} needs a restart, the same as any deferred key below.</li>
  *   <li><strong>Deferred</strong> — accepted into the new snapshot, but the wiring built at startup
  *       keeps the old value until a restart: {@code lifecycle:}, {@code leadHeartbeat:},
- *       {@code idleSleepGuard:} ({@code Fleetd.java} reads it once, at startup, to decide whether
- *       to construct an {@code IdleSleepGuard} and wire {@code SessionManager}'s
- *       {@code onAcquire}/{@code onRelease} hooks to it — neither is rebuilt on reload, so a
- *       running daemon keeps whatever this was at startup regardless of a later edit),
  *       {@code spawnReadyTimeoutMs} / {@code spawnReadyPollMs}, {@code quarantineCooldownSeconds}
  *       (CB-578 stage B — baked once into the {@code BackendQuarantine} built at startup),
- *       {@code guard:}, {@code worktreeRoot:}, {@code worktreeGroup:} and {@code memberSkills:}
- *       (all three of the latter baked once into the {@code GitWorktrees} built at
- *       {@code Fleetd.java:251} and never rebuilt — fleetd #323 instance 2 found
- *       {@code worktreeGroup} missing from this list and from {@link #changedDeferredKeys};
- *       {@code memberSkills} (fleetd #362) followed the same shape), {@code primary:} (fleetd #326 — {@code Fleetd.java:506, 519,
- *       520} read {@code cfg.primary()} only off the startup snapshot to build {@code
- *       PrimaryRegistry} and size {@code ReplyPushLoop}'s reminder cap/backoff, and neither is
- *       rebuilt on reload. Say the consequence exactly: {@code primary.terminal} is DEPRECATED
- *       (CB-532, and {@code Fleetd.java:511} warns about it at startup) — a lead's identity comes
- *       from {@code leaders:}/{@code leadScan:}, so changing this pin does not demote or promote a
- *       lead that uses those. What a changed pin still does not take effect on until a restart is
- *       the fallback nudge destination the pin remains, the deprecated identity path for an operator
- *       who still relies on it, and {@code pushReminders}/{@code pushBackoffMs}), {@code configReload:} (fleetd #326 — {@code
- *       Fleetd.java:679-680} read it only at startup to decide whether to build a {@code
- *       ConfigWatcher} at all and with what interval; the watcher that would apply a later change is
- *       itself built once, so a running watcher keeps polling on its original enabled flag and
- *       interval regardless of what a reload changes it to, the same shape as {@code lifecycle} —
- *       not cold, because no already-open resource goes inconsistent with the new value, the watcher
- *       (if any) simply keeps its old settings), adding or removing a profile (a new backend needs its own launcher,
+ *       {@code guard:}, {@code worktreeRoot:}, adding or removing a profile (a new backend needs its own launcher,
  *       which is constructed once), <em>and an existing profile's launch settings</em> —
  *       {@code model}, {@code baseUrl}, {@code argv}, {@code env}, {@code mcpUrl},
  *       {@code exhaustedPattern} (CB-578 stage A — compiled once into {@code Fleetd.main}'s
  *       pattern map at startup), {@code errorPattern} (fleetd #201 Unit 5 — compiled once into
- *       {@code Fleetd.main}'s backend-error pattern map at startup, the same way),
- *       {@code ideProjectDir} / {@code ideOpenCommand} / {@code autoCompactWindow} (fleetd #323
- *       instance 1 — all three are read at spawn off the same frozen profile map and were missing
- *       from {@link #sameLaunchSettings}), and the rest of {@link #sameLaunchSettings}.
+ *       {@code Fleetd.main}'s backend-error pattern map at startup, the same way), and the rest.
  *       {@code credentialId} (CB-578 stage B) is NOT on
  *       this list — it is read live off the config supplier at every quarantine check and
  *       exhaustion event, exactly like {@code weight} / {@code maxLoad}, so it is hot instead.
  *       {@code HerdrPeerLauncher} takes {@code Map.copyOf(profiles)} at construction and resolves
  *       each spawn out of that copy, so those never reach a launch until the daemon restarts. A
  *       reload logs these rather than pretending they applied.</li>
- *   <li><strong>Split</strong> (fleetd #330; extended to a third key by fleetd #333) — read
- *       <em>both</em> ways at different sites, so the key does not fit any class above as a whole:
- *       {@code health:}, {@code coordinator:} and {@code fleet:}. Each is read off the startup
- *       snapshot to build a long-lived object, and read live off {@link #get()} at a different,
- *       unrelated site — so half of a reload's effect already applies while the other half waits
- *       for a restart, and a bare "config reloaded" would under-claim by exactly that half.
- *       <ul>
- *         <li>{@code health:} — the monitor itself ({@code enabled}, {@code intervalSeconds},
- *             {@code workingSuspectAfterSeconds}) is built once at {@code Fleetd.java:556-563}
- *             and never rebuilt, so a changed value needs a restart to actually start, stop, or
- *             retime it. The coverage string {@code fleet_profiles} reports
- *             ({@code Fleetd.java:648-650}) is read live off {@link #get()} on every call, so it
- *             already reflects the new value.</li>
- *         <li>{@code coordinator:} — the {@code LeadMailbox} connection ({@code uri},
- *             {@code uriEnv}, {@code selfId}, {@code prefetch}) is opened once at
- *             {@code Fleetd.java:502} and never reopened, so a changed value needs a restart —
- *             {@code selfId} in particular names this daemon's own AMQP inbox queue, and a peer
- *             lead that learned the old name would not discover a new one on its own. The broker
- *             URI env-var <em>name</em> that {@code MemberEnvAllowList} keeps out of a member's
- *             environment is read live off {@link #get()} on every spawn
- *             ({@code HerdrPeerLauncher.java:1530}), so it already applies.</li>
- *         <li>{@code fleet:} (fleetd #333) — {@code fleet.leaders} is the frozen half:
- *             {@code Fleetd.java:281} reads {@code cfg.fleet().leaders()} off the startup snapshot
- *             for two long-lived objects built right after it and never rebuilt — the
- *             {@code LeadTabScanner}'s {@code tab label → lead name} map ({@code Fleetd.java:301},
- *             wired into {@code CallerResolver.withLeadsAndMembers} at {@code Fleetd.java:620/624},
- *             which is how a caller's pane is recognised as a lead at all) and, when herdr answered
- *             at startup, {@code LeadLauncher(...).ensureLeads()} ({@code Fleetd.java:315}), which
- *             auto-launches each declared lead up to its {@code instances} count. So a lead added,
- *             removed, or given a new {@code tab:} label under {@code fleet.leaders} needs a
- *             restart — until then it is invisible to identity resolution, and this is exactly the
- *             scenario fleetd #333 named: an operator edits a lead's {@code tab:} to match a
- *             renamed pane, sees "config reloaded", and the pane keeps resolving as a worker,
- *             because {@code CallerResolver} is still matching against the old label. The live
- *             half is the rest of {@code fleet:} — {@code architects}/{@code developers}/
- *             {@code reviewers}, {@code charters}, {@code tabLabel} — read live through the same
- *             {@code CompositePeerLauncher} supplier the Hot bullet above names, so a reload that
- *             only touches those already applies with nothing to report. Because the hot and frozen
- *             halves of {@code fleet:} are disjoint sub-fields rather than the same fields read two
- *             ways (contrast {@code coordinator.uriEnv} above), {@link #changedSplitKeys} compares
- *             {@code fleet.leaders} alone, not the whole {@code Fleet} record — comparing the whole
- *             record would report "split" for a {@code tabLabel}-only change that is actually fully
- *             hot, over-claiming in exactly the direction this class exists to avoid under-claiming
- *             in.</li>
- *       </ul>
- *       A split change is still accepted — {@link Outcome#applied()} stays {@code true}, the same
- *       as a deferred change — because the live half genuinely took effect; refusing the whole
- *       reload would leave the operator worse off than today. {@link Outcome#split()} names the
- *       key and says which half is which each time, rather than trying to score "how changed" a
- *       mixed key is or handle "both halves changed in one reload" as a special case.</li>
- *   <li><strong>Cold</strong> — cannot change at all under a running daemon. All five of
- *       {@link #COLD_KEYS}: {@code bind:}, {@code herdrSocket:}, {@code memberHerdrSocket:},
- *       {@code broker:} and {@code auth:}. The sockets are already connected, the broker
+ *   <li><strong>Cold</strong> — cannot change at all under a running daemon: {@code bind:},
+ *       {@code herdrSocket:}, {@code broker:} and {@code auth:}. The socket is bound, the broker
  *       connection is open, and the auth mode decides who may reach the port that is already
- *       listening. This bullet omitted {@code memberHerdrSocket:} until fleetd #333 — say "all
- *       five of COLD_KEYS" rather than re-listing them, so prose and set cannot drift again.</li>
+ *       listening.</li>
  * </ul>
  *
- * <p><strong>The denominator, measured on 2026-09-04 (fleetd #330; recounted for fleetd #333);
- * recounted again for fleetd #362, again after {@code idleSleepGuard:} was added, again after
- * {@code models:} was added as deferred, and again for fleetd #422, which moved {@code models:}
- * from deferred to hot-excluded once its on/off half was read live everywhere.</strong>
- * {@code FleetConfig} has 25 top-level record components: 5 cold, 13 deferred, 3 split, 4
- * hot-excluded. Four of them are named nowhere in this file, and the reason is the same for all
- * four: {@code placement}, {@code memberCredentials}, {@code memberLoginShell} and {@code models}
- * are <strong>hot</strong> and correctly absent — all four are read live off {@code config.get()}
- * (placement through the {@code CompositePeerLauncher} supplier the Hot bullet names;
- * {@code memberCredentials}/{@code memberLoginShell} at spawn time, {@code Fleetd.java:198, 205, 729}
- * and {@code HerdrPeerLauncher#configuredMemberLoginShell}; {@code models} the same way, through the
- * Hot bullet's {@code models:} paragraph), so a reload takes effect on the next spawn (or, for
- * {@code models}, the next reported status) with no entry needed here.
- * {@code health} and {@code coordinator} used to be a third kind — <strong>undecided</strong>, not
- * hot — until fleetd #330 added the <strong>split</strong> class above and gave them a home. A
- * reload touching either used to report a bare "config reloaded", which under-claimed; now it names
- * the key and says which half is which. {@code fleet} was the same story in reverse: fleetd #330's
- * own fact-find named {@code health}/{@code coordinator} as "the complete set of split-shaped keys"
- * and filed {@code fleet.leaders}'s restart requirement as a documented caveat sitting in the
- * <strong>hot-excluded</strong> escape hatch instead — correctly documented, but in the one bucket
- * this file's own coverage test cannot check the truth of (see that test's javadoc). fleetd #333
- * moved it into <strong>split</strong>, where {@link #changedSplitKeys} actually reports it.
- * <p>The point of writing the count down: "not mentioned in this file" looks identical for a key
- * that is correctly hot and for a key nobody triaged. Three times now — {@code worktreeGroup} (#323),
- * {@code primary}/{@code configReload} (#326), and {@code fleet.leaders} sitting in the escape hatch
- * (#333) — the second kind hid among the first. A top-level coverage checker in the
- * {@link ConfigRefProfileCoverageTest} shape (one level up, over {@code FleetConfig} itself rather
- * than {@code FleetConfig.Profile}) proves this file's four classes exhaust the record's components
- * — see {@code ConfigRefTopLevelCoverageTest}. That test proves the record's <em>shape</em> is fully
- * triaged; it does NOT prove a {@code SPLIT_KEYS}/{@code COLD_KEYS}/{@code DEFERRED_KEYS} member has
- * any reporting code behind it at all — {@code ConfigRefTopLevelReportingCoverageTest} is what
- * fleetd #333 added for that, after measuring that a {@code SPLIT_KEYS} entry with its reporting
- * branch deleted passes both this file's own "kept in step" assert and
- * {@code ConfigRefTopLevelCoverageTest} unchanged. fleetd #337 extended it to {@code DEFERRED_KEYS}
- * after measuring the same one-way gap there directly: dropping {@code guard}'s branch out of
- * {@link #changedDeferredKeys} while {@code "guard"} stayed in the set left the whole suite green.
- *
  * <p><strong>A cold change refuses the whole reload.</strong> Not the hot half applied and the cold
  * half warned about: that would leave the running daemon in a state matching no file on disk, which
  * is the worst thing a reload can do to an operator debugging one. Refusing keeps the invariant that
  * the live config is always some version of the file, and the message names the keys that must
- * change through a restart. A split change does <em>not</em> refuse, for a different reason than a
- * deferred change does not: its live half genuinely took effect, so refusing would throw that away
- * and leave the operator worse off than the partial-but-honest report {@link Outcome#split()} gives.
+ * change through a restart.
  *
  * <p>A reload that fails to parse or fails validation is also refused, and the previous config keeps
  * running. A config file being edited is normally read once mid-save; degrading a working daemon
@@ -204,43 +71,10 @@ public final class ConfigRef implements Supplier<FleetConfig> {
 
     private static final Logger log = LoggerFactory.getLogger(ConfigRef.class);
 
-    /**
-     * Keys that cannot change under a running daemon — see the class doc.
-     *
-     * <p>Package-private (not {@code private}) so {@code ConfigRefTopLevelCoverageTest} can fold it
-     * into the top-level triage it checks, the same way it reads {@link #SPLIT_KEYS}.
-     */
-    static final Set<String> COLD_KEYS =
+    /** Keys that cannot change under a running daemon — see the class doc. */
+    private static final Set<String> COLD_KEYS =
              Set.of("bind", "herdrSocket", "memberHerdrSocket", "broker", "auth");
 
-    /**
-     * Keys read BOTH off the startup snapshot and live off {@link #get()} at different sites, so
-     * neither the hot, deferred nor cold class fits them as a whole — see the class doc's Split
-     * bullet (fleetd #330). A changed split key is accepted ({@link Outcome#applied()} stays
-     * {@code true}) and reported by name, with a message naming which half is live and which needs
-     * a restart.
-     */
-    static final Set<String> SPLIT_KEYS = Set.of("health", "coordinator", "fleet");
-
-    /**
-     * Top-level keys {@link #changedDeferredKeys} compares — see the class doc's Deferred bullet.
-     * Promoted here from a test-side copy in {@code ConfigRefTopLevelCoverageTest} by fleetd #337,
-     * the same reason {@link #COLD_KEYS} and {@link #SPLIT_KEYS} live here rather than in a test: a
-     * second, hand-maintained copy of this set is exactly the kind of thing that silently drifts
-     * from the method it is supposed to describe. {@code spawnReadyTimeoutMs} and
-     * {@code spawnReadyPollMs} are compared together in one branch and reported under the combined
-     * label {@code "spawnReady*"}; {@code profiles} is compared twice over (added/removed names,
-     * then an existing profile's launch settings) — see {@link #changedDeferredKeys}.
-     *
-     * <p>Package-private (not {@code private}) so {@code ConfigRefTopLevelCoverageTest} and
-     * {@code ConfigRefTopLevelReportingCoverageTest} can both read it, the same way they already
-     * read {@link #COLD_KEYS} and {@link #SPLIT_KEYS}.
-     */
-    static final Set<String> DEFERRED_KEYS = Set.of(
-            "guard", "worktreeRoot", "worktreeGroup", "memberSkills", "primary", "configReload",
-            "leadHeartbeat", "lifecycle", "spawnReadyTimeoutMs", "spawnReadyPollMs",
-            "quarantineCooldownSeconds", "profiles", "idleSleepGuard");
-
     private final Path path;
     private final AtomicReference<FleetConfig> current;
 
@@ -268,37 +102,25 @@ public final class ConfigRef implements Supplier<FleetConfig> {
     /**
      * What a reload attempt did.
      *
-     * <p>{@code split} is a separate field from {@code deferred} rather than a differently-worded
-     * entry inside it, because the two carry different guarantees for any caller that branches on
-     * them rather than just printing {@link #summary()}: every {@code deferred} entry means "this
-     * key's whole change waits for a restart", while every {@code split} entry means "part of this
-     * key's change already applied, and the message says which part" — collapsing them would force
-     * a caller to re-parse the message to tell those apart. See the class doc's Split bullet
-     * (fleetd #330) for why the key needs this at all.
-     *
      * @param applied  true when the new config is now live
      * @param coldKeys cold keys whose value changed, which is why an unapplied reload was refused
-     * @param deferred keys that changed and were accepted, but whose effect waits entirely on a
-     *                 restart
-     * @param split    split keys that changed and were accepted, each named with which half of it
-     *                 is already live and which half waits for a restart
+     * @param deferred keys that changed and were accepted, but whose effect waits for a restart
      * @param error    the parse or validation failure that refused the reload, else {@code null}
      */
     public record Outcome(boolean applied, List<String> coldKeys, List<String> deferred,
-                          List<String> split, String error) {
+                          String error) {
 
         public Outcome {
             coldKeys = List.copyOf(coldKeys);
             deferred = List.copyOf(deferred);
-            split = List.copyOf(split);
         }
 
         static Outcome refusedCold(List<String> keys) {
-            return new Outcome(false, keys, List.of(), List.of(), null);
+            return new Outcome(false, keys, List.of(), null);
         }
 
         static Outcome failed(String error) {
-            return new Outcome(false, List.of(), List.of(), List.of(), error);
+            return new Outcome(false, List.of(), List.of(), error);
         }
 
         /** A one-line summary for the operator — the reason, not just the verdict. */
@@ -310,18 +132,11 @@ public final class ConfigRef implements Supplier<FleetConfig> {
                 return "config reload refused — these keys cannot change under a running daemon: "
                         + String.join(", ", coldKeys) + ". Restart fleetd to apply them.";
             }
-            if (deferred.isEmpty() && split.isEmpty()) {
-                return "config reloaded";
-            }
-            StringBuilder out = new StringBuilder("config reloaded");
             if (!deferred.isEmpty()) {
-                out.append("; these changes need a restart to take effect: ")
-                        .append(String.join(", ", deferred));
+                return "config reloaded; these changes need a restart to take effect: "
+                        + String.join(", ", deferred);
             }
-            if (!split.isEmpty()) {
-                out.append("; partially live — ").append(String.join(" | ", split));
-            }
-            return out.toString();
+            return "config reloaded";
         }
     }
 
@@ -342,12 +157,12 @@ public final class ConfigRef implements Supplier<FleetConfig> {
             fresh = FleetConfig.load(path);
             // The same gate startup runs. A config that would have refused to boot must not be able
             // to slip in through a reload — that is how a daemon ends up in a state it could never
-            // have started in, which is the hardest kind to debug. fleetd ticket "central allow-list
-            // of usable models" follow-up: this used to be six individual validateXxx() calls, and
-            // mutation testing found two of the six unpinned here even though startup pinned nothing
-            // at all — see FleetConfig#validateAll's javadoc for why the fix is one reflective call,
-            // not a longer hand-maintained list.
-            fresh.validateAll();
+            // have started in, which is the hardest kind to debug.
+            fresh.validateAuthExposure();
+            fresh.validateLeadTabPrefixes();
+            fresh.validateSubscriptionProfiles();
+            fresh.validateCharters();
+            fresh.validateMembers();
         } catch (RuntimeException e) {
             String msg = e.getMessage() == null ? e.toString() : e.getMessage();
             log.warn("config reload from {} refused, keeping the running config: {}", path, msg);
@@ -362,21 +177,14 @@ public final class ConfigRef implements Supplier<FleetConfig> {
         }
 
         List<String> deferred = changedDeferredKeys(old, fresh);
-        List<String> split = changedSplitKeys(old, fresh);
         current.set(fresh);
-        Outcome out = new Outcome(true, List.of(), deferred, split, null);
+        Outcome out = new Outcome(true, List.of(), deferred, null);
         log.info(out.summary());
         return out;
     }
 
-    /**
-     * Cold keys whose value differs between the running config and the candidate.
-     *
-     * <p>Package-private (not {@code private}) so {@code ConfigRefTopLevelReportingCoverageTest}
-     * can call it directly with a reflection-built {@code FleetConfig} pair, the same reason
-     * {@link #sameLaunchSettings} is package-private — see that test's class doc (fleetd #333).
-     */
-    static List<String> changedColdKeys(FleetConfig old, FleetConfig fresh) {
+    /** Cold keys whose value differs between the running config and the candidate. */
+    private static List<String> changedColdKeys(FleetConfig old, FleetConfig fresh) {
         List<String> changed = new ArrayList<>();
         if (!Objects.equals(old.bind(), fresh.bind())) {
             changed.add("bind");
@@ -398,16 +206,8 @@ public final class ConfigRef implements Supplier<FleetConfig> {
         return changed;
     }
 
-    /**
-     * Changed keys that were accepted but whose effect waits for a restart.
-     *
-     * <p>Package-private (not {@code private}) so {@code ConfigRefTopLevelReportingCoverageTest}
-     * can call it directly with a reflection-built {@code FleetConfig} pair, the same reason
-     * {@link #changedColdKeys} and {@link #changedSplitKeys} already are (fleetd #333, extended to
-     * this method by fleetd #337 — membership in {@link #DEFERRED_KEYS} proved nothing about this
-     * method on its own until then; see that test's class doc).
-     */
-    static List<String> changedDeferredKeys(FleetConfig old, FleetConfig fresh) {
+    /** Changed keys that were accepted but whose effect waits for a restart. */
+    private static List<String> changedDeferredKeys(FleetConfig old, FleetConfig fresh) {
         List<String> changed = new ArrayList<>();
         if (!Objects.equals(old.lifecycle(), fresh.lifecycle())) {
             changed.add("lifecycle");
@@ -421,44 +221,6 @@ public final class ConfigRef implements Supplier<FleetConfig> {
         if (!Objects.equals(old.worktreeRoot(), fresh.worktreeRoot())) {
             changed.add("worktreeRoot");
         }
-        // Baked into the same GitWorktrees as worktreeRoot (Fleetd.java:251) and never rebuilt
-        // either — see the class doc. Missing this check was fleetd #323 instance 2: a reload
-        // that changed only worktreeGroup reported "config reloaded" with nothing deferred, and
-        // newly provisioned worktrees kept the old sharing behaviour.
-        if (!Objects.equals(old.worktreeGroup(), fresh.worktreeGroup())) {
-            changed.add("worktreeGroup");
-        }
-        // fleetd #362: baked into the same GitWorktrees as worktreeRoot/worktreeGroup
-        // (Fleetd.java:251) and never rebuilt either — a reload that changes only memberSkills
-        // must be reported the same way, or a newly provisioned worktree keeps seeding from (or
-        // skipping) the old source directory with nothing telling the operator why.
-        if (!Objects.equals(old.memberSkills(), fresh.memberSkills())) {
-            changed.add("memberSkills");
-        }
-        // fleetd #326: Fleetd.java:506, 519, 520 read cfg.primary() only off the startup snapshot
-        // (PrimaryRegistry's pinned terminal, ReplyPushLoop's reminder cap and backoff) — neither is
-        // rebuilt on reload, so a changed value needs a restart. Note what it does NOT mean:
-        // primary.terminal is deprecated (CB-532), identity comes from leaders:/leadScan:, so a lead
-        // using those is unaffected by this pin either way. See the class doc for the exact scope.
-        if (!Objects.equals(old.primary(), fresh.primary())) {
-            changed.add("primary");
-        }
-        // fleetd #326: Fleetd.java:679-680 read cfg.configReload() only at startup to decide whether
-        // to build a ConfigWatcher at all and with what interval — the watcher that would apply a
-        // later change is itself built once, so a running watcher keeps its original enabled flag and
-        // interval regardless of what a reload changes it to. Not cold: no already-open resource goes
-        // inconsistent with the new value, a watcher (if any) simply keeps polling on the old settings.
-        if (!Objects.equals(old.configReload(), fresh.configReload())) {
-            changed.add("configReload");
-        }
-        // Fleetd.java reads cfg.idleSleepGuard() once, at startup, to decide whether to construct
-        // an IdleSleepGuard at all and wire SessionManager's onAcquire/onRelease hooks to it —
-        // neither is rebuilt on reload, so a running daemon keeps whatever this was at startup
-        // (armed or not) regardless of a later edit here. Not cold: nothing already-open goes
-        // inconsistent with the new value, an armed-or-not guard just keeps its original answer.
-        if (!Objects.equals(old.idleSleepGuard(), fresh.idleSleepGuard())) {
-            changed.add("idleSleepGuard");
-        }
         if (!Objects.equals(old.spawnReadyTimeoutMs(), fresh.spawnReadyTimeoutMs())
                 || !Objects.equals(old.spawnReadyPollMs(), fresh.spawnReadyPollMs())) {
             changed.add("spawnReady*");
@@ -503,110 +265,14 @@ public final class ConfigRef implements Supplier<FleetConfig> {
     }
 
     /**
-     * Split keys whose value differs between the running config and the candidate — see the class
-     * doc's Split bullet (fleetd #330, extended for {@code fleet:} by fleetd #333). Unlike
-     * {@link #changedDeferredKeys}, this does not try to tell which sub-field moved for {@code
-     * health:} or {@code coordinator:}: any change to either gets the same fixed message, because
-     * the message already names both halves every time, so there is no "which half changed"
-     * question left for the caller to answer. {@code fleet:} is different on purpose — see below.
-     *
-     * <p>Package-private (not {@code private}) so {@code ConfigRefTopLevelReportingCoverageTest}
-     * can call it directly with a reflection-built {@code FleetConfig} pair, the same reason
-     * {@link #sameLaunchSettings} is package-private — see that test's class doc (fleetd #333). That
-     * test exists because membership in {@link #SPLIT_KEYS} proves nothing about this method on its
-     * own: fleetd #333 measured that dropping the {@code coordinator} branch out of this method
-     * while leaving {@code "coordinator"} in {@code SPLIT_KEYS} left the whole suite green except a
-     * hand-written {@code ConfigRefTest} case — neither {@code ConfigRefTopLevelCoverageTest} (it
-     * only reads the set) nor the "kept in step" assert below (it only checks the reported keys are
-     * a SUBSET of {@code SPLIT_KEYS}, never that every {@code SPLIT_KEYS} member has a branch here)
-     * would have caught it.
+     * Whether two versions of a profile would launch a peer identically. Compares every component
+     * the launcher reads at spawn; {@code weight}, {@code maxLoad} and {@code credentialId} are
+     * excluded because those are read live (by the placement policy and, for credentialId, by
+     * {@code CompositePeerLauncher}/the CB-578 stage B exhaustion sink) and really do take effect on
+     * the next spawn.
      */
-    static List<String> changedSplitKeys(FleetConfig old, FleetConfig fresh) {
-        List<String> changed = new ArrayList<>();
-        if (!Objects.equals(old.health(), fresh.health())) {
-            changed.add("health: the monitor itself (enabled, interval, workingSuspectAfter) is "
-                    + "frozen at startup and needs a restart; the coverage status fleet_profiles "
-                    + "reports is read live and already applied");
-        }
-        if (!Objects.equals(old.coordinator(), fresh.coordinator())) {
-            changed.add("coordinator: the LeadMailbox connection (uri, uriEnv, selfId, prefetch) is "
-                    + "opened once and needs a restart; the broker URI env-var name kept out of a "
-                    + "member's environment is read live on every spawn and already applied");
-        }
-        // fleetd #333: unlike health/coordinator above, most of `fleet:` (developers, reviewers,
-        // charters, tabLabel) is genuinely hot — ConfigRefTest.aHotChangeIsAppliedAndRead-
-        // ThroughGet and aCharterChangeIsHotAndReachesTheLiveConfig prove it reaches the live config
-        // with no restart note. `architects` is hot too, and — since fleetd #424 — hot for BOTH of
-        // its consumers, not just the one this comment used to name: CompositePeerLauncher reads it
-        // live for PLACEMENT through the () -> config.get().fleet() supplier named in the class doc's
-        // Hot bullet, and MemberRegistry separately reads it live for IDENTITY (which slot a spawn
-        // may bind to, AND what a slot already bound still grants) through its own instance of that
-        // same supplier shape — see MemberRegistry.live and its class doc for the binding rule:
-        // removing a slot revokes ARCHITECT on the bound pane's very next request, and only the slot
-        // OCCUPANCY survives, so the demoted session keeps its slot key until it unbinds. Only
-        // fleet.leaders is frozen (Fleetd.java:281 reads cfg.fleet().leaders() off the startup
-        // snapshot to build both the LeadTabScanner's tab-label-to-name map, wired into
-        // CallerResolver.withLeadsAndMembers at Fleetd.java:620/624, and — when herdr answered —
-        // LeadLauncher(...).ensureLeads() at Fleetd.java:315, which auto-launches each lead up to its
-        // `instances` count; neither is rebuilt on reload). So this compares fleet.leaders alone, not
-        // the whole Fleet record: comparing the whole record would report "split" for a tabLabel-only
-        // or architects-only change that is actually fully hot, which is the over-claim mirror of the
-        // under-claim bug this class exists to prevent.
-        if (!Objects.equals(leadersOf(old), leadersOf(fresh))) {
-            changed.add("fleet: fleet.leaders (each lead's tab, workspace, cwd, profile and "
-                    + "instances count) is read once at startup to build the LeadTabScanner's "
-                    + "identity map and to auto-launch leads, and neither is rebuilt on reload, so a "
-                    + "lead added, removed, or given a new tab: label needs a restart — until then it "
-                    + "stays unrecognised, and a caller from its new tab resolves as a worker, not a "
-                    + "lead; the rest of fleet: (developers, reviewers, charters, tabLabel) is read "
-                    + "live through the supplier on CompositePeerLauncher, and architects is read "
-                    + "live through that same supplier for placement AND through a separate supplier "
-                    + "on MemberRegistry for spawn-time identity — both already applied");
-        }
-        // Kept in step with SPLIT_KEYS the same way changedColdKeys is kept in step with COLD_KEYS —
-        // every message here must be traceable to one of the split keys the class doc documents.
-        // NOTE what this does NOT prove, per the javadoc above: it does not catch a SPLIT_KEYS
-        // member with no branch above at all, only a branch whose message is mis-worded relative to
-        // the set. ConfigRefTopLevelReportingCoverageTest is what proves the former.
-        assert changed.stream().allMatch(m -> SPLIT_KEYS.stream().anyMatch(k -> m.startsWith(k + ":")))
-                : "a split entry was reported that does not start with a SPLIT_KEYS name: " + changed;
-        return changed;
-    }
-
-    /** {@code cfg.fleet().leaders()}, defensively, in case a caller hands in a non-defaulted config. */
-    private static Map<String, FleetConfig.Leader> leadersOf(FleetConfig cfg) {
-        return cfg.fleet() == null ? Map.of() : cfg.fleet().leaders();
-    }
-
-    /**
-     * {@link FleetConfig.Profile} record components deliberately left out of
-     * {@link #sameLaunchSettings} because they are read <em>live</em>, not baked in at spawn — see
-     * the class doc's <em>Hot</em> bullet. {@code weight} and {@code maxLoad} are read live by the
-     * placement policy on every spawn; {@code credentialId} is read live by
-     * {@code CompositePeerLauncher} and the CB-578 stage B exhaustion sink. Nothing else is
-     * excluded — see {@code sameLaunchSettingsComparesEveryProfileComponentOrExcludesIt} in
-     * {@code ConfigRefProfileCoverageTest}, which enumerates every {@code Profile} record component
-     * by reflection and fails the build if one is neither compared below nor named here.
-     */
-    static final Set<String> LAUNCH_SETTINGS_EXCLUDED = Set.of("weight", "maxLoad", "credentialId");
-
-    /**
-     * Whether two versions of a profile would launch a peer identically.
-     *
-     * <p>This must compare every {@link FleetConfig.Profile} record component except the three in
-     * {@link #LAUNCH_SETTINGS_EXCLUDED}. That is not a claim this javadoc can make good on by
-     * itself — a javadoc saying "compares every component" is exactly what fleetd #323 found to be
-     * false for three fields (and a sibling method's field list, for a fourth). The actual
-     * guarantee comes from {@code ConfigRefProfileCoverageTest}: it enumerates every record
-     * component of {@code FleetConfig.Profile} by reflection, mutates each one not in
-     * {@code LAUNCH_SETTINGS_EXCLUDED} on a base profile, and asserts this method reports a
-     * difference — so a new component that is neither compared here nor added to
-     * {@code LAUNCH_SETTINGS_EXCLUDED} (with a reason) fails that test by name, rather than
-     * silently reporting "config reloaded" for a value the daemon never picked up.
-     */
-    static boolean sameLaunchSettings(FleetConfig.Profile a, FleetConfig.Profile b) {
-        return Objects.equals(a.profile(), b.profile())
-                && Objects.equals(a.baseUrl(), b.baseUrl())
+    private static boolean sameLaunchSettings(FleetConfig.Profile a, FleetConfig.Profile b) {
+        return Objects.equals(a.baseUrl(), b.baseUrl())
                 && Objects.equals(a.model(), b.model())
                 && Objects.equals(a.configDir(), b.configDir())
                 && Objects.equals(a.tokenEnv(), b.tokenEnv())
@@ -632,16 +298,6 @@ public final class ConfigRef implements Supplier<FleetConfig> {
                 // fleetd #201 Unit 5: errorPattern is compiled once into Fleetd.main's backend-error
                 // pattern map at startup (see BackendErrorPatternLookup wiring), the same way
                 // exhaustedPattern is — a reload never re-reads it either.
-                && Objects.equals(a.errorPattern(), b.errorPattern())
-                // fleetd #323 instance 1: ideProjectDir and ideOpenCommand are read at spawn off the
-                // same frozen profile map as ideMcpUrl above (ClaudeCodeLauncher.java:267/269,
-                // OpenCodeLauncher.java:474/480/486) and were missing from this comparison.
-                && Objects.equals(a.ideProjectDir(), b.ideProjectDir())
-                && Objects.equals(a.ideOpenCommand(), b.ideOpenCommand())
-                // fleetd #323 instance 1: autoCompactWindow is read at spawn the same way
-                // (ClaudeCodeLauncher.java:926, OpenCodeLauncher.java:650). Comparing it here only
-                // makes the reload REPORT that a restart is needed — it deliberately does not make
-                // autoCompactWindow take effect live, which is a separate, larger change.
-                && Objects.equals(a.autoCompactWindow(), b.autoCompactWindow());
+                && Objects.equals(a.errorPattern(), b.errorPattern());
     }
 }

fleetd/src/main/java/dev/ltms/fleet/config/FleetConfig.java

@@ -16,15 +16,11 @@ import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -110,33 +106,6 @@ import java.util.regex.PatternSyntaxException;
  *                      When {@code memberHerdrSocket} is NOT configured this field is never
  *                      consulted at all; fleetd keeps reading its own {@code $SHELL}, exactly as
  *                      before this field existed.
- * @param memberSkills  fleetd #362: nullable directory of skill folders (each a subdirectory
- *                      holding a {@code SKILL.md}, the same shape as this repo's own {@code
- *                      .claude/skills/}) copied into every provisioned worktree's {@code
- *                      .claude/skills/}, so a member spawned against ANY repo — not only one that
- *                      already ships its own copy — can load a bridge skill such as {@code
- *                      implementer}. {@code null}/blank ⇒ off: no worktree is touched beyond
- *                      today's behaviour. A skill folder the target repo already carries is never
- *                      overwritten — see {@link dev.ltms.fleet.session.GitWorktrees}. Claude Code
- *                      members only; an opencode member's equivalent lives under a different path
- *                      ({@code .opencode/agent}) and is not covered by this key. Every non-hidden
- *                      subdirectory of this directory is copied wholesale, with no per-file
- *                      allowlist — do not park scratch files or drafts alongside the real skill
- *                      folders, they will be copied into every provisioned worktree too.
- * @param idleSleepGuard opt-in-by-default: hold an OS-level assertion against idle sleep while at
- *                      least one member is live, so an unattended host does not sleep out from
- *                      under a member's long turn. {@code null} (the block omitted) behaves the
- *                      same as an explicit {@code enabled: true}; set {@code enabled: false} to
- *                      turn it off. See {@link dev.ltms.fleet.power.IdleSleepGuard}.
- * @param models        central allow-list of models any {@code profiles:} entry may name. {@code
- *                      null} or an empty {@code allow:} ⇒ off: {@link #validateModels()} checks
- *                      nothing and every existing config keeps working exactly as it does today.
- *                      When non-empty, a profile whose {@code model:} is not one of {@link
- *                      Models#ids()} fails config load, naming both the model and the profile —
- *                      see {@link #validateModels()}. This block decides what may be CONFIGURED;
- *                      fleetd #422 added the separate on/off question — whether a configured model
- *                      may be spawned onto RIGHT NOW ({@link Models.ModelEntry#enabled}) — enforced
- *                      live at spawn by {@code CompositePeerLauncher}, not here. See {@link Models}.
  */
 @JsonIgnoreProperties(ignoreUnknown = true)
 public record FleetConfig(
@@ -161,52 +130,7 @@ public record FleetConfig(
         MemberCredentials memberCredentials,
         Coordinator coordinator,
         String worktreeGroup,
-        String memberLoginShell,
-        String memberSkills,
-        IdleSleepGuard idleSleepGuard,
-        Models models) {
-
-    /** Back-compat form before the {@code models:} block was added. */
-    public FleetConfig(Bind bind, String herdrSocket, String memberHerdrSocket, Map<String, Profile> profiles,
-                         Guard guard, String worktreeRoot, Lifecycle lifecycle, Integer spawnReadyTimeoutMs,
-                         Integer spawnReadyPollMs, Broker broker, Primary primary, Fleet fleet,
-                         LeadHeartbeat leadHeartbeat, Health health, String placement, Auth auth,
-                         ConfigReload configReload, Integer quarantineCooldownSeconds,
-                         MemberCredentials memberCredentials, Coordinator coordinator, String worktreeGroup,
-                         String memberLoginShell, String memberSkills, IdleSleepGuard idleSleepGuard) {
-        this(bind, herdrSocket, memberHerdrSocket, profiles, guard, worktreeRoot, lifecycle, spawnReadyTimeoutMs,
-                spawnReadyPollMs, broker, primary, fleet, leadHeartbeat, health, placement, auth,
-                configReload, quarantineCooldownSeconds, memberCredentials, coordinator, worktreeGroup,
-                memberLoginShell, memberSkills, idleSleepGuard, null);
-    }
-
-    /** Back-compat form before the {@code idleSleepGuard:} block was added. */
-    public FleetConfig(Bind bind, String herdrSocket, String memberHerdrSocket, Map<String, Profile> profiles,
-                         Guard guard, String worktreeRoot, Lifecycle lifecycle, Integer spawnReadyTimeoutMs,
-                         Integer spawnReadyPollMs, Broker broker, Primary primary, Fleet fleet,
-                         LeadHeartbeat leadHeartbeat, Health health, String placement, Auth auth,
-                         ConfigReload configReload, Integer quarantineCooldownSeconds,
-                         MemberCredentials memberCredentials, Coordinator coordinator, String worktreeGroup,
-                         String memberLoginShell, String memberSkills) {
-        this(bind, herdrSocket, memberHerdrSocket, profiles, guard, worktreeRoot, lifecycle, spawnReadyTimeoutMs,
-                spawnReadyPollMs, broker, primary, fleet, leadHeartbeat, health, placement, auth,
-                configReload, quarantineCooldownSeconds, memberCredentials, coordinator, worktreeGroup,
-                memberLoginShell, memberSkills, null);
-    }
-
-    /** Back-compat form before the {@code memberSkills} key was added. */
-    public FleetConfig(Bind bind, String herdrSocket, String memberHerdrSocket, Map<String, Profile> profiles,
-                         Guard guard, String worktreeRoot, Lifecycle lifecycle, Integer spawnReadyTimeoutMs,
-                         Integer spawnReadyPollMs, Broker broker, Primary primary, Fleet fleet,
-                         LeadHeartbeat leadHeartbeat, Health health, String placement, Auth auth,
-                         ConfigReload configReload, Integer quarantineCooldownSeconds,
-                         MemberCredentials memberCredentials, Coordinator coordinator, String worktreeGroup,
-                         String memberLoginShell) {
-        this(bind, herdrSocket, memberHerdrSocket, profiles, guard, worktreeRoot, lifecycle, spawnReadyTimeoutMs,
-                spawnReadyPollMs, broker, primary, fleet, leadHeartbeat, health, placement, auth,
-                configReload, quarantineCooldownSeconds, memberCredentials, coordinator, worktreeGroup,
-                memberLoginShell, null, null);
-    }
+        String memberLoginShell) {
 
     /** Back-compat form before the {@code memberLoginShell} key was added. */
     public FleetConfig(Bind bind, String herdrSocket, String memberHerdrSocket, Map<String, Profile> profiles,
@@ -217,7 +141,7 @@ public record FleetConfig(
                          MemberCredentials memberCredentials, Coordinator coordinator, String worktreeGroup) {
         this(bind, herdrSocket, memberHerdrSocket, profiles, guard, worktreeRoot, lifecycle, spawnReadyTimeoutMs,
                 spawnReadyPollMs, broker, primary, fleet, leadHeartbeat, health, placement, auth,
-                configReload, quarantineCooldownSeconds, memberCredentials, coordinator, worktreeGroup, null, null);
+                configReload, quarantineCooldownSeconds, memberCredentials, coordinator, worktreeGroup, null);
     }
 
     /** Back-compat form before the {@code worktreeGroup} key was added. */
@@ -398,9 +322,8 @@ public record FleetConfig(
      *                       statement that does not stop being true just because the profile was
      *                       named directly. A negative value has no sane meaning (there is no
      *                       "excluded" to degrade to below zero) and is refused at config load
-     *                       instead, naming the profile and the key. Live means a session that can
-     *                       receive another delivery. The roster keeps terminal {@code BACKEND_ERROR}
-     *                       and {@code FAILED} sessions for diagnostics, but they do not use capacity.
+     *                       instead, naming the profile and the key. Live means any session the
+     *                       registry still owns (acquired and not yet released), in any state.
      * @param kind           which peer launcher spawns this profile: {@code "claude-code"} (default —
      *                       the {@link dev.ltms.fleet.member.ClaudeCodeLauncher}) or {@code "opencode"}.
      *                       The {@code CompositePeerLauncher} routes {@code spawn}/reap by this value, so
@@ -964,18 +887,12 @@ public record FleetConfig(
      *                 {@code null} ⇒ kept as {@code null} (no self id configured).
      * @param prefetch the consumer's {@code basicQos} prefetch count. {@code null}/non-positive ⇒
      *                 {@link LeadMailbox#DEFAULT_PREFETCH}.
-     * @param peers    fleetd #361: the coord-ids the operator declares as this daemon's peers — the
-     *                 daemon never guesses who else exists. {@code fleet_list} reports each one's
-     *                 live reachability. Blank entries are dropped; {@code null} ⇒ an empty list, so
-     *                 a config written before this field existed still parses unchanged.
      */
     @JsonIgnoreProperties(ignoreUnknown = true)
-    public record Coordinator(String uri, String uriEnv, String selfId, Integer prefetch, List<String> peers) {
+    public record Coordinator(String uri, String uriEnv, String selfId, Integer prefetch) {
 
         public Coordinator {
             selfId = (selfId == null || selfId.isBlank()) ? null : selfId;
-            peers = peers == null ? List.of()
-                    : peers.stream().filter(p -> p != null && !p.isBlank()).toList();
         }
 
         /** True when a {@code uriEnv} is configured by name, whether or not its variable resolves. */
@@ -1327,145 +1244,6 @@ public record FleetConfig(
         }
     }
 
-    /**
-     * Hold an OS-level assertion against idle sleep while at least one member is live (see
-     * {@link dev.ltms.fleet.power.IdleSleepGuard}).
-     *
-     * <p>Unlike most opt-in blocks in this file, this one defaults to <em>on</em>: an unattended
-     * host idle-sleeping mid-turn is a correctness problem (a dropped AMQP link, a frozen member),
-     * not a convenience, so the safer default is armed. An operator who wants the previous
-     * behaviour (no assertion held, ever) sets {@code enabled: false} explicitly.
-     *
-     * @param enabled {@code false} turns the guard off; {@code null} (the block omitted
-     *                entirely) or {@code true} leaves it on
-     */
-    @JsonIgnoreProperties(ignoreUnknown = true)
-    public record IdleSleepGuard(Boolean enabled) {
-        public boolean isEnabled() {
-            return !Boolean.FALSE.equals(enabled);
-        }
-    }
-
-    /**
-     * Central allow-list of models any {@code profiles:} entry may name (fleetd ticket: "a central
-     * allow-list of usable models"). Nothing before this block checked a profile's {@code model:}
-     * against anything — it was a free-form string handed straight to the backend adapter, and a
-     * withdrawn or misspelled name failed silently (opencode falls back to a default model rather
-     * than erroring on an unknown {@code -m}) rather than at config load, where a mistake is cheap.
-     *
-     * <p><b>Absent or empty {@code allow:} is "off"</b>, on purpose: this is a large deployment
-     * with gitignored {@code fleetd.yaml} on more than one host, and a change that forced every
-     * operator to enumerate their models before the daemon would start would break every one of
-     * them on upgrade. See {@link FleetConfig#validateModels()}, which is where the allow-list is
-     * actually enforced, at config load.
-     *
-     * <p><b>The list is the authority; a {@code profiles:} entry is checked against it, never the
-     * other way around.</b> Adding or editing a {@code profiles:} entry cannot, by itself, widen
-     * the set of permitted models — only editing {@code models.allow:} itself can. This is the
-     * invariant the ticket asked for: the two blocks are validated in one direction only.
-     *
-     * <p><b>Spawn-time enforcement (fleetd #422, units 2+3) lives outside this record</b> —
-     * {@code CompositePeerLauncher.enforceModelEnabled} and its candidate-set filter read this
-     * block LIVE (through the same kind of supplier {@code weight}/{@code maxLoad} already use),
-     * so the on/off state below is hot: no restart needed. This block itself still only decides
-     * what may be CONFIGURED (membership in {@link #allow}); {@link ModelEntry#enabled} decides
-     * whether a member of that list is currently spawnable. The two questions are deliberately
-     * separate — see {@link ModelEntry}'s javadoc for why turning a model off must never mean
-     * removing it from {@link #allow}.
-     *
-     * @param allow the permitted models, each its own {@link ModelEntry} rather than a bare
-     *              string — see that record's javadoc for why. {@code null}/empty ⇒ the block is
-     *              treated as absent: {@link FleetConfig#validateModels()} checks nothing.
-     */
-    @JsonIgnoreProperties(ignoreUnknown = true)
-    public record Models(List<ModelEntry> allow) {
-
-        public Models {
-            allow = (allow == null) ? List.of() : List.copyOf(allow);
-        }
-
-        /**
-         * One permitted model, named as a record rather than a bare string on purpose: this ticket
-         * (fleetd #422) is the "later unit" the original comment here predicted — it hangs an on/off
-         * state ({@link #enabled}) off each entry, and a bare {@code List<String>} could not have
-         * grown that field without changing the YAML shape underneath every operator who already
-         * wrote one. {@link #model()} is intentionally a single flat, opaque-string namespace — a
-         * bare Claude id ({@code claude-sonnet-5}) and an opencode provider-prefixed id
-         * ({@code openai/gpt-5.6-terra}) both fit it unchanged, because {@link
-         * FleetConfig#validateModels()} only ever compares a profile's {@code model:} value against
-         * this string for exact equality; it never parses a provider prefix or branches on a
-         * profile's {@code kind:}.
-         *
-         * @param model   the model id exactly as a {@code profiles:} entry's {@code model:} field
-         *                would name it
-         * @param enabled {@code false} turns spawning onto this model off; {@code null} (the field
-         *                omitted — every config written before fleetd #422 is this shape) or
-         *                {@code true} leaves it on. Turning a model off must NEVER remove it from
-         *                {@link Models#allow} — {@link FleetConfig#validateModels()} checks
-         *                <em>membership</em> only, never the on/off state, so an off entry stays a
-         *                valid thing for a {@code profiles:} entry to name; only
-         *                {@code CompositePeerLauncher}'s spawn-time gate reads {@link #enabled}.
-         *                Collapsing the two — turning a model off by deleting its {@code allow:}
-         *                entry — would make {@link FleetConfig#validateModels()} refuse the whole
-         *                config reload the moment a still-configured profile names it, which is
-         *                exactly the restart-to-flip-a-switch problem this field exists to avoid.
-         *                <p>A model id can be named by more than one {@code profiles:} entry (e.g.
-         *                {@code deepseek-v4-flash} backs both {@code local} and {@code
-         *                local-direct} in the live config) — turning it off disables every profile
-         *                that names it, on purpose: the model is what a subscription's rate limit
-         *                actually constrains, not any one profile alias for it.
-         */
-        @JsonIgnoreProperties(ignoreUnknown = true)
-        public record ModelEntry(String model, Boolean enabled) {
-            public ModelEntry {
-                model = (model == null || model.isBlank()) ? null : model.trim();
-            }
-
-            /**
-             * Back-compat form before {@link #enabled} was added (fleetd #422) — the model is
-             * unconditionally on, exactly as every {@code ModelEntry} behaved before this field
-             * existed. Keeps pre-#422 call sites (and any YAML that omits {@code enabled:})
-             * compiling and behaving identically.
-             */
-            public ModelEntry(String model) {
-                this(model, null);
-            }
-
-            /** {@code true} unless {@link #enabled} is explicitly {@code false} — absent means on. */
-            public boolean isEnabled() {
-                return !Boolean.FALSE.equals(enabled);
-            }
-        }
-
-        /** {@link #allow}'s model ids, as a set for membership checks. Blank/null entries are dropped. */
-        public Set<String> ids() {
-            Set<String> ids = new java.util.LinkedHashSet<>();
-            for (ModelEntry e : allow) {
-                if (e != null && e.model() != null) {
-                    ids.add(e.model());
-                }
-            }
-            return Collections.unmodifiableSet(ids);
-        }
-
-        /**
-         * Model ids currently turned off (fleetd #422: {@link ModelEntry#isEnabled()} {@code
-         * false}). Read live by {@code CompositePeerLauncher}'s spawn gate and by {@code
-         * fleet_profiles}/{@code GET /profiles} — both must read this same accessor off the same
-         * live config so the two surfaces cannot disagree about which model is off (the fleetd
-         * #404 lesson: a status field must read the source the behaviour reads).
-         */
-        public Set<String> offIds() {
-            Set<String> off = new java.util.LinkedHashSet<>();
-            for (ModelEntry e : allow) {
-                if (e != null && e.model() != null && !e.isEnabled()) {
-                    off.add(e.model());
-                }
-            }
-            return Collections.unmodifiableSet(off);
-        }
-    }
-
     /**
      * The terminal → lead-name map seeded from the legacy singular {@code primary:} pin (CB-530).
      *
@@ -1716,8 +1494,7 @@ public record FleetConfig(
             "bind", "herdrSocket", "memberHerdrSocket", "profiles", "guard", "worktreeRoot",
             "lifecycle", "spawnReadyTimeoutMs", "spawnReadyPollMs", "broker", "primary", "fleet",
             "leadHeartbeat", "health", "placement", "auth", "configReload", "quarantineCooldownSeconds",
-            "memberCredentials", "coordinator", "worktreeGroup", "memberLoginShell", "memberSkills",
-            "idleSleepGuard", "models");
+            "memberCredentials", "coordinator", "worktreeGroup", "memberLoginShell");
 
     /** Load and validate config from {@code path}. */
     public static FleetConfig load(Path path) {
@@ -2394,23 +2171,9 @@ public record FleetConfig(
         // memberLoginShell is left as-is (fleetd #213), like worktreeGroup: null/blank is "not
         // configured", and there is no sane non-null default — a member's login shell is
         // operator-specific and only meaningful when memberHerdrSocket is also set.
-        // memberSkills is left as-is (fleetd #362), like worktreeGroup/memberLoginShell: null/blank
-        // is "off", and there is no sane non-null default — the daemon may not even run from a
-        // checkout that ships its own .claude/skills/.
-        // idleSleepGuard is left as-is, like leadHeartbeat/configReload above, but for the opposite
-        // reason: it is on by default already (its own isEnabled() treats null the same as
-        // enabled: true — see its javadoc), so defaulting the block here would change nothing a
-        // reader observes and would only obscure that "block omitted" and "block present and
-        // enabled" are deliberately the same outcome.
-        // models is left as-is, like broker/primary/coordinator above: null/empty is "off", and an
-        // absent block must validate nothing (see Models's javadoc) — defaulting it here to an
-        // empty Models would be a no-op for validateModels() either way, since an empty allow-list
-        // already means "check nothing", so there is nothing to gain and one more null check to
-        // avoid by leaving it exactly as configured.
         return new FleetConfig(b, herdrSocket, memberHerdrSocket, profiles, g, worktreeRoot, l, timeout, pollMs,
                 broker, primary, f, leadHeartbeat, health, placementOrDefault, a, configReload,
-                quarantineCooldown, mc, coordinator, worktreeGroup, memberLoginShell, memberSkills,
-                idleSleepGuard, models);
+                quarantineCooldown, mc, coordinator, worktreeGroup, memberLoginShell);
     }
 
     /**
@@ -2630,118 +2393,6 @@ public record FleetConfig(
         }
     }
 
-    /**
-     * Reject a {@code profiles:} entry whose {@code model:} is not on the configured {@link
-     * #models} allow-list.
-     *
-     * <p>Absent or empty {@code models.allow:} validates nothing — see {@link Models}'s javadoc:
-     * an existing config with no such block must keep working exactly as it does today. Once the
-     * operator declares at least one entry, every profile's {@code model:} (when set — a profile
-     * may legitimately leave it {@code null}, e.g. a {@code subscription: true} profile relying on
-     * the account's own default) must equal one of {@link Models#ids()} exactly. The comparison is
-     * a flat string match: a bare Claude id and an opencode {@code provider/model} id are both
-     * just opaque strings here, so nothing here needs to know which {@code kind:} a profile runs.
-     *
-     * <p>The check runs one direction only, by construction: it reads {@link #profiles} and
-     * {@link #models}, and only ever adds to {@code bad} when a profile's model is missing from
-     * the allow-list. Nothing here can be satisfied by widening a {@code profiles:} entry — only
-     * editing {@code models.allow:} itself changes what passes. That is the invariant the ticket
-     * asked for: the list is the authority, profiles are checked against it.
-     *
-     * @throws IllegalStateException when any profile names a model outside the configured
-     *                               allow-list, naming both the model and the profile that wanted it
-     */
-    public void validateModels() {
-        if (models == null || models.allow().isEmpty()) {
-            return;
-        }
-        Set<String> allowed = models.ids();
-        List<String> bad = new ArrayList<>();
-        profiles.forEach((name, p) -> {
-            String model = p.model();
-            if (model != null && !model.isBlank() && !allowed.contains(model)) {
-                bad.add("profile '" + name + "' names model '" + model + "', which is not in "
-                        + "models.allow: (have: " + allowed + ").");
-            }
-        });
-        if (!bad.isEmpty()) {
-            throw new IllegalStateException("refusing to start: " + String.join(" ", bad));
-        }
-    }
-
-    /**
-     * Runs every validator this class declares — found by reflection, not by name.
-     *
-     * <p>fleetd ticket "central allow-list of usable models", follow-up: mutation testing found
-     * that although each of the six validators above was well pinned on its own, nothing proved
-     * either real caller ({@code Fleetd.main} and {@link ConfigRef#reload()}) still
-     * invoked it — deleting a call site left the full suite green. The fix is not a seventh test
-     * per caller; a hand-maintained list of six names here would have the exact same defect its
-     * own javadoc would warn against: the seventh validator someone adds next month has no reason
-     * to be added to it. So this method does not name any validator. It sweeps {@link
-     * #getClass()}'s own public, no-argument, {@code void} methods whose name starts with {@code
-     * "validate"} (excluding itself) and invokes every one it finds, via {@link
-     * #invokeAllValidators}. A new {@code validateXxx()} method is therefore wired into both
-     * callers the moment it is written — there is no second step to forget, and so no state in
-     * which it silently never runs.
-     *
-     * <p>{@code Fleetd.main} and {@link ConfigRef#reload()} each call this one method instead of
-     * the six individually — see the comments at those two call sites for why
-     * each must run it.
-     *
-     * <p>Methods run in a fixed (alphabetical) order, so a config with more than one violation
-     * always names the same one first, on every run.
-     *
-     * @throws IllegalStateException (or whatever unchecked exception a validator itself throws),
-     *                                propagated unchanged from the first validator, in that order,
-     *                                that finds a problem
-     */
-    public void validateAll() {
-        invokeAllValidators(this);
-    }
-
-    /**
-     * The reflective sweep behind {@link #validateAll()}, kept as its own method — taking any
-     * {@code target}, not just {@code this} — so a test can prove the MECHANISM is generic (it
-     * would sweep a seventh {@code validateXxx()} method added to any class, not just something
-     * special-cased to today's six on {@link FleetConfig}) without needing to add a real, unwanted
-     * seventh validator to this class just to exercise that claim. See {@code
-     * FleetConfigValidateAllTest} for that proof.
-     *
-     * @param target an object whose public, no-argument, {@code void} methods named {@code
-     *               validateXxx} (any name starting with {@code "validate"}, excluding {@code
-     *               validateAll} itself) should all run, in alphabetical-by-name order
-     */
-    static void invokeAllValidators(Object target) {
-        List<Method> methods = new ArrayList<>();
-        for (Method m : target.getClass().getMethods()) {
-            if (Modifier.isPublic(m.getModifiers())
-                    && m.getParameterCount() == 0
-                    && m.getReturnType() == void.class
-                    && m.getName().startsWith("validate")
-                    && !m.getName().equals("validateAll")) {
-                methods.add(m);
-            }
-        }
-        methods.sort(Comparator.comparing(Method::getName));
-        for (Method m : methods) {
-            try {
-                m.invoke(target);
-            } catch (InvocationTargetException e) {
-                Throwable cause = e.getCause();
-                if (cause instanceof RuntimeException re) {
-                    throw re;
-                }
-                if (cause instanceof Error err) {
-                    throw err;
-                }
-                throw new IllegalStateException("validator " + m.getName() + " failed", cause);
-            } catch (IllegalAccessException e) {
-                throw new IllegalStateException("cannot invoke validator " + m.getName(), e);
-            }
-        }
-    }
-
     /** True for the loopback addresses and the unspecified-but-local forms we treat as same-host. */
     private static boolean isLoopbackBind(String host) {
         if (host == null || host.isBlank()) {

fleetd/src/main/java/dev/ltms/fleet/health/FleetHealthMonitor.java

@@ -14,7 +14,6 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.function.BiConsumer;
@@ -29,65 +28,17 @@ public final class FleetHealthMonitor {
     static final int MAX_FAIL_TARGET_ATTEMPTS = 3;
     // CB-641: Match the injector's 60s readiness gate so health allows a full first boot.
     static final long READINESS_GRACE_NANOS = TimeUnit.SECONDS.toNanos(60);
-    /**
-     * fleetd #280: how long after a terminal transition to wait before the one bounded re-check
-     * fires. Must exceed the worst-case reverse-rendezvous {@code fleet_ask} window (55-115s, see
-     * {@code FleetMcp.ASK_DEFAULT_TIMEOUT_MS} / {@code FleetApp.MAX_ASK_TIMEOUT_MS}) so that, if the
-     * target was genuinely {@code ASKING} when {@code state} was first observed, its own ask has had
-     * time to lapse (clearing {@code Task#question} back to {@code null}) before this fires.
-     */
-    static final long ASK_LAPSE_RECHECK_DELAY_SECONDS = 120;
-
-    /**
-     * fleetd #386: {@code System.nanoTime()} (or whatever {@link #clock} is) does not advance while
-     * macOS sleeps, so a raw {@code nowNanos - lastActivityAtNanos} comparison freezes with the
-     * host and can never cross {@link #workingSuspectAfterNanos}. This is a second, wall-clock
-     * source used ONLY inside the stall check ({@link #stallElapsedNanos}) to detect and correct
-     * for that freeze. Nothing else in this class reads it — every other decision (readiness grace,
-     * the fault classification itself) stays exactly on {@link #clock}, as the ticket requires.
-     */
-    private static final LongSupplier DEFAULT_REALTIME_CLOCK =
-            () -> TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
 
     private final AgentControl agents;
     private final Supplier<List<MemberSession>> roster;
     private final MessageService messages;
     private final ScheduledExecutorService scheduler;
     private final LongSupplier clock;
-    private final LongSupplier realtimeClock;
     private final long intervalSeconds;
-    private final long tickIntervalNanos;
     private final long workingSuspectAfterNanos;
     private final BiConsumer<String, String> failTarget;
     private final Map<String, HealthPrior> priors = new HashMap<>();
-    /**
-     * fleetd #386 clock-drift bookkeeping. {@code haveClockBaseline}/{@code lastTickMonoNanos}/
-     * {@code lastTickRealNanos} track the previous tick's pair of readings so each new tick can
-     * measure how far the two clocks moved apart since then. {@code accumulatedDriftNanos} is the
-     * running total of every such divergence observed since this monitor started (never decreases —
-     * the monotonic clock can only lag real time, never lead it). {@code busyDriftBaselineNanos}/
-     * {@code busyBaselineActivityNanos} record, per target, the value of {@code accumulatedDriftNanos}
-     * at the moment this monitor first saw that target's CURRENT {@code lastActivityAtNanos} while
-     * BUSY — so {@link #stallElapsedNanos} adds back only the drift observed DURING this BUSY span,
-     * never drift from a sleep that happened before the member went busy. All five fields are touched
-     * only from {@code tick()}, like {@link #priors}.
-     */
-    private boolean haveClockBaseline = false;
-    private long lastTickMonoNanos;
-    private long lastTickRealNanos;
-    private long accumulatedDriftNanos = 0;
-    private final Map<String, Long> busyDriftBaselineNanos = new HashMap<>();
-    private final Map<String, Long> busyBaselineActivityNanos = new HashMap<>();
-    /**
-     * The live classification per member, and the only one of this class's three maps that more
-     * than one scheduler task touches. {@code tick} writes it (and prunes it to the roster);
-     * fleetd #280's delayed {@link #recheckTerminalTarget} reads it from its own separate scheduled
-     * task. Both run on the single-threaded scheduler {@code Fleetd} passes in today, so they are
-     * serialised — but nothing in this class enforces that, and an unsynchronised {@link HashMap}
-     * read racing a resize can spin a CPU forever rather than fail visibly. {@code priors} and
-     * {@code orphanStreaks} stay plain maps because {@code tick} is still their only toucher.
-     */
-    private final Map<String, HealthState> states = new ConcurrentHashMap<>();
+    private final Map<String, HealthState> states = new HashMap<>();
     /**
      * CB-643: consecutive ticks on which a target looked like an orphaned delegation. The fact
      * {@link MessageService#hasOrphanedDelegation} reports is a true snapshot, but it can read true
@@ -119,29 +70,12 @@ public final class FleetHealthMonitor {
     public FleetHealthMonitor(AgentControl agents, Supplier<List<MemberSession>> roster, MessageService messages,
                               ScheduledExecutorService scheduler, LongSupplier clock, long intervalSeconds,
                               long workingSuspectAfterSeconds, BiConsumer<String, String> failTarget) {
-        this(agents, roster, messages, scheduler, clock, DEFAULT_REALTIME_CLOCK, intervalSeconds,
-                workingSuspectAfterSeconds, failTarget);
-    }
-
-    /**
-     * @param realtimeClock fleetd #386: a wall-clock nanosecond source (e.g.
-     *                       {@code System.currentTimeMillis()} converted to nanos) that keeps
-     *                       advancing while {@code clock} is frozen by a host sleep. Used only to
-     *                       correct the stall check — see the class-level javadoc on the
-     *                       clock-drift fields.
-     */
-    public FleetHealthMonitor(AgentControl agents, Supplier<List<MemberSession>> roster, MessageService messages,
-                              ScheduledExecutorService scheduler, LongSupplier clock, LongSupplier realtimeClock,
-                              long intervalSeconds, long workingSuspectAfterSeconds,
-                              BiConsumer<String, String> failTarget) {
         this.agents = agents;
         this.roster = roster;
         this.messages = messages;
         this.scheduler = scheduler;
         this.clock = clock;
-        this.realtimeClock = Objects.requireNonNull(realtimeClock, "realtimeClock");
         this.intervalSeconds = intervalSeconds;
-        this.tickIntervalNanos = TimeUnit.SECONDS.toNanos(intervalSeconds);
         this.workingSuspectAfterNanos = TimeUnit.SECONDS.toNanos(workingSuspectAfterSeconds);
         this.failTarget = Objects.requireNonNull(failTarget, "failTarget");
     }
@@ -171,7 +105,6 @@ public final class FleetHealthMonitor {
             for (Agent agent : agentsNow) live.put(agent.terminalId(), agent);
             HashSet<String> current = new HashSet<>();
             long nowNanos = clock.getAsLong();
-            long driftBeforeThisTick = observeClockDrift(nowNanos);
             for (MemberSession session : rosterNow) {
                 current.add(session.terminalId());
                 Agent agent = live.get(session.terminalId());
@@ -182,7 +115,7 @@ public final class FleetHealthMonitor {
                         && session.state() != MemberSession.State.SPAWNING;
                 boolean readinessGraceElapsed = nowNanos - session.spawnedAtNanos() >= READINESS_GRACE_NANOS;
                 boolean stalled = session.state() == MemberSession.State.BUSY
-                        && stallElapsedNanos(session, nowNanos, driftBeforeThisTick) >= workingSuspectAfterNanos;
+                        && nowNanos - session.lastActivityAtNanos() >= workingSuspectAfterNanos;
                 // CB-643: the three message-layer facts CB-640 published. Read them here rather than
                 // leaving them false — that constant is what made 8 of the 9 fault states dead.
                 boolean queuedDelivery = messages.hasQueuedDelivery(session.terminalId());
@@ -200,8 +133,6 @@ public final class FleetHealthMonitor {
             priors.keySet().retainAll(current);
             states.keySet().retainAll(current);
             orphanStreaks.keySet().retainAll(current);
-            busyDriftBaselineNanos.keySet().retainAll(current);
-            busyBaselineActivityNanos.keySet().retainAll(current);
         } catch (Throwable error) {
             // Any unclassified collection failure must never kill the monitor's only scheduler task.
             log.warn("fleet health collection failed; will retry next tick", error);
@@ -226,65 +157,6 @@ public final class FleetHealthMonitor {
         return streak >= ORPHAN_CONFIRM_TICKS;
     }
 
-    /**
-     * fleetd #386: compare this tick's monotonic and real-time readings against the previous
-     * tick's, and fold any positive divergence into {@link #accumulatedDriftNanos} (a ratchet — it
-     * never decreases, since the monotonic clock can only fall behind real time, never ahead of
-     * it). Logs once, at WARN, when that single tick's divergence exceeds one full tick interval —
-     * the signature of a host that slept between the two ticks (a tick literally cannot run while
-     * the process itself is suspended, so the whole sleep duration lands inside one tick's gap).
-     *
-     * @return {@link #accumulatedDriftNanos} as it stood BEFORE this tick's divergence was folded
-     *         in — the baseline {@link #stallElapsedNanos} needs when a target is observed BUSY
-     *         for the first time this tick, so a sleep that happened before this member went busy
-     *         is not attributed to it.
-     */
-    private long observeClockDrift(long nowNanos) {
-        long nowRealNanos = realtimeClock.getAsLong();
-        long driftBeforeThisTick = accumulatedDriftNanos;
-        if (haveClockBaseline) {
-            long monoDelta = nowNanos - lastTickMonoNanos;
-            long realDelta = nowRealNanos - lastTickRealNanos;
-            long tickDrift = realDelta - monoDelta;
-            if (tickDrift > tickIntervalNanos) {
-                log.warn("fleet health: the monotonic clock did not advance for about {}s that the "
-                        + "real clock did since the last tick (host likely slept); the stall "
-                        + "detector could not see that time", TimeUnit.NANOSECONDS.toSeconds(tickDrift));
-            }
-            if (tickDrift > 0) {
-                accumulatedDriftNanos = driftBeforeThisTick + tickDrift;
-            }
-        }
-        lastTickMonoNanos = nowNanos;
-        lastTickRealNanos = nowRealNanos;
-        haveClockBaseline = true;
-        return driftBeforeThisTick;
-    }
-
-    /**
-     * fleetd #386: {@code nowNanos - lastActivityAtNanos} alone freezes across a host sleep, since
-     * both come from the monotonic {@link #clock}. This adds back the real-time drift observed
-     * since this BUSY span started — not the monitor's whole lifetime, so a sleep that happened
-     * before this member went busy never leaks into its stall reading (see the class-level javadoc
-     * on the drift fields). The baseline resets whenever {@code lastActivityAtNanos} changes (a new
-     * turn) or the member is not currently BUSY.
-     */
-    private long stallElapsedNanos(MemberSession session, long nowNanos, long driftBeforeThisTick) {
-        String target = session.terminalId();
-        if (session.state() != MemberSession.State.BUSY) {
-            busyDriftBaselineNanos.remove(target);
-            busyBaselineActivityNanos.remove(target);
-            return nowNanos - session.lastActivityAtNanos();
-        }
-        Long baselineActivity = busyBaselineActivityNanos.get(target);
-        if (baselineActivity == null || baselineActivity != session.lastActivityAtNanos()) {
-            busyBaselineActivityNanos.put(target, session.lastActivityAtNanos());
-            busyDriftBaselineNanos.put(target, driftBeforeThisTick);
-        }
-        long driftSinceBusyStart = accumulatedDriftNanos - busyDriftBaselineNanos.get(target);
-        return (nowNanos - session.lastActivityAtNanos()) + driftSinceBusyStart;
-    }
-
     void reportTransition(String target, HealthState next) {
         HealthState previous = states.put(target, next);
         if (previous == next) return;
@@ -299,7 +171,6 @@ public final class FleetHealthMonitor {
         // member stayed terminal.
         if (terminal(next)) {
             failTerminalTarget(target, next);
-            scheduleTerminalRecheck(target, next);
         }
     }
 
@@ -320,48 +191,6 @@ public final class FleetHealthMonitor {
                 target, state, MAX_FAIL_TARGET_ATTEMPTS, last);
     }
 
-    /**
-     * fleetd #280: schedule the one bounded, delayed follow-up for a terminal transition — never a
-     * per-tick retry (CB-580 rejected that shape; {@link #reportTransition} still fires
-     * {@link #failTerminalTarget} exactly once per transition, unconditionally on the tick loop).
-     * This is a single one-shot task, scheduled once per transition into GONE/NEVER_READY, so a
-     * member stuck terminal for the rest of its life gets exactly one extra attempt, not one per
-     * tick. See {@link #recheckTerminalTarget} for why the extra attempt is safe.
-     */
-    private void scheduleTerminalRecheck(String target, HealthState state) {
-        if (scheduler.isShutdown()) return;
-        try {
-            scheduler.schedule(() -> recheckTerminalTarget(target, state),
-                    ASK_LAPSE_RECHECK_DELAY_SECONDS, TimeUnit.SECONDS);
-        } catch (RuntimeException e) {
-            log.warn("fleet health: could not schedule terminal re-check for member={} state={}",
-                    target, state, e);
-        }
-    }
-
-    /**
-     * fleetd #280: the delayed re-check {@link #scheduleTerminalRecheck} scheduled for one terminal
-     * transition. By now, a {@code fleet_ask} that was still open when {@code state} was first
-     * observed has had time to lapse on its own (see {@link #ASK_LAPSE_RECHECK_DELAY_SECONDS}),
-     * clearing {@code Task#question} back to {@code null} — which is exactly what
-     * {@link MessageService#abandon(String, String, boolean)}'s {@code sweepAsking=false} filter
-     * needs to finally match it. Calling {@link #failTerminalTarget} again is safe only because
-     * {@code sweepAsking} stays {@code false}: a task genuinely still {@code ASKING} is skipped
-     * exactly as it was on the very first attempt — this never fails a ticket whose ask has not yet
-     * lapsed.
-     *
-     * <p><strong>Guarded on "target is still classified {@code state}."</strong> Without this guard,
-     * a member that recovered (or was released and dropped from the roster) between the transition
-     * and this re-check would still take a blind {@code failTarget} call — reaching into whatever
-     * brand-new, unrelated turn it has since picked up and failing it too. {@link #states} already
-     * carries the live classification (updated every tick, pruned to the current roster on release),
-     * so a stale or recovered target simply reads as a mismatch here and this is a no-op.
-     */
-    void recheckTerminalTarget(String target, HealthState state) {
-        if (states.get(target) != state) return;
-        failTerminalTarget(target, state);
-    }
-
     private static boolean terminal(HealthState state) {
         return state == HealthState.GONE || state == HealthState.NEVER_READY;
     }

fleetd/src/main/java/dev/ltms/fleet/herdr/HerdrClient.java

@@ -3,7 +3,7 @@ package dev.ltms.fleet.herdr;
 import com.fasterxml.jackson.databind.JsonNode;
 
 /**
- * Client face onto the herdr daemon (protocol 19, herdr 0.8.0).
+ * Client face onto the herdr daemon (protocol 14, herdr 0.7.0).
  *
  * <p>This is the ONLY thing in {@code fleetd} that speaks to herdr. Every method
  * maps to a herdr JSON-RPC call over its Unix domain socket. Requests are

fleetd/src/main/java/dev/ltms/fleet/herdr/HerdrCodec.java

@@ -8,7 +8,7 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
 import java.nio.charset.StandardCharsets;
 
 /**
- * Wire codec for herdr's newline-delimited JSON-RPC (protocol 19).
+ * Wire codec for herdr's newline-delimited JSON-RPC (protocol 14).
  *
  * <p>Split out from the socket so the framing rules — the ones that actually bit us
  * during the spike (id MUST be a string; response carries {@code result} or

fleetd/src/main/java/dev/ltms/fleet/herdr/LeadTabScanner.java

@@ -5,7 +5,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
@@ -54,40 +53,17 @@ import java.util.function.Supplier;
  * daemon and found again by this scan. The trust direction above is unaffected — fleetd writing a
  * name for a lead it just started is not a pane promoting itself — but <em>staleness</em> becomes
  * real: a label left behind by a session that has since died would read as a live lead forever.
+ * This scanner does not solve that (its job is naming, and a stale name costs nothing here); the
+ * launcher does, by requiring a running agent in the tab before it counts the lead as live. If you
+ * ever make a decision that <em>removes</em> something based on this map, add the same check.
  * The remaining hazard is an <em>operator</em> one — a worker {@code tabLabel} template that
  * happens to start with the same prefix would promote the whole fleet — and that is refused at
  * startup by {@code FleetConfig.validateLeadTabPrefixes} rather than documented here.
  *
- * <p><strong>fleetd #359 — the staleness check this class used to skip.</strong> This used to say
- * "a stale name costs nothing here" and leave liveness to {@code LeadLauncher}, on the theory that
- * naming and removing are different decisions. That was wrong: {@code dev.ltms.fleet.msg.LeadCoordLoop}
- * makes exactly the kind of removal decision the old javadoc warned about, by reading this map to
- * pick which pane a peer message goes into — and a stale entry there is not free. On a host where
- * {@code fleetd} had restarted more than once, a labelled-but-dead tab from a previous life was
- * reported right alongside the live one; {@code LeadCoordLoop.resolveLocalLead()} saw more than one
- * candidate and refused to guess (safe), but the fix the daemon's own WARN suggests — name a lead
- * after {@code coordinator.selfId} — stops being safe once two tabs can share a label: step 1 of
- * that resolution picks whichever matching entry it finds first, which can be the dead one, and
- * typing a peer's message into a dead shell does not fail — it is silently gone instead of merely
- * held. {@link #scan()} now cross-checks every labelled tab against {@code agent.list} (the same
- * signal {@code LeadLauncher.countLeads} already trusts for the same purpose) and drops any tab
- * with no agent running in it, so a dead tab is never in the map for a caller to pick at all.
- *
  * <p><strong>Caching.</strong> {@link #get()} is on the request path (every resolve), so the scan
- * is TTL-cached and a stale-but-valid map is preferred to a herdr round-trip. A failed scan (herdr
- * throws) keeps the previous answer instead of emptying it — a herdr hiccup must not silently
- * demote a live lead mid-session.
- *
- * <p><strong>fleetd #359 review, finding 2 — a successful-but-wrong scan is the same hazard.</strong>
- * The catch above only fires when a call throws. It does nothing for a call that returns 200 with an
- * incomplete answer — exactly what the ticket's own evidence showed {@code agent.list} can do. Once
- * this class started trusting that signal, an empty read would otherwise get cached as fact and
- * silently drop a lead {@code CallerResolver} had, until then, correctly resolved — turning it into a
- * {@code Role.WORKER}, which refuses every orchestration call. So a terminal this class already
- * reported as live is not dropped the first time {@code agent.list} loses it: {@link #scan()} grants
- * it one grace scan (see {@code gracedTerminals}) and only drops it if a <em>later</em> scan still
- * finds no agent. A terminal never reported live before gets no grace — that would weaken the
- * original #359 fix itself, which this class's own test suite already pins.
+ * is TTL-cached and a stale-but-valid map is preferred to a herdr round-trip. A failed scan keeps
+ * the previous answer instead of emptying it — a herdr hiccup must not silently demote a live lead
+ * mid-session.
  */
 public final class LeadTabScanner implements Supplier<Map<String, String>> {
 
@@ -103,15 +79,6 @@ public final class LeadTabScanner implements Supplier<Map<String, String>> {
     private long scannedAtNanos;
     private boolean everScanned;
 
-    /**
-     * Terminals currently on their one grace scan: {@code cached} reported them live, the most
-     * recent {@link #scan()} found no agent for them, and they were re-included anyway. Cleared for
-     * a terminal the instant it is seen live again; a terminal still here on the <em>next</em> scan
-     * is finally dropped. Scoped separately from {@link #cached} so a graced terminal cannot renew
-     * its own grace forever just by staying in the exposed map (fleetd #359 review, finding 2).
-     */
-    private Set<String> gracedTerminals = Set.of();
-
     /**
      * @param herdr                   the herdr client to query ({@code workspace.list},
      *                                {@code tab.list}, {@code pane.list} — all read-only)
@@ -174,7 +141,7 @@ public final class LeadTabScanner implements Supplier<Map<String, String>> {
         return cached;
     }
 
-    /** One full pass: labelled tabs → live agents in them → those panes' terminals. */
+    /** One full pass: labelled tabs → their panes → those panes' terminals. */
     private Map<String, String> scan() {
         Map<String, String> nameByTab = new LinkedHashMap<>();
         for (JsonNode w : herdr.call("workspace.list").path("workspaces")) {
@@ -191,47 +158,17 @@ public final class LeadTabScanner implements Supplier<Map<String, String>> {
             }
         }
 
-        if (nameByTab.isEmpty()) {
-            gracedTerminals = Set.of();
-            return Map.of();
-        }
-
-        // fleetd #359: a labelled tab is only a lead when herdr also reports a running agent in
-        // it — the same liveness signal LeadLauncher.countLeads trusts for the identical purpose.
-        // Without this, a tab left behind by a session that has since died reads as live forever.
-        Set<String> tabsWithAgent = new HashSet<>();
-        for (JsonNode a : herdr.call("agent.list").path("agents")) {
-            String tabId = a.path("tab_id").asText(null);
-            if (tabId != null) {
-                tabsWithAgent.add(tabId);
-            }
-        }
-
         Map<String, String> byTerminal = new LinkedHashMap<>();
-        Set<String> stillGraced = new HashSet<>();
-        // One pane.list for every tab: panes carry tab_id, so the join is local.
-        for (JsonNode p : herdr.call("pane.list", Map.of()).path("panes")) {
-            String tabId = p.path("tab_id").asText(null);
-            String name = nameByTab.get(tabId);
-            String terminal = p.path("terminal_id").asText(null);
-            if (name == null || terminal == null || terminal.isBlank()) {
-                continue;
-            }
-            if (tabsWithAgent.contains(tabId)) {
-                byTerminal.put(terminal, name);
-                continue;
-            }
-            // No agent reported for this tab, but its tab/pane are still here — this is the
-            // ambiguous case review finding 2 named: a successful agent.list that came back short
-            // does not prove the lead is dead. Grant one grace scan to a terminal we had already
-            // reported as live; a terminal we never reported live gets none, so the original #359
-            // fix (a genuinely dead tab is never reported) is unaffected for the common case.
-            if (cached.containsKey(terminal) && !gracedTerminals.contains(terminal)) {
-                byTerminal.put(terminal, name);
-                stillGraced.add(terminal);
+        if (!nameByTab.isEmpty()) {
+            // One pane.list for every tab: panes carry tab_id, so the join is local.
+            for (JsonNode p : herdr.call("pane.list", Map.of()).path("panes")) {
+                String name = nameByTab.get(p.path("tab_id").asText(null));
+                String terminal = p.path("terminal_id").asText(null);
+                if (name != null && terminal != null && !terminal.isBlank()) {
+                    byTerminal.put(terminal, name);
+                }
             }
         }
-        gracedTerminals = stillGraced;
         return Collections.unmodifiableMap(byTerminal);
     }
 
@@ -240,14 +177,12 @@ public final class LeadTabScanner implements Supplier<Map<String, String>> {
      *
      * <p>Exact match (case-insensitive, ends stripped) against {@link #tabToName} — no prefix
      * stripping, so an operator's {@code "lead: something-else"} tab is never mistaken for a
-     * configured lead just because it shares a prefix. The match strips a trailing
-     * {@link PendingCloseMarker} first, so a tab {@code LeadLauncher} has flagged as maybe-dead but
-     * not yet closed keeps resolving normally while that reconcile is pending.
+     * configured lead just because it shares a prefix.
      */
     private String leadNameOf(String label) {
         if (label == null) {
             return null;
         }
-        return tabToName.get(PendingCloseMarker.strip(label).toLowerCase(Locale.ROOT));
+        return tabToName.get(label.strip().toLowerCase(Locale.ROOT));
     }
 }

fleetd/src/main/java/dev/ltms/fleet/herdr/PendingCloseMarker.java

@@ -1,42 +0,0 @@
-package dev.ltms.fleet.herdr;
-
-/**
- * The suffix {@code dev.ltms.fleet.lead.LeadLauncher} appends to a lead tab's label the first time a
- * reconcile finds no running agent in it, before it is sure enough to close the tab outright.
- *
- * <p><strong>fleetd #359 review, finding 1.</strong> The daemon's own evidence showed
- * {@code agent.list} can read "no agent" for a tab that genuinely has one running — so a single such
- * reading must never be treated as proof a tab is dead. {@code LeadLauncher} now writes this marker
- * on the first miss, and only closes the tab if a <em>later</em>, independent reconcile still finds
- * it dead while the marker is still there. Two consecutive misses, one restart apart, is a much
- * stronger claim than one.
- *
- * <p>{@link LeadTabScanner} strips the same suffix before matching a label against a configured
- * lead's {@code tab}, so a flagged-but-actually-still-live tab keeps resolving normally — the marker
- * changes nothing about which pane {@code LeadCoordLoop} can reach while the flag is pending. Both
- * classes must use exactly this suffix, which is why it lives here rather than as a private constant
- * on either.
- */
-public final class PendingCloseMarker {
-
-    public static final String SUFFIX = " [fleetd:pending-close]";
-
-    private PendingCloseMarker() {
-    }
-
-    /** The label with any trailing pending-close marker removed, for name matching. */
-    public static String strip(String label) {
-        if (label == null) {
-            return null;
-        }
-        String stripped = label.strip();
-        return stripped.endsWith(SUFFIX)
-                ? stripped.substring(0, stripped.length() - SUFFIX.length()).strip()
-                : stripped;
-    }
-
-    /** Whether a label currently carries the marker. */
-    public static boolean isFlagged(String label) {
-        return label != null && label.strip().endsWith(SUFFIX);
-    }
-}

fleetd/src/main/java/dev/ltms/fleet/inject/BackendErrorSink.java

@@ -1,12 +1,10 @@
 package dev.ltms.fleet.inject;
 
 /**
- * Notified when {@link CompletionResolver} has a backend-error match at the start of a pane line,
- * or both a match and its too-fast crash signature, for a waiting send (fleetd#201 / #227). A text
- * match inside ordinary pane prose can be a member's report about an error, so it fails the send
- * without notifying this sink.
- * {@link CompletionResolver} calls this only after {@code Rendezvous.resolveFailure} returns
- * {@code true} for that exact waiter, mirroring the win-only race rule {@link ExhaustionSink} uses.
+ * Notified when {@link CompletionResolver} actually delivers a typed backend-error classification
+ * to a waiting send (fleetd#201 / #227) — never on a race that lost. {@link CompletionResolver}
+ * calls this only after {@code Rendezvous.resolveFailure} returns {@code true} for that exact
+ * waiter, mirroring the win-only race rule {@link ExhaustionSink} already uses.
  *
  * <p>The public send result is unchanged by this classification — it is still a failed send
  * ({@code Rendezvous.Kind#FAILED}); this sink is the internal seam a later stage (fleetd#201 Unit

fleetd/src/main/java/dev/ltms/fleet/inject/CompletionResolver.java

@@ -380,19 +380,16 @@ public final class CompletionResolver implements TurnListener {
                         + "matched the profile's exhausted pattern): {}", target, reason);
                 // CB-578 stage B: only on the resolution that actually won the race — a late
                 // duplicate must never quarantine a credential twice for one refusal.
-                if (startsWithExhaustion(matchedLine, exhausted)) {
-                    exhaustionSink.onExhausted(target, reason);
-                }
+                exhaustionSink.onExhausted(target, reason);
             }
             return;
         }
         // fleetd#164 (part 2) / fleetd#201: a scrape that read cleanly and produced content still
         // isn't a real reply when that content is the backend's own rejection (e.g. an HTTP 400
         // before the worker did any work). Classify it as a failure naming the member, rather than
-        // handing the caller a scrape that reads like a completed answer. A text match alone is not
-        // enough to notify the typed backend-error sink: this assistant block can be a member's
-        // normal prose about an error. A line that starts with the error match is stronger evidence;
-        // the too-fast path below also has its crash signature before it records a credential failure.
+        // handing the caller a scrape that reads like a completed answer, and — only on the
+        // resolution that actually wins the race, mirroring the exhaustion sink above — notify the
+        // typed backend-error sink so a later stage can act on repeated failures.
         String backendError = firstMatchingLine(assistantBlock, backendErrorPatternOrFallback(target));
         if (backendError != null) {
             // Carry the whole scrape, not just the matched line. The pattern is a heuristic: a member
@@ -404,9 +401,9 @@ public final class CompletionResolver implements TurnListener {
             if (rendezvous.resolveFailure(waiter, reason)) {
                 inFlight.remove(target, turn);
                 log.warn("failing send to {} via turn-stall fallback: {}", target, reason);
-                if (startsWithBackendError(backendError, backendErrorPatternOrFallback(target))) {
-                    backendErrorSink.onBackendError(target, backendError, reason);
-                }
+                // fleetd#201 Unit 1: only on the resolution that actually won the race — a late
+                // duplicate must never double-count one backend failure.
+                backendErrorSink.onBackendError(target, backendError, reason);
             }
             return;
         }
@@ -480,9 +477,7 @@ public final class CompletionResolver implements TurnListener {
                         + "usable assistant block; no fleet_reply): {}", target, reason);
                 // CB-578 stage B: only on the resolution that actually won the race — a late
                 // duplicate must never quarantine a credential twice for one refusal.
-                if (startsWithExhaustion(matchedLine, exhausted)) {
-                    exhaustionSink.onExhausted(target, reason);
-                }
+                exhaustionSink.onExhausted(target, reason);
             }
             return true;
         }
@@ -497,9 +492,8 @@ public final class CompletionResolver implements TurnListener {
             if (rendezvous.resolveFailure(waiter, reason)) {
                 inFlight.remove(target, turn);
                 log.warn("failing send to {} via turn-stall fallback from the raw scrape: {}", target, reason);
-                if (startsWithBackendError(backendError, backendErrorPatternOrFallback(target))) {
-                    backendErrorSink.onBackendError(target, backendError, reason);
-                }
+                // fleetd#201 Unit 1: only on the resolution that actually won the race.
+                backendErrorSink.onBackendError(target, backendError, reason);
             }
             return true;
         }
@@ -546,21 +540,10 @@ public final class CompletionResolver implements TurnListener {
      * {@link #MIN_TURN_NANOS} — a crash signature (e.g. a backend HTTP 400 before the worker did
      * anything) that a bare {@code BUSY -> DONE} transition cannot be told apart from a genuinely
      * fast completion. Runs the same backend-error classification the normal and raw-scrape paths
-     * apply, against whatever is on screen right now: a match together with the too-fast crash
-     * signature notifies {@link #backendErrorSink} (only on the resolution that wins the race). A
-     * non-match stays the generic too-fast failure, naming the member and both timings, with
-     * whatever the pane shows appended so the caller sees the evidence, not just "it failed".
-     *
-     * <p>fleetd#376: <strong>this path must never resolve a completion.</strong> A fast backend can
-     * genuinely answer inside the floor, so the failure is sometimes wrong — but it is wrong in the
-     * loud direction, and the fix for that is honest wording, not a guess at the pane's meaning.
-     * Reclassifying from the scrape was tried and rejected: there is no reliable positive marker for
-     * "this is a real reply" across backends. {@link #lastAssistantBlock} falls back to the entire
-     * pane when it finds no {@code ⏺} marker, so on a crash the candidate "reply" is the whole
-     * screen; and {@code ⏺} itself is a Claude Code marker that an opencode pane never carries — the
-     * very backend whose speed raised this ticket. Any weaker test (non-blank, or "contains sentence
-     * punctuation") passes on almost every crash, because a pane holding a file path, a version
-     * number or a hostname contains a full stop. That trades a loud wrong answer for a silent one.
+     * apply, against whatever is on screen right now: a match is a typed failure that notifies
+     * {@link #backendErrorSink} (only on the resolution that wins the race); a non-match stays the
+     * original generic too-fast failure, naming the member and both timings, with whatever the pane
+     * shows appended so the caller sees the cause, not just "it failed".
      */
     private void failTooFast(String target, InFlight turn, CompletableFuture<Rendezvous.Resolution> waiter,
                               long elapsedNanos) {
@@ -571,13 +554,13 @@ public final class CompletionResolver implements TurnListener {
             scrape = "";
         }
         String clippedScrape = clip(scrape);
-        String timing = String.format(
-                "member %s went BUSY -> DONE in %dms (floor %dms)",
+        String baseReason = String.format(
+                "member %s went BUSY -> DONE in %dms (floor %dms) — too fast to be real work, most "
+                        + "likely a backend error before any work started",
                 target, elapsedNanos / 1_000_000, MIN_TURN_NANOS / 1_000_000);
         String backendError = firstMatchingLine(scrape, backendErrorPatternOrFallback(target));
         if (backendError != null) {
-            String reason = timing + " — too fast to be real work, and the pane carries a backend "
-                    + "error: " + clippedScrape;
+            String reason = baseReason + ": " + clippedScrape;
             if (rendezvous.resolveFailure(waiter, reason)) {
                 inFlight.remove(target, turn);
                 log.warn("failing send to {} via turn-stall fallback: {}", target, reason);
@@ -586,14 +569,7 @@ public final class CompletionResolver implements TurnListener {
             }
             return;
         }
-        // fleetd#376: no pattern matched, so the cause is genuinely unknown. Say that, rather than
-        // asserting a backend error the way this message used to — a fast backend really can finish
-        // inside the floor, and a reader who trusts a wrong cause stops looking at the pane.
-        String reason = timing + " — inside the floor. That is usually a backend error before any "
-                + "work started, but a fast backend can answer inside it too, and nothing here can "
-                + "tell those apart, so the turn is reported failed rather than guessed. Read the "
-                + "pane below before deciding which it was";
-        fail(target, turn, clippedScrape.isBlank() ? reason : reason + ": " + clippedScrape);
+        fail(target, turn, clippedScrape.isBlank() ? baseReason : baseReason + ": " + clippedScrape);
     }
 
     /**
@@ -636,119 +612,17 @@ public final class CompletionResolver implements TurnListener {
     }
 
     /**
-     * True when nothing before the match on this pane line ends a sentence — that is, the match is
-     * still inside the line's first sentence rather than inside prose a member wrote about it.
-     * Used to decide whether an exhaustion match may quarantine a credential (fleetd #348).
-     *
-     * <p><strong>Why this is looser than {@link #startsWithBackendError}.</strong> An
-     * {@code exhaustedPattern} is written per profile and may name only the decisive words of a
-     * provider message — {@code "usage limit has been reached"} without its leading {@code "The"}.
-     * A start-of-line check would then reject the genuine refusal. That is the false negative
-     * fleetd #348's invariant 1 calls the worse direction: an unrecorded exhaustion leaves the
-     * fleet spawning into a credential with no capacity, and a quarantine runs 1800s against the
-     * backend-error cooldown's fixed 60s.
-     *
-     * <p>This rule accepts a superset of what a start-of-line check accepts: if the match begins
-     * right after the chrome, there is nothing in front of it, so there is no sentence ending
-     * either. So moving to it cannot add a false negative.
-     *
-     * <p><strong>No chrome skipping here, deliberately.</strong> The first version of this method
-     * copied {@code startsWithBackendError}'s leading-chrome loop. Measured on merge: deleting that
-     * loop left all 1369 tests green, and it must — the scan only looks for {@code . ! ?}, and no
-     * terminal chrome character is one of those. A step that cannot change the result is worse than
-     * no step, because the next reader takes it as evidence that chrome was handled.
-     *
-     * <p>It stays a heuristic. Prose whose <em>first</em> sentence carries the pattern still
-     * notifies the sink, and a genuine refusal behind an earlier full stop (a hostname, a version
-     * number) still does not. Both are known and neither is fixed here.
-     */
-    private static boolean startsWithExhaustion(String line, Pattern pattern) {
-        var matcher = pattern.matcher(line);
-        if (!matcher.find()) {
-            return false;
-        }
-        for (int prefix = 0; prefix < matcher.start(); prefix++) {
-            if (".!?".indexOf(line.charAt(prefix)) >= 0) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * True when the error pattern begins the matched pane line, rather than appearing in prose.
-     *
-     * <p>Leading terminal chrome is skipped first — box-drawing characters, bullets, gutter bars and
-     * spaces. #339 introduced this check with a bare {@code lookingAt}, and that rejected a genuine
-     * error line rendered as {@code "| 503 Service Unavailable: ..."}: the send still failed, but the
-     * credential outage was never recorded. That is the false negative #339's own invariant 3 called
-     * worse than the false positive it set out to fix — measured with a throwaway probe on the
-     * raw-scrape path, which is exactly the path whose comment says to expect leading chrome.
-     *
-     * <p>Skipping only a leading run of non-letter, non-digit characters keeps the fix's intent. A
-     * member's prose ({@code "I checked the retry path. An API Error: makes it back off."}) still
-     * does not match, because there the pattern sits after words, not after chrome.
-     */
-    private static boolean startsWithBackendError(String line, Pattern pattern) {
-        int i = 0;
-        while (i < line.length() && !Character.isLetterOrDigit(line.charAt(i))) {
-            i++;
-        }
-        return pattern.matcher(line.substring(i)).lookingAt();
-    }
-
-    /**
-     * What an unset pattern key means for the classification it configures (fleetd#415).
-     * {@code coverage()} cannot infer this from the key's name — the two keys it currently
-     * describes disagree on it, and a string comparison on the name would just move the same bug
-     * to a new spot — so every caller must state it explicitly.
-     *
-     * <p><strong>This alone does not prove a caller passes the right one for its key.</strong> A
-     * test that calls {@code coverage()} directly and supplies the meaning itself only proves this
-     * enum is worded correctly, never that {@code Fleetd}'s two call sites pair each key with its
-     * true meaning — that pairing is #415's actual defect. Measured on review: swapping the two
-     * {@code UnsetMeaning} arguments at those call sites (giving {@code exhaustedPattern} the
-     * built-in-default wording and {@code errorPattern} the off wording — #415's exact defect with
-     * the keys exchanged) compiled with 0 errors and left all 1506 existing tests green. See
-     * {@code dev.ltms.fleet.Fleetd#exhaustedPatternCoverageLine}/{@code #errorPatternCoverageLine}
-     * and {@code FleetdPatternCoverageLineTest}, which exists specifically to catch that swap.
-     */
-    public enum UnsetMeaning {
-        /** No fallback exists: a profile with no configured pattern truly has this classification off. */
-        OFF,
-        /** A built-in pattern applies when unset: the classification still runs for that profile. */
-        BUILT_IN_DEFAULT
-    }
-
-    /**
-     * Coverage summary for a fleetd#201/CB-578-style pattern-key classification, logged at startup
+     * Coverage summary for the CB-578 stage A exhausted-pattern classification, logged at startup
      * the way {@link dev.ltms.fleet.health.FleetHealthMonitor#coverage} is — so an operator can
      * see whether the classification is on, and for which profiles, without reading every
      * profile's config by hand.
      *
-     * <p>fleetd#415: this method measures <em>pattern coverage</em> — how many profiles set the
-     * key — which is not the same thing as <em>feature state</em> for a key with a fallback. For
-     * {@code errorPattern}, an empty {@code configuredProfiles} still runs the classification
-     * against {@code CompletionResolver}'s built-in compatibility pattern ({@link #BACKEND_ERROR}
-     * at line ~84); for {@code exhaustedPattern} there is no fallback, so empty really does mean
-     * off. {@code unsetMeaning} is the single, required source of that fact — see
-     * {@link dev.ltms.fleet.config.FleetConfig#rejectMalformedProfilePatterns} lines ~2029-2032 for
-     * where it is documented for config authors. It is a required parameter, not a defaulted
-     * overload: a third pattern key added later must supply one to compile at all, rather than
-     * silently inheriting whichever wording this method happened to default to.
-     *
      * @param allProfiles        every configured profile name
-     * @param configuredProfiles the subset of {@code allProfiles} that carry the pattern
+     * @param configuredProfiles the subset of {@code allProfiles} that carry an exhausted pattern
      */
-    public static String coverage(String patternKey, UnsetMeaning unsetMeaning, Set<String> allProfiles,
-                                   Set<String> configuredProfiles) {
+    public static String coverage(String patternKey, Set<String> allProfiles, Set<String> configuredProfiles) {
         if (configuredProfiles.isEmpty()) {
-            return switch (unsetMeaning) {
-                case OFF -> "off (no profile has an " + patternKey + " configured; profiles: "
-                        + sorted(allProfiles) + ")";
-                case BUILT_IN_DEFAULT -> "built-in default for all profiles (no profile customises "
-                        + patternKey + "; profiles: " + sorted(allProfiles) + ")";
-            };
+            return "off (no profile has an " + patternKey + " configured; profiles: " + sorted(allProfiles) + ")";
         }
         Set<String> unconfigured = new TreeSet<>(allProfiles);
         unconfigured.removeAll(configuredProfiles);

fleetd/src/main/java/dev/ltms/fleet/inject/Injector.java

@@ -145,58 +145,8 @@ public final class Injector {
         return router != null ? router.agentsFor(target) : agents;
     }
 
-    /** The result of trying to remove an undelivered message from the injector. */
-    public enum Cancellation {
-        CANCELLED,
-        DELIVERED,
-        NOT_DELIVERED
-    }
-
-    /**
-     * An identity handle for one queued delivery. It is the only value accepted by
-     * {@link #cancel(Delivery)}, so a caller cannot cancel a different message with the same target
-     * or text.
-     */
-    public static final class Delivery {
-        private final Pending pending;
-
-        private Delivery(Pending pending) {
-            this.pending = pending;
-        }
-
-        public CompletableFuture<Void> completion() {
-            return pending.delivered;
-        }
-    }
-
     /** A pending message and the future that completes when it has been delivered. */
-    private static final class Pending {
-        enum State { QUEUED, DELIVERED, NOT_DELIVERED, CANCELLED }
-
-        final String target;
-        final String text;
-        final TurnToken token;
-        final CompletableFuture<Void> delivered;
-        volatile State state = State.QUEUED; // written under the owning Target monitor
-
-        Pending(String target, String text, TurnToken token, CompletableFuture<Void> delivered) {
-            this.target = target;
-            this.text = text;
-            this.token = token;
-            this.delivered = delivered;
-        }
-
-        String text() {
-            return text;
-        }
-
-        TurnToken token() {
-            return token;
-        }
-
-        CompletableFuture<Void> delivered() {
-            return delivered;
-        }
+    private record Pending(String text, TurnToken token, CompletableFuture<Void> delivered) {
     }
 
     /** Per-worker delivery state, guarded by its own monitor (single writer per worker). */
@@ -207,7 +157,6 @@ public final class Injector {
         boolean awaitingCompletion; // a delivered message's turn is not yet known-complete
         boolean turnObserved;      // saw a real `working` sample since that delivery (turn ran)
         int unknownSinceTurn;      // consecutive `unknown` samples while a delegation is outstanding (CB-109)
-        int unknownSincePostTurn;  // the same, for the post-turn housekeeping phase (fleetd #306)
         int notReadySincePoll;     // consecutive injectable samples a queued message waited on the readiness gate (CB-114)
         boolean postTurnPending;   // completion observed; adapter housekeeping has not started yet
         boolean awaitingPostTurnPickup;
@@ -227,47 +176,15 @@ public final class Injector {
      * <p>Uses an atomic map update so a concurrent {@link #drop} cannot slip between "find the
      * target" and "queue the message" and orphan it in a target it just removed.
      */
-    public Delivery enqueue(String target, String text, TurnToken token) {
+    public CompletableFuture<Void> enqueue(String target, String text, TurnToken token) {
         CompletableFuture<Void> delivered = new CompletableFuture<>();
-        Pending p = new Pending(target, text, token, delivered);
+        Pending p = new Pending(text, token, delivered);
         targets.compute(target, (_, existing) -> {
             Target t = (existing != null) ? existing : new Target();
             t.add(p); // synchronized on the Target monitor — atomic with a concurrent drop
             return t;
         });
-        return new Delivery(p);
-    }
-
-    /**
-     * Cancel this exact queued delivery. The target monitor serializes this operation with
-     * {@link #onStatus}: if delivery wins that race, this returns {@link Cancellation#DELIVERED}
-     * rather than claiming the message remained queued.
-     */
-    public Cancellation cancel(Delivery delivery) {
-        Pending p = delivery.pending;
-        Target t = targets.get(p.target);
-        if (t == null) {
-            return cancellationOf(p);
-        }
-        synchronized (t) {
-            if (p.state != Pending.State.QUEUED || !t.queue.remove(p)) {
-                return cancellationOf(p);
-            }
-            p.state = Pending.State.CANCELLED;
-            if (isQuiescent(t)) {
-                targets.remove(p.target, t);
-            }
-            return Cancellation.CANCELLED;
-        }
-    }
-
-    private static Cancellation cancellationOf(Pending p) {
-        return p.state == Pending.State.DELIVERED ? Cancellation.DELIVERED : Cancellation.NOT_DELIVERED;
-    }
-
-    private static boolean isQuiescent(Target t) {
-        return t.queue.isEmpty() && !t.awaitingPickup && !t.awaitingCompletion
-                && !t.postTurnPending && !t.awaitingPostTurnPickup && !t.postTurnObserved;
+        return delivered;
     }
 
     /**
@@ -300,12 +217,10 @@ public final class Injector {
                 t.awaitingPickup = false;
                 t.injectableSincePickup = 0;
                 t.unknownSinceTurn = 0;
-                t.unknownSincePostTurn = 0;
                 t.notReadySincePoll = 0;
                 if (t.awaitingCompletion) t.turnObserved = true;
             } else if (status.injectable()) { // IDLE or BLOCKED
                 t.unknownSinceTurn = 0;
-                t.unknownSincePostTurn = 0;
                 if (t.awaitingPostTurnPickup) {
                     if (++t.injectableSincePostTurnPickup >= PICKUP_GRACE_POLLS) {
                         t.awaitingPostTurnPickup = false;
@@ -356,7 +271,6 @@ public final class Injector {
                             try {
                                 agentsFor(target).send(target, p.text());
                                 t.queue.poll();
-                                p.state = Pending.State.DELIVERED;
                                 t.awaitingPickup = true;
                                 t.awaitingCompletion = true;
                                 t.turnObserved = false;
@@ -366,7 +280,6 @@ public final class Injector {
                                 // Delivery failed at herdr; drop the poisoned message and surface it
                                 // rather than blocking the queue behind it.
                                 t.queue.poll();
-                                p.state = Pending.State.NOT_DELIVERED;
                                 sent = p;
                                 sendError = e;
                             }
@@ -377,9 +290,6 @@ public final class Injector {
                             // fail every queued message and release the target (CB-114) instead of
                             // polling it indefinitely with the caller's future never completing.
                             notReady = new ArrayList<>(t.queue);
-                            for (Pending pending : notReady) {
-                                pending.state = Pending.State.NOT_DELIVERED;
-                            }
                             log.warn("readiness grace for {} expired after {} polls ({}s): target never "
                                     + "became deliverable, so failing {} queued message(s) that never "
                                     + "reached its pane",
@@ -405,29 +315,12 @@ public final class Injector {
                     t.unknownSinceTurn = 0;
                     turnFailed = true;
                 }
-                // fleetd #306: the same escape for the post-turn housekeeping phase. Four latches
-                // gate delivery (awaitingCompletion, postTurnPending, awaitingPostTurnPickup,
-                // postTurnObserved) and only the first had a way out of a sustained unknown streak —
-                // a gate that closed one direction only. The other two below are released here as
-                // well; postTurnPending needs no escape because it is cleared unconditionally on the
-                // line after the listener call that sets it.
-                //
-                // This does NOT set turnFailed. The delegated turn already completed and its waiter
-                // already resolved — what is outstanding is adapter housekeeping (the `/clear`).
-                // Reporting a turn failure here would drive SessionManager.onFailed on a session
-                // that genuinely finished its work, which is a worse lie than the wedge.
-                if ((t.awaitingPostTurnPickup || t.postTurnObserved)
-                        && ++t.unknownSincePostTurn >= TURN_STALL_GRACE_POLLS) {
-                    t.awaitingPostTurnPickup = false;
-                    t.postTurnObserved = false;
-                    t.injectableSincePostTurnPickup = 0;
-                    t.unknownSincePostTurn = 0;
-                }
             }
 
             // Reclaim the entry once the worker is fully quiescent (nothing queued, no pickup or
             // completion awaited), so the map cannot grow without bound across short-lived workers.
-            if (isQuiescent(t)) {
+            if (t.queue.isEmpty() && !t.awaitingPickup && !t.awaitingCompletion
+                    && !t.postTurnPending && !t.awaitingPostTurnPickup && !t.postTurnObserved) {
                 targets.remove(target, t);
             }
         }
@@ -518,9 +411,6 @@ public final class Injector {
         boolean hadDeliveredTurn;
         synchronized (t) {
             pending = new ArrayList<>(t.queue);
-            for (Pending p : pending) {
-                p.state = Pending.State.NOT_DELIVERED;
-            }
             t.queue.clear();
             hadDeliveredTurn = t.awaitingCompletion;
             t.awaitingCompletion = false;

fleetd/src/main/java/dev/ltms/fleet/lead/LeadLauncher.java

@@ -4,7 +4,6 @@ import dev.ltms.fleet.config.FleetConfig;
 import dev.ltms.fleet.herdr.Agent;
 import dev.ltms.fleet.herdr.AgentControl;
 import dev.ltms.fleet.herdr.HerdrException;
-import dev.ltms.fleet.herdr.PendingCloseMarker;
 import dev.ltms.fleet.herdr.Tab;
 import dev.ltms.fleet.herdr.Workspace;
 import dev.ltms.fleet.herdr.WorkspaceControl;
@@ -13,11 +12,9 @@ import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
 import dev.ltms.fleet.peer.PeerLauncher;
 
 /**
@@ -47,33 +44,8 @@ import dev.ltms.fleet.peer.PeerLauncher;
  * privilege escalation (the tab label never granted anything a pane could take for itself; see that
  * class's javadoc), but <em>staleness</em>: a label left behind by a crashed session would otherwise
  * read as a live lead forever, and the lead would never be relaunched. So a lead counts as live only
- * when herdr also reports a <em>running agent</em> in that tab — see {@link #countLeads}. A labelled
+ * when herdr also reports a <em>running agent</em> in that tab — see {@link #liveLeads}. A labelled
  * tab with no agent in it is not a lead.
- *
- * <p><strong>fleetd #359 — a stale label used to pile up, not just mislead.</strong> Finding "not
- * live" here used to mean only one thing: launch another. The old label was left exactly where it
- * was, so a daemon that restarted enough times — or hit one herdr read that missed a genuinely
- * running agent — accumulated one more identically-labelled dead tab per occurrence, and
- * {@code LeadTabScanner} (before its own #359 fix) reported every one of them as a lead.
- *
- * <p><strong>Review finding 1 — closing on one reading is worse than the bug.</strong> The first
- * version of this fix closed a name's dead tabs the moment a single {@link #countLeads} reading
- * called them dead. The ticket's own live evidence rules that out: on a real host, {@code
- * agent.list} was seen reporting "0 live" for a tab that a plain {@code ps} confirmed was running a
- * real session. Closing on that reading would have destroyed the operator's actual lead — a worse
- * failure than the extra tab it replaces. So {@link #ensureLeads()} now needs the same dead reading
- * <em>twice</em>, one restart apart, before it closes anything: the first time a labelled tab reads
- * dead, it is only flagged ({@link PendingCloseMarker}), left running, untouched; it is closed only
- * if a <em>later</em>, independently-connected reconcile still finds it dead while the flag is
- * still there. A transient miss self-heals — the next reconcile sees the agent again and clears the
- * flag (see {@code toUnflag} below) — so the worst case for a single bad reading is one extra tab
- * surviving one more restart, never a live session destroyed. Two alternatives were considered and
- * rejected: corroborating {@code agent.list} against a second, truly independent signal was dropped
- * because nothing else herdr exposes proves "is a process attached to this pane" any better — a
- * second call to the same unreliable source is not independent evidence; capping the close to "all
- * but the most recent dead tab" was dropped because "most recent" has no reliable ordering across
- * tab ids and would leave the true failure mode (a name that is <em>never</em> reconfirmed) growing
- * by one tab per bad reading forever, which is the exact defect this ticket exists to fix.
  */
 public final class LeadLauncher {
 
@@ -107,9 +79,9 @@ public final class LeadLauncher {
             return 0;
         }
 
-        Map<String, LeadCount> live;
+        Map<String, Integer> live;
         try {
-            live = countLeads(leaders);
+            live = liveLeads(leaders);
         } catch (HerdrException e) {
             // Counting is the whole safety mechanism against double-spawning. If we cannot count, we
             // must not guess — spawning a second orchestrator is worse than starting none.
@@ -121,53 +93,9 @@ public final class LeadLauncher {
         for (Map.Entry<String, FleetConfig.Leader> e : leaders.entrySet()) {
             String name = e.getKey();
             FleetConfig.Leader lead = e.getValue();
-            LeadCount state = live.getOrDefault(name, LeadCount.NONE);
-            int running = state.running();
+            int running = live.getOrDefault(name, 0);
             int wanted = lead.instances();
 
-            // fleetd #359 review finding 1: a tab already flagged pending-close, still labelled for
-            // this lead, and STILL hosting no agent on this separate reconcile — two independent
-            // readings agree, so close it. A tab found dead for the first time is only flagged below,
-            // never closed on the spot.
-            for (String tabId : state.toClose()) {
-                log.info("lead '{}': closing tab {} — flagged pending-close on a previous reconcile "
-                        + "and still no agent running in it", name, tabId);
-                try {
-                    spaces.closeTab(tabId);
-                } catch (RuntimeException cleanup) {
-                    log.warn("could not close stale tab {} for lead '{}': {}",
-                            tabId, name, cleanup.getMessage());
-                }
-            }
-            // A tab labelled for this lead, with no agent running in it, seen dead for the first
-            // time — flag it rather than closing it. One reading of `agent.list` is not enough
-            // evidence to destroy a tab that might genuinely be live (see the class javadoc).
-            for (String tabId : state.toFlag()) {
-                String flagged = lead.tabLabel() + PendingCloseMarker.SUFFIX;
-                log.info("lead '{}': tab {} has no agent running in it this reconcile — flagging it "
-                        + "'{}' rather than closing; it is only closed if a later reconcile still "
-                        + "finds it dead", name, tabId, flagged);
-                try {
-                    spaces.renameTab(tabId, flagged);
-                } catch (RuntimeException cleanup) {
-                    log.warn("could not flag stale tab {} for lead '{}': {}",
-                            tabId, name, cleanup.getMessage());
-                }
-            }
-            // A previously-flagged tab that is running an agent again — the miss that flagged it was
-            // transient. Clear the flag so a future, unrelated miss starts its own two-reading count
-            // rather than closing on the strength of this one's already-spent flag.
-            for (String tabId : state.toUnflag()) {
-                log.info("lead '{}': tab {} is running an agent again — clearing its pending-close flag",
-                        name, tabId);
-                try {
-                    spaces.renameTab(tabId, lead.tabLabel());
-                } catch (RuntimeException cleanup) {
-                    log.warn("could not clear the pending-close flag on tab {} for lead '{}': {}",
-                            tabId, name, cleanup.getMessage());
-                }
-            }
-
             if (running >= wanted) {
                 log.info("lead '{}': {} live, {} wanted — nothing to start", name, running, wanted);
                 continue;
@@ -198,29 +126,18 @@ public final class LeadLauncher {
     }
 
     /**
-     * How many live leads exist per configured name, and which of that name's labelled tabs are
-     * <em>not</em> live: a running agent in a tab labelled with that lead's exact {@code tab}
-     * (CB-579). Member workspaces are excluded, exactly as the scanner excludes them: a member must
-     * not be counted as a lead because it happens to sit in a matching tab.
+     * How many live leads exist per configured name: a running agent in a tab labelled with that
+     * lead's exact {@code tab} (CB-579). Member workspaces are excluded, exactly as the scanner
+     * excludes them: a member must not be counted as a lead because it happens to sit in a matching
+     * tab.
      *
      * <p>There used to be a second path here — a running agent on the terminal a
      * {@code fleet.leaders.<name>.terminal} pin named, for a lead opened and pinned by hand. That
      * pin is retired: {@code tab} is now the only field identity depends on, and {@link Agent}
      * already carries {@link Agent#tabId()} directly, so a hand-opened lead is found the same way an
      * auto-launched one is — by labelling its tab to match.
-     *
-     * <p>fleetd #359 review finding 1: a labelled tab with nothing running in it is split into
-     * {@code toClose} (already flagged pending-close by a previous reconcile, and still dead — two
-     * independent readings agree) and {@code toFlag} (dead for the first time — not enough evidence
-     * to close yet). {@code toUnflag} is the reverse: a tab flagged pending-close that is running an
-     * agent again, so the flag it carries no longer means anything and {@link #ensureLeads()} clears
-     * it.
      */
-    private record LeadCount(int running, List<String> toClose, List<String> toFlag, List<String> toUnflag) {
-        static final LeadCount NONE = new LeadCount(0, List.of(), List.of(), List.of());
-    }
-
-    private Map<String, LeadCount> countLeads(Map<String, FleetConfig.Leader> leaders) {
+    private Map<String, Integer> liveLeads(Map<String, FleetConfig.Leader> leaders) {
         // A lead and the members share ONE workspace now (the operator asked for a single "session"
         // with many tabs), so a workspace can no longer be excluded wholesale — the lead lives in the
         // member workspace by design. The sole discriminator is the exact tab label: a lead carries
@@ -228,7 +145,6 @@ public final class LeadLauncher {
         // profile's `worker: {profile} #{n}` template. These never collide, so an exact-label match
         // separates them without needing to know which workspace anyone is in.
         Map<String, String> nameByTab = new LinkedHashMap<>();
-        Set<String> flaggedTabIds = new LinkedHashSet<>();
         for (Workspace ws : spaces.listWorkspaces()) {
             if (ws.workspaceId() == null) {
                 continue;
@@ -237,65 +153,31 @@ public final class LeadLauncher {
                 String declared = leadNameOf(tab.label(), leaders);
                 if (declared != null && tab.tabId() != null) {
                     nameByTab.put(tab.tabId(), declared);
-                    if (PendingCloseMarker.isFlagged(tab.label())) {
-                        flaggedTabIds.add(tab.tabId());
-                    }
                 }
             }
         }
 
-        Set<String> liveTabIds = new LinkedHashSet<>();
         Map<String, Integer> counts = new LinkedHashMap<>();
         for (Agent a : agents.list()) {
             String name = nameByTab.get(a.tabId());
             if (name != null) {
                 counts.merge(name, 1, Integer::sum);
-                liveTabIds.add(a.tabId());
             }
         }
-
-        Map<String, List<String>> toCloseByName = new LinkedHashMap<>();
-        Map<String, List<String>> toFlagByName = new LinkedHashMap<>();
-        Map<String, List<String>> toUnflagByName = new LinkedHashMap<>();
-        nameByTab.forEach((tabId, name) -> {
-            boolean live = liveTabIds.contains(tabId);
-            boolean flagged = flaggedTabIds.contains(tabId);
-            if (live) {
-                if (flagged) {
-                    toUnflagByName.computeIfAbsent(name, k -> new ArrayList<>()).add(tabId);
-                }
-                return;
-            }
-            if (flagged) {
-                toCloseByName.computeIfAbsent(name, k -> new ArrayList<>()).add(tabId);
-            } else {
-                toFlagByName.computeIfAbsent(name, k -> new ArrayList<>()).add(tabId);
-            }
-        });
-
-        Map<String, LeadCount> out = new LinkedHashMap<>();
-        for (String name : leaders.keySet()) {
-            out.put(name, new LeadCount(counts.getOrDefault(name, 0),
-                    toCloseByName.getOrDefault(name, List.of()),
-                    toFlagByName.getOrDefault(name, List.of()),
-                    toUnflagByName.getOrDefault(name, List.of())));
-        }
-        return out;
+        return counts;
     }
 
     /**
      * The configured lead a tab label names, or {@code null} for a label that names none.
      *
      * <p>Matched exactly (case-insensitively) against each lead's configured {@code tab}, so an
-     * operator's {@code "lead: something-else"} tab is not mistaken for a configured lead. A
-     * trailing {@link PendingCloseMarker} is stripped first, so a tab this class flagged on a
-     * previous reconcile is still recognised as the same lead's tab on this one.
+     * operator's {@code "lead: something-else"} tab is not mistaken for a configured lead.
      */
     private String leadNameOf(String label, Map<String, FleetConfig.Leader> leaders) {
         if (label == null) {
             return null;
         }
-        String l = PendingCloseMarker.strip(label);
+        String l = label.strip();
         for (Map.Entry<String, FleetConfig.Leader> e : leaders.entrySet()) {
             String tab = e.getValue().tabLabel();
             if (tab != null && l.equalsIgnoreCase(tab.strip())) {

fleetd/src/main/java/dev/ltms/fleet/mcp/ConnectionIdentity.java

@@ -36,25 +36,6 @@ public final class ConnectionIdentity {
      * primary / an off-host client) and its {@code pid} (or {@code -1} if not resolvable).
      */
     public record Caller(String terminal, long pid) {
-
-        /**
-         * Whether the OS peer-PID lookup actually succeeded — {@code false} means {@code pid} is
-         * the {@code -1} sentinel, not a real process id, so this caller's identity could not be
-         * established at all. That is a different fact from a real pid that simply owns no worker
-         * pane (the primary's own connection): the primary is {@code resolved()} and has a
-         * {@code null terminal}; an unresolvable caller is {@code !resolved()} and also has a
-         * {@code null terminal}. The two look identical through {@link #terminal} alone, which is
-         * exactly how fleetd #317 happened — a failed {@code lsof} lookup and a genuine primary both
-         * fell through to {@code Principal.primary(...)}.
-         *
-         * <p>Centralised here, next to the sentinel it tests, for the same reason
-         * {@link ConnectionIdentity#isLoopback} is centralised rather than left for each caller to
-         * reimplement: a raw {@code pid > 0} check duplicated at every call site is precisely the
-         * "one rule, two copies" shape that let #305 drift.
-         */
-        public boolean resolved() {
-            return pid > 0;
-        }
     }
 
     /** Resolve the caller's terminal and PID from one peer-PID lookup. */
@@ -79,44 +60,7 @@ public final class ConnectionIdentity {
         return pid > 0 ? cwds.cwdForPid(pid) : null;
     }
 
-    /**
-     * Whether {@code addr} is a same-host address, and therefore one whose peer PID is worth
-     * looking up. <strong>This is the one definition of loopback in the daemon</strong> —
-     * {@code CallerResolver} calls it rather than keeping its own, because the two used to differ
-     * and that difference was a privilege escalation (fleetd #305).
-     *
-     * <p>The whole of {@code 127.0.0.0/8} counts, not just {@code 127.0.0.1}. On Linux every
-     * address in that range is bound to {@code lo} by default, so a process can connect to
-     * {@code 127.0.0.1:8765} with a source address of {@code 127.0.0.2} — measured on the Linux
-     * fleet host, where binding that source succeeds.
-     *
-     * <p><strong>What excluding an address costs, stated as it is today.</strong> This paragraph
-     * used to say that narrowing this range turned a worker into the lead, and that widening the
-     * check was what closed the hole. That was true only while there were <em>two</em> definitions
-     * that disagreed: {@code ConnectionIdentity} skipped the identity lookup for {@code 127.0.0.2}
-     * while {@code CallerResolver} read the same address as loopback and granted the primary role.
-     * #305 removed the second copy, and with one shared definition the old sentence no longer holds.
-     *
-     * <p>Measured on 2026-09-04 by narrowing this method back to exactly {@code 127.0.0.1} and
-     * running {@code CallerResolverTest} and {@code ConnectionIdentityTest}: a caller from
-     * {@code 127.0.0.2} then resolves to {@code ANONYMOUS}, not {@code PRIMARY} — for a worker
-     * ({@code aWorkerOnAnyLoopbackSourceAddressIsStillAWorkerNotThePrimary}) and for a non-worker
-     * ({@code aNonWorkerOnAnyLoopbackSourceAddressIsStillThePrimary}) alike. Excluding an address
-     * now <em>refuses</em> its caller; it does not promote one.
-     *
-     * <p>So keep the whole range, but for the plain reason: a genuine worker or primary that
-     * connects from {@code 127.0.0.2} must be identifiable at all, and narrowing this predicate
-     * locks it out. That is an outage, and an outage is the direction to fail in — which is exactly
-     * why the range must not be narrowed casually and also why doing so is no longer a security
-     * hole. This predicate still does not decide whether a caller is trusted; it decides whether the
-     * caller's identity is <em>resolved at all</em>. What makes an unresolved caller safe is
-     * {@link Caller#resolved()} (#317), not this method.
-     */
-    public static boolean isLoopback(String addr) {
-        if (addr == null) {
-            return false;
-        }
-        String a = addr.startsWith("::ffff:") ? addr.substring(7) : addr; // IPv4-mapped IPv6
-        return a.startsWith("127.") || "::1".equals(a) || "0:0:0:0:0:0:0:1".equals(a);
+    private static boolean isLoopback(String addr) {
+        return "127.0.0.1".equals(addr) || "::1".equals(addr) || "0:0:0:0:0:0:0:1".equals(addr);
     }
 }

fleetd/src/main/java/dev/ltms/fleet/mcp/FleetMcp.java

@@ -22,7 +22,6 @@ import dev.ltms.fleet.placement.BackendQuarantine;
 import dev.ltms.fleet.placement.PlacementException;
 import dev.ltms.fleet.session.SessionManager;
 import dev.ltms.fleet.session.MemberSession;
-import dev.ltms.fleet.session.ShuttingDownException;
 import dev.ltms.fleet.session.WorktreeRequest;
 import dev.ltms.fleet.peer.MemberRole;
 import dev.ltms.fleet.peer.PeerLauncher;
@@ -37,7 +36,6 @@ import io.modelcontextprotocol.spec.McpSchema;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.servlet.http.HttpServlet;
 
-import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -45,7 +43,6 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -103,8 +100,6 @@ public final class FleetMcp {
     private final LeadSeatSource leadSeats;
     /** CB-637: this daemon's lead-to-lead channel; {@code null} when no coordinator is configured. */
     private final LeadChannel leadChannel;
-    /** fleetd #361: {@code coordinator.peers} — see {@link CoordinationSource}. Empty when unset. */
-    private final List<String> peers;
 
     /** Capacity facts used by {@code fleet_list}; production must supply the placement live count. */
     public record CapacitySource(Function<String, Integer> liveCount, Function<String, Integer> maxLoad,
@@ -120,28 +115,9 @@ public final class FleetMcp {
     /**
      * CB-578 stage B quarantine facts used by {@code fleet_profiles}: a profile → credential id
      * lookup, plus the shared {@link BackendQuarantine} to read remaining cooldowns off.
-     *
-     * @param exhaustedPatternArmed fleetd #395: profile → whether that profile's {@code
-     *                      exhaustedPattern} is configured (see {@code
-     *                      FleetConfig.Profile#hasExhaustedPattern}), i.e. whether a backend refusal
-     *                      on it can EVER be classified {@code BACKEND_EXHAUSTED} and quarantine its
-     *                      credential. Bundled here, not a separate Source, because it answers the
-     *                      exact question {@code fleet_profiles}'s quarantine facts already answer
-     *                      for a QUARANTINED profile — "can this profile's usage limit ever be
-     *                      caught?" — just for every profile, not only one currently caught.
      */
-    public record QuarantineSource(Function<String, String> credentialIdFor, BackendQuarantine quarantine,
-                                    Function<String, Boolean> exhaustedPatternArmed) {
-        /**
-         * Backward-compatible 2-arg form, before fleetd #395 added {@code exhaustedPatternArmed} —
-         * reports every profile unarmed. Keeps every pre-existing call site (production and test)
-         * compiling and behaving identically for the quarantine facts they actually asked for.
-         */
-        public QuarantineSource(Function<String, String> credentialIdFor, BackendQuarantine quarantine) {
-            this(credentialIdFor, quarantine, _ -> false);
-        }
-
-        /** Inert source — no profile is ever reported quarantined or armed. Explicit stand-in, not a default. */
+    public record QuarantineSource(Function<String, String> credentialIdFor, BackendQuarantine quarantine) {
+        /** Inert source — no profile is ever reported quarantined. Explicit stand-in, not a default. */
         public static QuarantineSource none() { return new QuarantineSource(_ -> null, BackendQuarantine.none()); }
     }
 
@@ -187,32 +163,6 @@ public final class FleetMcp {
         public static LeadSeatSource none() { return new LeadSeatSource(_ -> 0); }
     }
 
-    /**
-     * fleetd #361: peer-visibility facts for {@code fleet_list}'s {@code coordinator} row — this
-     * daemon's own {@link LeadChannel} (for its self mailbox state and held messages) plus the
-     * coord-ids the operator has declared as peers ({@code coordinator.peers}). Bundled as its own
-     * Source, the same idiom as {@link OutageSource}/{@link QuarantineSource}/{@link LeadSeatSource},
-     * so {@code listFleet}'s already-long overload chain gains exactly one new required parameter
-     * instead of a further bare positional argument.
-     *
-     * <p>Every mailbox look this triggers goes through {@link LeadChannel#inspect}, which is
-     * specified to run on its own disposable channel — never the channel {@link LeadChannel#publish}
-     * or the consume loop depends on — so a peer that happens to be down, or the coordination broker
-     * itself being unreachable, can never take {@code fleet_send}/{@code LeadCoordLoop}'s own path
-     * down with it. See {@code FleetMcp.probe} for the additional timeout bound on top of that.
-     *
-     * @param leadChannel this daemon's own channel, or {@code null} when no coordinator is configured
-     * @param peers       the coord-ids declared under {@code coordinator.peers}, or empty
-     */
-    public record CoordinationSource(LeadChannel leadChannel, List<String> peers) {
-        public CoordinationSource {
-            peers = peers == null ? List.of() : List.copyOf(peers);
-        }
-
-        /** Inert source — no coordinator row is ever reported. */
-        public static CoordinationSource none() { return new CoordinationSource(null, List.of()); }
-    }
-
     /**
      * @param callers resolves each call's {@link Principal}; {@code null} disables authorization.
      *                This surface needs its own enforcement: {@code /mcp} is a raw servlet on
@@ -260,34 +210,19 @@ public final class FleetMcp {
     }
 
     /**
-     * As above, with fleetd #176 lead-seat facts (see {@link LeadSeatSource}).
+     * As above, with fleetd #176 lead-seat facts (see {@link LeadSeatSource}). This is what
+     * {@code Fleetd.main} actually wires up.
+     *
+     * @param leadSeats required — pass {@link LeadSeatSource#none()} for a caller that does not want
+     *                  the feature, never a defaulting overload (the same rule {@code quarantine} and
+     *                  {@code outage} follow).
      */
     public FleetMcp(MessageService messages, PeerLauncher workers, SessionManager sessions,
                      ConnectionIdentity identity, MemberPresence presence, PrimaryRegistry primaryRegistry,
                       CallerResolver callers, Metrics metrics, CapacitySource capacity, HealthCoverageSource healthCoverage,
                       QuarantineSource quarantine, LeadChannel leadChannel, OutageSource outage,
                       LeadSeatSource leadSeats) {
-        this(messages, workers, sessions, identity, presence, primaryRegistry, callers, metrics, capacity,
-                healthCoverage, quarantine, leadChannel, outage, leadSeats, List.of());
-    }
-
-    /**
-     * As above, with fleetd #361 {@code coordinator.peers} (see {@link CoordinationSource}). This is
-     * what {@code Fleetd.main} actually wires up.
-     *
-     * @param leadSeats required — pass {@link LeadSeatSource#none()} for a caller that does not want
-     *                  the feature, never a defaulting overload (the same rule {@code quarantine} and
-     *                  {@code outage} follow).
-     * @param peers     the coord-ids declared under {@code coordinator.peers}; empty when unset or
-     *                  when {@code leadChannel} is {@code null}.
-     */
-    public FleetMcp(MessageService messages, PeerLauncher workers, SessionManager sessions,
-                     ConnectionIdentity identity, MemberPresence presence, PrimaryRegistry primaryRegistry,
-                      CallerResolver callers, Metrics metrics, CapacitySource capacity, HealthCoverageSource healthCoverage,
-                      QuarantineSource quarantine, LeadChannel leadChannel, OutageSource outage,
-                      LeadSeatSource leadSeats, List<String> peers) {
         this.leadChannel = leadChannel;
-        this.peers = peers == null ? List.of() : List.copyOf(peers);
         this.capacity = capacity;
         this.quarantine = Objects.requireNonNull(quarantine, "quarantine");
         this.outage = Objects.requireNonNull(outage, "outage");
@@ -322,7 +257,7 @@ public final class FleetMcp {
         // Each handler is built once and wired to its fleet_* tool below.
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> sendHandler =
                 (exchange, req) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_send", req.arguments()),
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.SEND,
                             str(req.arguments(), "sessionId"));
                     if (denied != null) return denied;
                     String caller = callerTerminal(exchange);
@@ -364,21 +299,21 @@ public final class FleetMcp {
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> replyHandler =
                 (exchange, req) -> {
                     String self = callerTerminal(exchange);
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_reply", req.arguments()), self);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.REPLY, self);
                     if (denied != null) return denied;
-                    return reply(messages, self, principal(exchange).role(), str(req.arguments(), "content"));
+                    return reply(messages, self, str(req.arguments(), "content"));
                 };
         // fleet_ask (CB-205): a worker's mid-turn question — identity from the CONNECTION.
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> askHandler =
                 (exchange, req) -> {
                     String self = callerTerminal(exchange);
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_ask", req.arguments()), self);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.ASK, self);
                     if (denied != null) return denied;
                     return ask(messages, self, str(req.arguments(), "question"), timeoutMs(req.arguments()));
                 };
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> statusHandler =
                 (exchange, req) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_status", req.arguments()), null);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.READ, null);
                     if (denied != null) return denied;
                     return status(messages, str(req.arguments(), "sessionId"));
                 };
@@ -386,25 +321,24 @@ public final class FleetMcp {
                 (exchange, req) -> {
                     Map<String, Object> a = req.arguments();
                     String target = str(a, "target");
-                    String coordId = str(a, "coordId");
                     // The action depends on the ARGUMENTS, not on the tool name -- see pollAction.
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_poll", a), target);
+                    McpSchema.CallToolResult denied = deny(exchange, pollAction(target), target);
                     if (denied != null) return denied;
-                    return poll(messages, leadChannel, str(a, "ticket"), target, coordId);
+                    return poll(messages, str(a, "ticket"), target);
                 };
         // CB-307 Increment 3: per-msgId ack (not needed in v1 but supported by the inbox).
         // Acking removes a reply from the inbox, so it is a drain, not a read.
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> ackHandler =
                 (exchange, req) -> {
                     Map<String, Object> a = req.arguments();
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_ack", a), str(a, "target"));
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.DRAIN, str(a, "target"));
                     if (denied != null) return denied;
                     return ack(messages, str(a, "target"), str(a, "msgId"));
                 };
         // Fleet management (CB-108): spawn/list/stop over ClaudeCodeLauncher.
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> spawnHandler =
                 (exchange, req) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_spawn", req.arguments()), null);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.SPAWN, null);
                     if (denied != null) return denied;
                     String caller = callerTerminal(exchange);
                     // SPAWN is already auth-gated to PRIMARY (architects can never call it), but
@@ -421,30 +355,29 @@ public final class FleetMcp {
                 };
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> listHandler =
                 (exchange, _) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_list", Map.of()), null);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.READ, null);
                     if (denied != null) return denied;
                     return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, outage,
                             leadSeats, callers == null ? Map.of() : callers.leads(),
                             callerTerminal(exchange),
-                            new CoordinationSource(leadChannel, peers),
-                            coordinatorVisibleTo(principal(exchange)));
+                            leadChannel == null ? null : leadChannel.selfCoordId());
                 };
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> stopHandler =
                 (exchange, req) -> {
                     String paneId = str(req.arguments(), "paneId");
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_stop", req.arguments()), paneId);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.STOP, paneId);
                     if (denied != null) return denied;
                     return stop(sessions, paneId);
                 };
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> profilesHandler =
                 (exchange, _) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_profiles", Map.of()), null);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.READ, null);
                     if (denied != null) return denied;
                     return profiles(workers, quarantine, outage);
                 };
         BiFunction<McpSyncServerExchange, McpSchema.CallToolRequest, McpSchema.CallToolResult> whoamiHandler =
                 (exchange, _) -> {
-                    McpSchema.CallToolResult denied = deny(exchange, toolAction("fleet_whoami", Map.of()), null);
+                    McpSchema.CallToolResult denied = deny(exchange, Authz.Action.READ, null);
                     if (denied != null) return denied;
                     return whoami(principal(exchange), sessions);
                 };
@@ -580,20 +513,6 @@ public final class FleetMcp {
         }
     }
 
-    /**
-     * fleetd #439: only the primary may read {@code fleet_list}'s {@code coordinator} row —
-     * lead-to-lead coordination state (coord-ids, mailbox facts, held-message previews), never the
-     * roster. Split out of the {@code fleet_list} handler, same reason as {@link #denyFor} and
-     * {@link #recordPrimarySingleton}: the decision must be unit-testable without fabricating an
-     * SDK {@code McpSyncServerExchange}, and the handler must call this named predicate rather than
-     * inlining the check, so a future edit cannot silently pass a literal instead of asking who
-     * called ({@code FleetMcpAuthzTest.theFleetListHandlerActuallyConsultsCoordinatorVisibleTo}
-     * reads the source and asserts the handler calls this method by name, not a literal).
-     */
-    static boolean coordinatorVisibleTo(Principal caller) {
-        return caller.isPrimary();
-    }
-
     /** The worker identity resolved from this call's connection, or {@code null} if the primary. */
     private static String callerTerminal(McpSyncServerExchange exchange) {
         Object v = exchange.transportContext().get(CALLER_TERMINAL);
@@ -777,15 +696,6 @@ public final class FleetMcp {
      * turned into a tool error naming the coord-id. It is never allowed to escape as a crash: an
      * unreachable peer is an ordinary outcome of addressing a fleet you do not control.
      *
-     * <p><strong>fleetd #361: the success text is honest about what "durably confirmed" does and
-     * does not mean.</strong> The broker's publisher confirm proves the message is durably queued —
-     * it says nothing about whether the peer's pane has, or ever will, receive it. After a
-     * successful publish this looks at the target mailbox's consumer count (via
-     * {@link LeadChannel#inspect}, bounded and never allowed to fail the call — see {@link #probe})
-     * and appends a warning when it is zero: that is the observable form of "nobody is reading this
-     * right now". A zero-consumer publish is still reported as a SUCCESS, never an error — the
-     * message is safely queued and will be read once a daemon owning that coord-id connects.
-     *
      * @param leadChannel this daemon's channel, or {@code null} when no coordinator is configured
      */
     static McpSchema.CallToolResult sendToLead(LeadChannel leadChannel, String coordId, String content,
@@ -813,95 +723,39 @@ public final class FleetMcp {
                     + ". Check that a daemon is running with coordinator.selfId=\"" + coordId
                     + "\" and is connected to the same coordination broker.");
         }
-        String result = "published to peer lead \"" + coordId + "\"'s mailbox and durably confirmed "
-                + "by the broker (msgId " + msg.msgId() + ").";
-        LeadChannel.MailboxState state = probe(leadChannel, coordId);
-        if (state.exists() && state.consumers() == 0) {
-            result += " Warning: that mailbox currently has NO consumers attached — nobody is reading "
-                    + "it right now. The message is safely queued and will be delivered once a daemon "
-                    + "with coordinator.selfId=\"" + coordId + "\" is running and connected; until then "
-                    + "it will not reach that lead's pane.";
-        }
-        return text(result);
+        return text("delivered to peer lead " + coordId + " (msgId " + msg.msgId() + ")");
     }
 
     /**
      * Which authorization action a {@code fleet_poll} call needs, decided by its arguments
-     * (fleetd #272, widened by fleetd #421).
+     * (fleetd #272).
      *
-     * <p>{@code fleet_poll} is now <strong>three operations behind one tool name</strong>. With
-     * {@code ticket} it observes an async delegation and changes nothing, which is a {@link
+     * <p>{@code fleet_poll} is <strong>two operations behind one tool name</strong>. With {@code
+     * ticket} it observes an async delegation and changes nothing, which is a {@link
      * Authz.Action#READ}. With {@code target} it calls {@link MessageService#drainReplies} on that
      * session -- the replies are removed from the inbox and a second call returns nothing -- so it
      * is a {@link Authz.Action#DRAIN}, the same gate {@code fleet_ack} already uses for removing a
-     * single message, and the same one the REST path uses at {@code FleetApp.drainReplies}. With
-     * {@code coordId} it reads (never acks) this daemon's own held lead-to-lead mail, which is a
-     * {@link Authz.Action#COORD_READ} -- <strong>not</strong> {@code READ}, even though nothing is
-     * consumed: {@code READ}'s grant is open to every authenticated role on the premise that the
-     * roster carries no secrets, and a lead-to-lead body is not the roster. Mapping a non-destructive
-     * peer-mail read to {@code READ} would let any worker read every peer lead's mail in full.
+     * single message, and the same one the REST path uses at {@code FleetApp.drainReplies}.
      *
-     * <p>Before this method existed (fleetd #272) the handler passed a constant {@code READ} for
-     * both of the original branches. {@code READ} is open to every authenticated role, so any
-     * worker could read a peer's id out of {@code fleet_list} and destroy the replies that peer had
-     * queued for the primary. The gate failed open, and it did so because the required action is a
-     * function of the arguments while the handler chose it before looking at them.
+     * <p>Until this method existed the handler passed a constant {@code READ} for both branches.
+     * {@code READ} is open to every authenticated role, so any worker could read a peer's id out of
+     * {@code fleet_list} and destroy the replies that peer had queued for the primary. The gate
+     * failed open, and it did so because the required action is a function of the arguments while
+     * the handler chose it before looking at them.
      *
      * <p>The choice lives in this method, and not inline in the handler, so that a test can assert
      * the mapping the handler actually uses. {@code FleetMcpAuthzTest} already checked every
      * {@link Authz.Action} against every {@link Role} and passed throughout -- it tested the policy
      * table, which was correct, while the defect was in which action the caller handed it.
      *
-     * <p>Checked first, and exclusively of {@code target}: a call naming {@code coordId} is reading
-     * a different inbox entirely (this daemon's own lead channel, never a worker's), so it takes
-     * priority over whatever {@code target} might also say.
-     *
-     * @param target  the {@code target} argument of the call, or {@code null}/blank when absent
-     * @param coordId the {@code coordId} argument of the call, or {@code null}/blank when absent
+     * @param target the {@code target} argument of the call, or {@code null}/blank when absent
      */
-    static Authz.Action pollAction(String target, String coordId) {
-        if (!isBlank(coordId)) {
-            return Authz.Action.COORD_READ;
-        }
+    static Authz.Action pollAction(String target) {
         return isBlank(target) ? Authz.Action.READ : Authz.Action.DRAIN;
     }
 
-    /**
-     * The action a registered tool handler actually hands to the authorization gate.
-     * Keeping this choice beside the registered-tool inventory makes a new tool fail the coverage
-     * test until its action is pinned.
-     */
-    static Authz.Action toolAction(String toolName, Map<String, Object> arguments) {
-        return switch (toolName) {
-            case "fleet_send" -> Authz.Action.SEND;
-            case "fleet_reply" -> Authz.Action.REPLY;
-            case "fleet_ask" -> Authz.Action.ASK;
-            case "fleet_status", "fleet_list", "fleet_profiles", "fleet_whoami" -> Authz.Action.READ;
-            case "fleet_poll" -> pollAction(str(arguments, "target"), str(arguments, "coordId"));
-            case "fleet_ack" -> Authz.Action.DRAIN;
-            case "fleet_spawn" -> Authz.Action.SPAWN;
-            case "fleet_stop" -> Authz.Action.STOP;
-            default -> throw new IllegalArgumentException("unregistered tool: " + toolName);
-        };
-    }
-
     /** {@code fleet_poll}: check an async delegation by ticket, or drain a worker's inbox by target. */
     static McpSchema.CallToolResult poll(MessageService messages, String ticket, String target) {
-        return poll(messages, null, ticket, target, null);
-    }
-
-    /**
-     * As above, plus (fleetd #421) a held-peer-mail read when {@code coordId} is present: returns
-     * this daemon's own held lead-to-lead messages, in full, without acking them. Checked first and
-     * exclusively of {@code ticket}/{@code target} — see {@link #pollAction}'s javadoc for why this
-     * is a different inbox (this daemon's own {@link LeadChannel}) that authorizes differently
-     * ({@link Authz.Action#COORD_READ}, primary-only) from either of the original two branches.
-     */
-    static McpSchema.CallToolResult poll(MessageService messages, LeadChannel leadChannel, String ticket,
-                                         String target, String coordId) {
-        if (!isBlank(coordId)) {
-            return pollHeldPeerMail(leadChannel, coordId);
-        }
         if (!isBlank(target)) {
             var replies = messages.drainReplies(target);
             if (replies.isEmpty()) {
@@ -929,79 +783,22 @@ public final class FleetMcp {
         };
     }
 
-    /**
-     * fleetd #421: a lead's own held lead-to-lead mail, read without consuming it.
-     *
-     * <p>{@link LeadChannel#peek} is non-destructive, so calling this twice returns the same
-     * bodies, and {@code fleet_list}'s {@code coordinator.held[]} is unaffected — this adds a
-     * read, it never acks. Never let this short-circuit the delivery contract: {@code
-     * LeadCoordLoop}'s javadoc explains why a message must stay unacked until actually delivered,
-     * and that is unchanged here.
-     *
-     * <p>{@code coordId} must be THIS daemon's own coord-id ({@code fleet_list}'s
-     * {@code coordinator.selfId}) — there is no route here to read a PEER's outbound mail, only
-     * your own inbound mail. Requiring the caller to echo its own id catches the exact confusion
-     * that opened fleetd #421: the original failed attempt passed a PEER's id ("fleet01") as
-     * {@code fleet_poll}'s {@code target}, expecting to read that peer's messages, and got the same
-     * silent {@code []} as a genuinely empty worker inbox. This refuses the same mistake here with a
-     * reason, instead of a second silent wrong answer.
-     */
-    static McpSchema.CallToolResult pollHeldPeerMail(LeadChannel leadChannel, String coordId) {
-        if (leadChannel == null) {
-            return error("lead coordination is not configured (no coordinator: block) — there is "
-                    + "no held peer mail to read.");
-        }
-        String selfId = leadChannel.selfCoordId();
-        if (!coordId.equals(selfId)) {
-            return error("coordId \"" + coordId + "\" is not this daemon's own coord-id (\"" + selfId
-                    + "\"). fleet_poll reads only YOUR OWN held mail — pass your own coordId "
-                    + "(fleet_list's coordinator.selfId), not a peer's.");
-        }
-        return text(json(leadChannel.peek().stream().map(FleetMcp::heldMailView).toList()));
-    }
-
-    /** The full body of one held lead-to-lead message — never truncated, unlike {@link #heldView}. */
-    private static Map<String, Object> heldMailView(LeadMessage m) {
-        Map<String, Object> row = new LinkedHashMap<>();
-        row.put("msgId", m.msgId());
-        row.put("from", m.from());
-        row.put("content", m.content());
-        return row;
-    }
-
     /**
      * {@code fleet_reply}: the worker returns its structured answer, resolving the awaiting send
      * or — when no send is open — queueing the reply in the inbox for later drain (CB-307).
-     * {@code callerTerminal} and {@code callerRole} are resolved from the connection (never an
-     * argument). A {@code null} terminal means the caller is not a known worker. A PRIMARY with a
-     * terminal is a lead and must use {@code fleet_send}, because reply has no peer-lead route.
-     *
-     * <p>fleetd #365: the result text names which of those actually happened
-     * ({@link MessageService.ReplyOutcome#description()}) instead of the single word "delivered"
-     * for both — a queued reply is a real success, but it is not the same fact as one that resolved
-     * a live waiter, and the caller could not previously tell them apart.
+     * {@code callerTerminal} is resolved from the connection (never an argument); a {@code null}
+     * means the caller is not a known worker (e.g. the primary called it by mistake).
      */
-    static McpSchema.CallToolResult reply(MessageService messages, String callerTerminal, Role callerRole, String content) {
+    static McpSchema.CallToolResult reply(MessageService messages, String callerTerminal, String content) {
         if (callerTerminal == null) {
             return error("fleet_reply is for workers only — could not identify the calling worker "
                     + "from the connection");
         }
-        if (callerRole == Role.PRIMARY) {
-            return error("fleet_reply has no route to a peer lead. Use fleet_send{coordId: ...} for a peer on another "
-                    + "daemon or fleet_send{sessionId: ...} for a peer on this host. fleet_reply resolves a member's "
-                    + "blocked fleet_send, and a peer's coord-id message is durable and non-blocking, so there is "
-                    + "nothing for it to resolve.");
-        }
-        // fleetd #302: isBlank, not == null, to match fleet_send's own guard above. MessageService
-        // .reply now REJECTS blank content, and this handler is a bare BiFunction with no try/catch
-        // around it — so a whitespace-only fleet_reply would leave here as an uncaught
-        // IllegalArgumentException instead of this clean tool error. Null and whitespace are the
-        // same mistake by the caller and must get the same answer.
-        if (isBlank(content)) {
+        if (content == null) {
             return error("content is required");
         }
-        MessageService.ReplyOutcome outcome = messages.reply(callerTerminal, content);
-        return text(outcome.description());
+        messages.reply(callerTerminal, content);
+        return text("delivered");
     }
 
     /** {@code fleet_ack}: acknowledge (remove) a specific reply from the inbox. */
@@ -1009,11 +806,7 @@ public final class FleetMcp {
         if (isBlank(target) || isBlank(msgId)) {
             return error("target and msgId are required");
         }
-        if (!messages.ackReply(target, msgId)) {
-            return error(msgId + " is not in " + target + "'s reply inbox (wrong id, wrong target, "
-                    + "or already acked). Held lead-to-lead (peer) mail cannot be acked this way — "
-                    + "read it with fleet_poll{coordId}.");
-        }
+        messages.ackReply(target, msgId);
         return text("acknowledged " + msgId);
     }
 
@@ -1145,10 +938,6 @@ public final class FleetMcp {
             return text(json(memberView(member)));
         } catch (GuardException e) {
             return error("subscription boundary: " + e.getMessage());
-        } catch (ShuttingDownException e) {
-            // fleetd #308: the daemon's shutdown drain has already started — refuse loudly rather
-            // than register a session drainAll will never see again.
-            return error("shutting down: " + e.getMessage());
         } catch (PlacementException e) {
             // CB-599: no candidate had capacity (maxLoad, quarantine, or all-exhausted) — distinct
             // from "profile does not exist" below.
@@ -1207,41 +996,12 @@ public final class FleetMcp {
      * both maps at once when it is both exhaustion-quarantined AND cooling off.
      */
     static McpSchema.CallToolResult profiles(PeerLauncher workers, QuarantineSource quarantine, OutageSource outage) {
-        return text(json(profilesView(workers, quarantine, outage)));
-    }
-
-    /**
-     * The body both front doors answer {@code profiles} with: the configured profile names, the
-     * default, and the two independent outage states — {@code quarantined} (the backend reported it
-     * out of capacity) and {@code coolingOff} (the credential threw repeated non-exhaustion backend
-     * errors). Each map is present only when at least one profile is in that state, and a profile
-     * can appear in both at once, because the two checks are separate.
-     *
-     * <p>fleetd #297: extracted so {@code fleet_profiles} and {@code GET /profiles} render from ONE
-     * body builder rather than two copies. Passing both doors the same {@link QuarantineSource} and
-     * {@link OutageSource} instances is necessary but not sufficient: with the loop written out
-     * twice, a later edit to the row shape — a renamed key, an added field — lands on one door and
-     * not the other, and the two then disagree about a live outage. That is exactly what fleetd
-     * #284 was, where one rule computed in two places was widened in only one and a single response
-     * contradicted itself. Shared inputs do not make duplicated computation safe.
-     *
-     * <p>fleetd #395: also reports {@code exhaustionDetectionArmed}, one boolean per configured
-     * profile — {@code true} when that profile's {@code exhaustedPattern} is set, {@code false}
-     * when it is not, so an operator can tell "this profile is healthy" from "nothing can ever
-     * quarantine this profile" without reading {@code fleetd.yaml}. Unlike {@code quarantined}/
-     * {@code coolingOff}, this map always names every profile: an unarmed profile never enters a
-     * transient state to be absent from, so silence here would read as "healthy" rather than "not
-     * being watched at all".
-     */
-    public static Map<String, Object> profilesView(PeerLauncher workers, QuarantineSource quarantine, OutageSource outage) {
         Map<String, Object> result = new LinkedHashMap<>();
         result.put("profiles", workers.profiles());
         result.put("default", workers.defaultProfile() == null ? "" : workers.defaultProfile());
         Map<String, Object> quarantined = new LinkedHashMap<>();
         Map<String, Object> coolingOff = new LinkedHashMap<>();
-        Map<String, Object> exhaustionDetectionArmed = new LinkedHashMap<>();
         for (String profile : workers.profiles()) {
-            exhaustionDetectionArmed.put(profile, quarantine.exhaustedPatternArmed().apply(profile));
             String credentialId = quarantine.credentialIdFor().apply(profile);
             if (credentialId != null) {
                 quarantine.quarantine().remainingSeconds(credentialId).ifPresent(remaining -> {
@@ -1261,31 +1021,13 @@ public final class FleetMcp {
                 });
             }
         }
-        result.put("exhaustionDetectionArmed", exhaustionDetectionArmed);
         if (!quarantined.isEmpty()) {
             result.put("quarantined", quarantined);
         }
         if (!coolingOff.isEmpty()) {
             result.put("coolingOff", coolingOff);
         }
-        // fleetd #422: read the exact same accessor CompositePeerLauncher's spawn gate reads
-        // (PeerLauncher.modelGateState(), which for the composite is models0() read live) — never a
-        // separately-derived answer, so this status can never overstate or understate what the gate
-        // actually enforces (the fleetd #404 lesson).
-        //
-        // fleetd #422 follow-up: "armed" and "off" come from the ONE modelGateState() call below,
-        // never two independent reads of the gate — a reload landing between two separate reads
-        // could otherwise make them disagree. modelGateArmed is reported unconditionally (never
-        // omitted like quarantined/coolingOff above) precisely so a lead can tell "no models: block
-        // at all" (false) apart from "a models: block with nothing currently off" (true, with
-        // modelsOff simply absent below) — the two states PeerLauncher.disabledModels() alone
-        // cannot distinguish, both reporting an empty set.
-        PeerLauncher.ModelGateState modelGate = workers.modelGateState();
-        result.put("modelGateArmed", modelGate.configured());
-        if (!modelGate.off().isEmpty()) {
-            result.put("modelsOff", new ArrayList<>(modelGate.off()));
-        }
-        return result;
+        return text(json(result));
     }
 
     /**
@@ -1320,8 +1062,7 @@ public final class FleetMcp {
     static McpSchema.CallToolResult listFleet(PeerLauncher workers, SessionManager sessions, MessageService messages,
                                                CapacitySource capacity, HealthCoverageSource healthCoverage,
                                                QuarantineSource quarantine, Map<String, String> leads, String selfTerm) {
-        return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, leads, selfTerm,
-                CoordinationSource.none());
+        return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, leads, selfTerm, null);
     }
 
     /** As above, plus fleetd #201 Unit 5 cool-off facts (see {@link OutageSource}). */
@@ -1330,73 +1071,41 @@ public final class FleetMcp {
                                                QuarantineSource quarantine, OutageSource outage,
                                                Map<String, String> leads, String selfTerm) {
         return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, outage,
-                LeadSeatSource.none(), leads, selfTerm, CoordinationSource.none());
+                LeadSeatSource.none(), leads, selfTerm, null);
     }
 
     /**
-     * As above, additionally reporting this daemon's own lead coordination state (CB-637, fleetd
-     * #361) when a coordinator is configured and its channel opened — see {@link #coordinatorView}
-     * for the shape. Omitted entirely when no coordinator is configured, so an ordinary fleet's
-     * output is unchanged.
+     * As above, additionally reporting this daemon's own lead coordination id (CB-637) when one is
+     * configured and its channel opened. There is no peer-discovery surface yet — a lead addresses a
+     * peer by a coord-id it was told — so this row exists to answer the one question the operator
+     * cannot answer any other way: what is MY coord-id, the one a peer must use to reach me. It is
+     * omitted entirely when no coordinator is configured, so an ordinary fleet's output is unchanged.
      *
-     * @param coordination this daemon's lead channel plus its declared peers, or
-     *                      {@link CoordinationSource#none()} when lead coordination is off
+     * @param selfCoordId this daemon's coord-id, or {@code null} when lead coordination is off
      */
     static McpSchema.CallToolResult listFleet(PeerLauncher workers, SessionManager sessions, MessageService messages,
                                                CapacitySource capacity, HealthCoverageSource healthCoverage,
                                                QuarantineSource quarantine, Map<String, String> leads, String selfTerm,
-                                               CoordinationSource coordination) {
+                                               String selfCoordId) {
         return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, OutageSource.none(),
-                LeadSeatSource.none(), leads, selfTerm, coordination);
+                LeadSeatSource.none(), leads, selfTerm, selfCoordId);
     }
 
     /** As above, plus fleetd #201 Unit 5 cool-off facts (see {@link OutageSource}). */
     static McpSchema.CallToolResult listFleet(PeerLauncher workers, SessionManager sessions, MessageService messages,
                                                CapacitySource capacity, HealthCoverageSource healthCoverage,
                                                QuarantineSource quarantine, OutageSource outage,
-                                               Map<String, String> leads, String selfTerm, CoordinationSource coordination) {
+                                               Map<String, String> leads, String selfTerm, String selfCoordId) {
         return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, outage,
-                LeadSeatSource.none(), leads, selfTerm, coordination);
+                LeadSeatSource.none(), leads, selfTerm, selfCoordId);
     }
 
-    /**
-     * As above, plus fleetd #176 lead-seat facts (see {@link LeadSeatSource}).
-     *
-     * <p>Assumes the caller is the primary — every wrapper overload above delegates here without
-     * carrying a caller identity, which is exactly right for them: they exist for call sites (and
-     * unit tests) that have no {@link Principal} to hand over, and this preserves their pre-#439
-     * behavior unchanged. The one call site that has a real caller ({@code fleet_list}'s MCP
-     * handler) uses {@link #listFleet(PeerLauncher, SessionManager, MessageService, CapacitySource,
-     * HealthCoverageSource, QuarantineSource, OutageSource, LeadSeatSource, Map, String,
-     * CoordinationSource, boolean)} instead, so it can pass the true answer.
-     */
+    /** As above, plus fleetd #176 lead-seat facts (see {@link LeadSeatSource}). */
     static McpSchema.CallToolResult listFleet(PeerLauncher workers, SessionManager sessions, MessageService messages,
                                                CapacitySource capacity, HealthCoverageSource healthCoverage,
                                                QuarantineSource quarantine, OutageSource outage,
                                                LeadSeatSource leadSeats, Map<String, String> leads, String selfTerm,
-                                               CoordinationSource coordination) {
-        return listFleet(workers, sessions, messages, capacity, healthCoverage, quarantine, outage,
-                leadSeats, leads, selfTerm, coordination, true);
-    }
-
-    /**
-     * As above, gated by the caller's role (fleetd #439). The {@code coordinator} row is
-     * lead-to-lead coordination state — coordination between orchestrators, not roster
-     * observation — so it is assembled and included only when {@code callerIsPrimary} is
-     * {@code true}. A worker or an architect gets a result with the {@code coordinator} key
-     * <strong>absent</strong>, never an empty or redacted one, and never pays the cost of
-     * {@link #coordinatorView} probing peer mailboxes for a row it will not receive.
-     *
-     * @param callerIsPrimary whether the {@code fleet_list} caller is the primary; only the MCP
-     *                        handler computes this from the real connection (see
-     *                        {@code Principal#isPrimary()}) — every other overload passes
-     *                        {@code true}
-     */
-    static McpSchema.CallToolResult listFleet(PeerLauncher workers, SessionManager sessions, MessageService messages,
-                                               CapacitySource capacity, HealthCoverageSource healthCoverage,
-                                               QuarantineSource quarantine, OutageSource outage,
-                                               LeadSeatSource leadSeats, Map<String, String> leads, String selfTerm,
-                                               CoordinationSource coordination, boolean callerIsPrimary) {
+                                               String selfCoordId) {
         try {
             Map<String, Agent> live = workers.list().stream()
                     .map(Agent.class::cast)
@@ -1418,14 +1127,8 @@ public final class FleetMcp {
             Map<String, Object> result = new LinkedHashMap<>();
             result.put("leads", leadRows); result.put("members", out);
             result.put("healthCoverage", healthCoverage.value().get());
-            // fleetd #439: coordinator/coordinatorView is lead-to-lead coordination state and must
-            // never reach a worker or an architect -- gate BEFORE assembling it, not after, so the
-            // key is absent rather than present-and-empty.
-            if (callerIsPrimary) {
-                Map<String, Object> coordinatorRow = coordinatorView(coordination);
-                if (coordinatorRow != null) {
-                    result.put("coordinator", coordinatorRow);
-                }
+            if (selfCoordId != null && !selfCoordId.isBlank()) {
+                result.put("coordinator", Map.of("selfId", selfCoordId, "configured", true));
             }
             if (capacity.available()) result.put("capacity", profiles.stream()
                     .map(profile -> capacityView(profile, capacity.liveCount(), capacity.maxLoad(), roster, messages,
@@ -1436,153 +1139,6 @@ public final class FleetMcp {
         }
     }
 
-    /**
-     * fleetd #361: the {@code coordinator} row — this daemon's own coord-id and mailbox state, the
-     * messages currently held for it, and the live reachability of every operator-declared peer.
-     * {@code null} (the row is then omitted entirely) when lead coordination is off, so an ordinary
-     * fleet's {@code fleet_list} output is byte-identical to before this feature existed.
-     *
-     * <p>Every peer/self mailbox look goes through {@link #probe}, which bounds each
-     * {@link LeadChannel#inspect} call to {@link #PEER_PROBE_TIMEOUT_MS} and never lets it throw —
-     * a coordination broker that is down or slow degrades this row toward "unreachable"/"unknown"
-     * counts, it can never make {@code fleet_list} itself slow or fail. {@code held} comes from
-     * {@link LeadChannel#peek}, a pure in-memory read with no broker round trip, so it is never
-     * subject to that bound.
-     *
-     * <p><strong>fleetd #421: {@code heldCount}/{@code heldDurable} fix the "pending: 0" trap.</strong>
-     * {@code mailbox.pending} counts only broker-<em>ready</em> messages; a held message is already
-     * an unacked delivery sitting with this consumer, so the normal, healthy state of a blocked lead
-     * is {@code "pending": 0} next to a non-empty {@code held[]} — which invites the false reading
-     * "these are only in memory, a restart will lose them". {@code heldCount} is the honest second
-     * number beside {@code pending} ({@code held.size()}, not left for the reader to count the
-     * array). {@code heldDurable} comes straight from {@link LeadChannel#heldDurable}, which the
-     * channel implementation derives from what it actually did when it declared and consumed its own
-     * queue (fleetd #440) — this method never asserts the fact itself.
-     */
-    private static Map<String, Object> coordinatorView(CoordinationSource coordination) {
-        LeadChannel channel = coordination.leadChannel();
-        if (channel == null) {
-            return null;
-        }
-        String selfId = channel.selfCoordId();
-        List<LeadMessage> held = channel.peek();
-        Map<String, Object> row = new LinkedHashMap<>();
-        row.put("selfId", selfId);
-        row.put("configured", true);
-        row.put("mailbox", mailboxView(probe(channel, selfId)));
-        row.put("heldCount", held.size());
-        row.put("heldDurable", channel.heldDurable());
-        row.put("held", held.stream().map(FleetMcp::heldView).toList());
-        row.put("peers", coordination.peers().stream().map(p -> peerView(channel, p)).toList());
-        return row;
-    }
-
-    /**
-     * fleetd #361: render a {@link LeadChannel.MailboxState} without ever presenting an unmeasured
-     * fact as a measured one. {@code status} is the tri-state itself — {@code "exists"},
-     * {@code "absent"} (the broker positively confirmed no such queue), or {@code "unknown"} (the
-     * probe could not determine either way: down, unreachable, or timed out). {@code pending}/
-     * {@code consumers} are included ONLY when {@code status == "exists"} — a reader must never see
-     * them default to {@code 0} for a mailbox this call never actually measured. This is the fix for
-     * the review finding that a collapsed {@code absent()} rendered a self-probe timeout as
-     * "pending: 0, consumers: 0", indistinguishable from an actually-empty, actually-unread mailbox.
-     */
-    private static Map<String, Object> mailboxView(LeadChannel.MailboxState state) {
-        Map<String, Object> row = new LinkedHashMap<>();
-        row.put("status", state.exists() ? "exists" : state.known() ? "absent" : "unknown");
-        if (state.exists()) {
-            row.put("pending", state.pending());
-            row.put("consumers", state.consumers());
-        }
-        return row;
-    }
-
-    /** One held-for-me message: enough to identify it and see roughly what it says, never the whole body. */
-    private static Map<String, Object> heldView(LeadMessage m) {
-        Map<String, Object> row = new LinkedHashMap<>();
-        row.put("msgId", m.msgId());
-        row.put("from", m.from());
-        row.put("preview", preview(m.content()));
-        return row;
-    }
-
-    /** Cap a held message's content to a short preview — {@code fleet_list} must never dump a full body. */
-    private static final int HELD_PREVIEW_MAX_CHARS = 80;
-
-    private static String preview(String content) {
-        if (content == null) {
-            return "";
-        }
-        return content.length() <= HELD_PREVIEW_MAX_CHARS
-                ? content
-                : content.substring(0, HELD_PREVIEW_MAX_CHARS) + "…";
-    }
-
-    /**
-     * One declared peer's row: its coord-id, then the same tri-state {@link #mailboxView} shape.
-     * Deliberately no boolean "reachable" field — that collapsed "confirmed gone" and "could not
-     * check" into the same {@code false}, which is exactly the review finding this row now avoids:
-     * an operator reading {@code status} can tell "fleet01 is down" (a {@code coordinator.selfId}
-     * nobody has ever run) apart from "my own broker is slow or unreachable right now".
-     */
-    private static Map<String, Object> peerView(LeadChannel channel, String coordId) {
-        Map<String, Object> row = new LinkedHashMap<>();
-        row.put("coordId", coordId);
-        row.putAll(mailboxView(probe(channel, coordId)));
-        return row;
-    }
-
-    /**
-     * fleetd #361: how long {@code fleet_list} waits on any single {@link LeadChannel#inspect} call
-     * before giving up on it — see {@link #probe}.
-     */
-    private static final long PEER_PROBE_TIMEOUT_MS = 1_500L;
-
-    /**
-     * Dedicated pool for {@link LeadChannel#inspect} calls so a slow one blocks only its own virtual
-     * thread, never the MCP request thread calling {@code fleet_list}. Not a <em>bounded</em> pool —
-     * {@code newThreadPerTaskExecutor} starts a fresh virtual thread per call with no cap on how many
-     * run at once; virtual threads make that cheap, not bounded. What actually keeps a hung probe
-     * from accumulating forever is the {@link Future#cancel} in {@link #probe}, not a pool limit.
-     */
-    private static final java.util.concurrent.ExecutorService PEER_PROBE_POOL =
-            java.util.concurrent.Executors.newThreadPerTaskExecutor(Thread.ofVirtual().name("fleet-peer-probe-", 0).factory());
-
-    /**
-     * fleetd #361: {@link LeadChannel#inspect}, bounded to {@link #PEER_PROBE_TIMEOUT_MS} and never
-     * allowed to throw or hang the caller — a coordination broker that is unreachable or slow
-     * degrades to {@link LeadChannel.MailboxState#unknown} (never {@code absent}: a timeout proves
-     * nothing about whether the mailbox exists) rather than making {@code fleet_list} slow or
-     * failing it. {@code inspect} itself is already specified to never throw, but this is the seam
-     * that also survives an implementation that does, or one that blocks indefinitely on a dead
-     * connection.
-     *
-     * <p><strong>A timeout cancels the orphaned task</strong> rather than abandoning it. Before this,
-     * {@code get(timeout)} on a hung {@code inspect} left the submitted task running forever on its
-     * own virtual thread, holding the AMQP channel it had already opened — against a broker that
-     * hangs rather than fails fast, every {@code fleet_list} call would orphan one more channel until
-     * the connection's channel-max (2047 by default) was exhausted, which would break {@link
-     * LeadChannel#publish} too. {@link Future#cancel(boolean) cancel(true)} interrupts the orphaned
-     * task's thread; {@link LeadMailbox#inspect} has no interruptible wait of its own to catch that,
-     * but the underlying AMQP RPC continuation does block on one, so the interrupt reaches it and the
-     * task's {@code finally} still closes the probe channel it opened rather than leaking it forever.
-     */
-    private static LeadChannel.MailboxState probe(LeadChannel channel, String coordId) {
-        return probe(channel, coordId, PEER_PROBE_TIMEOUT_MS);
-    }
-
-    /** As {@link #probe(LeadChannel, String)}, with an explicit timeout — a seam for tests. */
-    static LeadChannel.MailboxState probe(LeadChannel channel, String coordId, long timeoutMs) {
-        java.util.concurrent.Future<LeadChannel.MailboxState> future =
-                PEER_PROBE_POOL.submit(() -> channel.inspect(coordId));
-        try {
-            return future.get(timeoutMs, TimeUnit.MILLISECONDS);
-        } catch (Exception e) {
-            future.cancel(true); // best-effort: don't leave a hung probe (and its channel) running forever
-            return LeadChannel.MailboxState.unknown(coordId);
-        }
-    }
-
     /**
      * Capacity is advisory only. {@code reclaimable} says there is no bridge work, not that fleetd
      * may stop the member: the bridge has capacity facts but no work list, and choosing work needs
@@ -1592,35 +1148,15 @@ public final class FleetMcp {
     private static Map<String, Object> memberCapacityView(MemberSession session, Agent live,
                                                            MessageService messages, long nowNanos) {
         Map<String, Object> row = SessionManager.rosterView(session, live);
-        boolean reclaimable = reclaimable(session, messages);
+        boolean open = messages != null && messages.hasAcceptedDelivery(session.terminalId());
+        boolean inbox = messages != null && messages.hasInboxMessage(session.terminalId());
+        boolean reclaimable = (session.state() == MemberSession.State.READY || session.state() == MemberSession.State.DONE)
+                && !open && !inbox;
         row.put("reclaimable", reclaimable);
         row.put("idleForSeconds", reclaimable ? Math.max(0, (nowNanos - session.lastActivityAtNanos()) / 1_000_000_000L) : null);
         return row;
     }
 
-    /**
-     * The one definition of {@code reclaimable}: this member holds a spawn seat, and has no open
-     * bridge work, so stopping it gives the seat back. Both views in a single {@code fleet_list}
-     * response call it — the per-member flag in {@link #memberCapacityView} and the per-profile
-     * count in {@link #capacityView} — because two copies of this rule in one response is how the
-     * two numbers come to disagree.
-     *
-     * <p>fleetd #284: {@code BACKEND_ERROR} and {@code FAILED} are deliberately NOT reclaimable.
-     * The ticket asked for them to be, and that half of the ticket was wrong. Once
-     * {@code Fleetd.liveSessionCount} stopped counting a terminal session as live, that seat is
-     * ALREADY in {@code free}; counting it here too reports the same seat twice, and
-     * {@code free + reclaimable} then reads as more capacity than {@code maxLoad} allows. The dead
-     * session stays visible either way: its roster row still carries {@code state:
-     * "backend_error"} or {@code "failed"}, which is what tells the lead to stop it.
-     */
-    static boolean reclaimable(MemberSession session, MessageService messages) {
-        boolean holdsSeat = session.state() == MemberSession.State.READY
-                || session.state() == MemberSession.State.DONE;
-        return holdsSeat && (messages == null
-                || (!messages.hasAcceptedDelivery(session.terminalId())
-                        && !messages.hasInboxMessage(session.terminalId())));
-    }
-
     /**
      * CB-583: {@code free} alone cannot tell a lead "busy, will free up" from "refusing, and
      * nothing changes for N seconds" — those need different decisions. So a quarantined profile
@@ -1659,7 +1195,8 @@ public final class FleetMcp {
         int live = liveCount.apply(profile);
         int leadSeatCount = leadSeats.seatsFor().apply(profile);
         int reclaimable = (int) roster.stream().filter(s -> profile.equals(s.profile()))
-                .filter(s -> reclaimable(s, messages))
+                .filter(s -> (s.state() == MemberSession.State.READY || s.state() == MemberSession.State.DONE))
+                .filter(s -> messages == null || (!messages.hasAcceptedDelivery(s.terminalId()) && !messages.hasInboxMessage(s.terminalId())))
                 .count();
         Map<String, Object> row = new LinkedHashMap<>();
         row.put("profile", profile); row.put("maxLoad", cap); row.put("live", live);
@@ -1773,12 +1310,8 @@ public final class FleetMcp {
                                 + "routes your answer back into the same turn (omit for a normal delegation)"),
                         "coordId", stringProp("A peer LEAD's coordination id — delivers content to that "
                                 + "lead's durable mailbox on the shared coordination broker, which works "
-                                + "across hosts. Mutually exclusive with sessionId and turnId. Success means "
-                                + "the message is durably queued and confirmed by the broker, with a warning "
-                                + "if that mailbox has no consumers attached right now (queued, but nobody is "
-                                + "reading it yet) — it does not mean the peer's pane has seen it. Your own "
-                                + "coordId, this daemon's mailbox state, and every coordinator.peers entry's "
-                                + "live reachability are reported by fleet_list's coordinator row.")),
+                                + "across hosts. Mutually exclusive with sessionId and turnId. Your own "
+                                + "coordId is reported by fleet_list.")),
                         List.of("content")));
     }
 
@@ -1801,18 +1334,10 @@ public final class FleetMcp {
                 "Check an async delegation (a fleet_send with wait:false) by its ticket: "
                         + "pending, done (with the worker's reply), or failed. When target (a worker "
                         + "session id) is present instead of ticket, drain that worker's inbox of "
-                        + "replies delivered when no send was open. When coordId is present instead, "
-                        + "read (never consume) your own held lead-to-lead mail — primary-only.",
+                        + "replies delivered when no send was open.",
                 objectSchema(Map.of(
                         "ticket", stringProp("The ticket returned by fleet_send wait:false"),
-                        "target", stringProp("Worker session id to drain pending replies from (optional)"),
-                        "coordId", stringProp("Your own coord-id (fleet_list's coordinator.selfId) — "
-                                + "reads every message currently held[] for you in full, without "
-                                + "acking. Read twice, get the same bodies both times; fleet_list's "
-                                + "held[] still reports them afterward. Primary-only, and this can "
-                                + "read only YOUR OWN mailbox — there is no route to a peer's outbound "
-                                + "mail, so passing a peer's coordId here is refused rather than "
-                                + "silently returning the wrong thing (or nothing).")),
+                        "target", stringProp("Worker session id to drain pending replies from (optional)")),
                         List.of()));
     }
 
@@ -1822,10 +1347,7 @@ public final class FleetMcp {
                         + "has processed a reply and wants to confirm it, leaving other pending replies "
                         + "in the inbox for later drain.",
                 objectSchema(Map.of(
-                        "target", stringProp("Worker session id whose inbox to ack from. Must name a "
-                                + "reply actually queued for it — an id in no inbox, or a coord-id "
-                                + "(peer held mail, read with fleet_poll{coordId} instead), errors "
-                                + "rather than reporting a false success"),
+                        "target", stringProp("Worker session id whose inbox to ack from"),
                         "msgId", stringProp("The message id to acknowledge")),
                         List.of("target", "msgId")));
     }
@@ -1867,11 +1389,7 @@ public final class FleetMcp {
                 "List the configured worker profiles (backends) and which one fleet_spawn uses by "
                         + "default. A 'quarantined' map is present when a backend-exhausted refusal put "
                         + "a profile's credential on cooldown — fleet_spawn onto it is refused until "
-                        + "quarantinedForSeconds elapses; a profile sharing that credential is listed too. "
-                        + "'exhaustionDetectionArmed' reports, per profile, whether a usage-limit refusal "
-                        + "on it can EVER be classified and quarantined (its exhaustedPattern is "
-                        + "configured) — false means that profile's credential can never be quarantined "
-                        + "by this mechanism, however many usage-limit refusals it sees.",
+                        + "quarantinedForSeconds elapses; a profile sharing that credential is listed too.",
                 objectSchema(Map.of(), List.of()));
     }
 
@@ -1901,13 +1419,7 @@ public final class FleetMcp {
                         + "for a quarantined profile's credential (see fleet_profiles), whatever its "
                         + "maxLoad/live — with credentialId and quarantinedForSeconds naming the "
                         + "quarantine, so 'free: 0, busy' can be told apart from 'free: 0, refusing "
-                        + "for N seconds'. When lead-to-lead coordination is configured, a 'coordinator' "
-                        + "object reports this daemon's own coord-id ('selfId') and mailbox state "
-                        + "('mailbox': pending/consumers), the messages currently held for it ('held': "
-                        + "msgId/from/preview, never the full body), and one row per coordinator.peers "
-                        + "coord-id ('peers': coordId/reachable, plus pending/consumers when reachable) — "
-                        + "this is peer DISCOVERY for cross-host leads, distinct from the local 'leads' "
-                        + "array above. It is omitted entirely when no coordinator is configured.",
+                        + "for N seconds'.",
                 objectSchema(Map.of(), List.of()));
     }
 

fleetd/src/main/java/dev/ltms/fleet/mcp/LsofPeerPidLookup.java

@@ -41,14 +41,6 @@ public final class LsofPeerPidLookup implements PeerPidLookup {
             if (!p.waitFor(2, TimeUnit.SECONDS)) {
                 p.destroyForcibly();
             }
-            if (found < 0) {
-                // fleetd #317: this is the silent path — lsof ran clean and simply reported no
-                // matching process (e.g. queried before the OS socket table settles). Previously
-                // this logged nothing at all, which is exactly why the escalation went unnoticed;
-                // the exception path below already logs. A caller now refused because of this is
-                // still refused (never promoted) — this line only makes the refusal diagnosable.
-                log.debug("lsof peer-pid lookup for port {} found no matching process", port);
-            }
             return found;
         } catch (Exception e) {
             log.debug("lsof peer-pid lookup for port {} failed: {}", port, e.getMessage());

fleetd/src/main/java/dev/ltms/fleet/member/ClaudeCodeLauncher.java

@@ -540,66 +540,16 @@ public final class ClaudeCodeLauncher extends HerdrPeerLauncher {
      * itself is still lost, because there is no OS-level compare-and-swap on a plain file, only this
      * cooperative narrowing of the gap.
      *
-     * <p><b>fleetd #285: refuses under {@code memberHerdrSocket} rather than writing somewhere the
-     * member cannot read.</b> Under {@code memberHerdrSocket:} the member pane runs as a
-     * <em>different OS user with its own {@code $HOME}</em> — the same reason {@link
-     * #writeCharterFile} routes the role/reply charter under {@code worktreeRoot} instead of
-     * {@code java.io.tmpdir} and refuses the spawn when it cannot. This method has no equivalent
-     * relocation available: unlike the charter (fleetd's own content, free to place anywhere and
-     * hand to the peer via an argv flag), {@code .claude.json} is a file Claude Code looks up for
-     * ITSELF at a fixed location — {@code CLAUDE_CONFIG_DIR/.claude.json}, or else the member OS
-     * user's own {@code ~/.claude.json}, a path fleetd has no channel to learn. So when {@code
-     * configDir} is unset, there is no member-readable target to seed at all — writing the
-     * unqualified default would land in <em>fleetd's own</em> {@code ~/.claude.json} instead, the
-     * exact defect this fix closes, not a workable fallback. And even with {@code configDir} set,
-     * the file this method itself just wrote is {@code 0600} (owner-only — see {@link
-     * #copyPosixPermissionsIfPresent}), unreadable by a different-uid member unless shared with
-     * {@code worktreeGroup}, the same group {@link EnvAllowListScrub#shareWithGroup} already uses
-     * for the ZDOTDIR scrub (fleetd #213) and the charter file (fleetd #219/#222). So under {@code
-     * memberHerdrSocket} this method requires BOTH {@code configDir} and {@code worktreeGroup}
-     * before it ever touches a file, and refuses the spawn — naming exactly which one is missing —
-     * rather than silently corrupt fleetd's own home or hand the member an unreadable path. This
-     * mirrors {@link #writeCharterFile}'s "refuse, don't degrade" decision: a member spawned without
-     * a readable trust seed is not degraded, it sits on the interactive dialog forever and never
-     * calls {@code fleet_reply} — exactly the failure fleetd #149 exists to prevent, so trading it
-     * for "spawn something" is not worth it. When {@code configDir} and {@code worktreeGroup} are
-     * both present, the write proceeds exactly as below and the resulting file is additionally
-     * chgrp'd/chmod'd group-readable ({@code rw-r-----}) via {@link
-     * EnvAllowListScrub#shareFileWithGroup(Path, String)} so the member's OS user can actually
-     * open it — the
-     * directory itself (unlike {@code worktreeRoot} or the charter's per-spawn directory) is not
-     * fleetd-managed, so its own traversal permissions remain the operator's setup, same as they
-     * already must be for the member to read anything else fleetd points {@code CLAUDE_CONFIG_DIR}
-     * at. With {@code memberHerdrSocket} ABSENT (today's only live mode) every branch below is
-     * byte-identical to before this fix.
-     *
      * @param configDir the profile's {@code CLAUDE_CONFIG_DIR} ({@code cfg.configDir()}), or
-     *                  {@code null}/blank to target the default {@code ~/.claude.json} — refused
-     *                  outright when {@code memberHerdrSocket} is configured, see above
+     *                  {@code null}/blank to target the default {@code ~/.claude.json}
      * @param cwd       the spawn's resolved working directory — the exact key Claude Code will look
      *                  up for itself once it starts there
-     * @throws IllegalStateException when {@code memberHerdrSocket} is configured but {@code
-     *                                configDir} and/or {@code worktreeGroup} is not — the same
-     *                                refusal shape as {@link #writeCharterFile}
      */
-    private void seedTrustDialog(String configDir, String cwd) {
+    private static void seedTrustDialog(String configDir, String cwd) {
         if (!isProvisionedWorktree(cwd)) {
             return;
         }
         boolean unsetConfigDir = configDir == null || configDir.isBlank();
-        boolean memberHerdrSocket = memberHerdrSocketConfigured();
-        String group = memberHerdrSocket ? memberGroup() : null;
-        if (memberHerdrSocket && (unsetConfigDir || group == null)) {
-            throw new IllegalStateException("memberHerdrSocket is configured, so the workspace-trust "
-                    + "seed (.claude.json, which gates Claude Code's interactive trust dialog) must be "
-                    + "placed where the member's OS user can read it — configDir, shared via "
-                    + "worktreeGroup — but " + (unsetConfigDir ? "configDir" : "worktreeGroup")
-                    + " is not configured. Refusing to spawn rather than write fleetd's own default "
-                    + "'~/.claude.json' or hand the member a config file it cannot read: that member "
-                    + "would sit on the interactive trust dialog forever and never reach an "
-                    + "injectable state. Configure configDir on this profile and worktreeGroup on the "
-                    + "fleet to enable claude-code member spawns under memberHerdrSocket.");
-        }
         Path target = unsetConfigDir
                 ? Path.of(System.getProperty("user.home"), ".claude.json")
                 : Path.of(configDir, ".claude.json");
@@ -609,20 +559,18 @@ public final class ClaudeCodeLauncher extends HerdrPeerLauncher {
             // profile that simply forgot to set configDir gets no signal at all short of the
             // operator noticing their own file changing. Say so loudly, every time it is about to
             // happen, rather than only once ever: each occurrence is a live write to a real
-            // person's home config and deserves its own log line. (Reached only when
-            // memberHerdrSocket is absent — the block above already refused otherwise.)
+            // person's home config and deserves its own log line.
             log.warn("seedTrustDialog: profile has no configDir set, so the workspace-trust seed "
                     + "for cwd '{}' is about to write the operator's own default '{}' — set "
                     + "configDir on this profile to target a per-member config file instead",
                     cwd, target);
         }
         synchronized (TRUST_JSON_LOCK) {
-            boolean written = false;
             try {
                 if (target.getParent() != null) {
                     Files.createDirectories(target.getParent());
                 }
-                for (int attempt = 1; attempt <= MAX_TRUST_JSON_CAS_ATTEMPTS && !written; attempt++) {
+                for (int attempt = 1; attempt <= MAX_TRUST_JSON_CAS_ATTEMPTS; attempt++) {
                     byte[] before = Files.isRegularFile(target) ? Files.readAllBytes(target) : null;
                     ObjectNode root = parseTrustJsonOrEmpty(before);
                     JsonNode projectsNode = root.get("projects");
@@ -663,39 +611,26 @@ public final class ClaudeCodeLauncher extends HerdrPeerLauncher {
                         continue;
                     }
                     writeAtomically(target, newContent);
-                    written = true;
-                }
-                if (!written) {
-                    // fleetd #247: deliberately do NOT write here. A member that starts without the
-                    // seed still starts — it may hit the trust dialog fleetd #149 describes and fail
-                    // to reach an injectable state, but that failure is visible (herdr reports it,
-                    // the spawn-readiness gate times out) and recoverable (retry the spawn). Writing
-                    // our stale copy over whatever the other writer left would be silent and, if that
-                    // other writer is the operator's own live session, could destroy real
-                    // configuration — fail toward the recoverable outcome, not the silent one.
-                    log.warn("seedTrustDialog: gave up seeding workspace-trust for cwd '{}' into '{}' "
-                            + "after {} attempts — another writer (most plausibly the operator's own "
-                            + "live Claude Code sharing this file) kept changing it faster than we "
-                            + "could re-read it, so nothing was written; the member may show the "
-                            + "trust dialog instead", cwd, target, MAX_TRUST_JSON_CAS_ATTEMPTS);
+                    return;
                 }
+                // fleetd #247: deliberately do NOT write here. A member that starts without the
+                // seed still starts — it may hit the trust dialog fleetd #149 describes and fail to
+                // reach an injectable state, but that failure is visible (herdr reports it, the
+                // spawn-readiness gate times out) and recoverable (retry the spawn). Writing our
+                // stale copy over whatever the other writer left would be silent and, if that other
+                // writer is the operator's own live session, could destroy real configuration —
+                // fail toward the recoverable outcome, not the silent one.
+                log.warn("seedTrustDialog: gave up seeding workspace-trust for cwd '{}' into '{}' "
+                        + "after {} attempts — another writer (most plausibly the operator's own "
+                        + "live Claude Code sharing this file) kept changing it faster than we could "
+                        + "re-read it, so nothing was written; the member may show the trust dialog "
+                        + "instead", cwd, target, MAX_TRUST_JSON_CAS_ATTEMPTS);
             } catch (Exception e) {
                 log.debug("cannot seed workspace-trust entry for cwd '{}' into '{}'", cwd, target, e);
-                return;
-            }
-            // fleetd #285: the write above lands as fleetd's own OS user; under memberHerdrSocket
-            // that is NOT the member's OS user, so without this the member still cannot read the
-            // file it exists to seed — a silent readiness timeout with the write looking "done".
-            // Deliberately OUTSIDE the swallow-all catch above: a group that fails to resolve here
-            // means the seed is unreadable despite a successful write, which must fail as loudly as
-            // writeCharterFile's own EnvAllowListScrub.shareWithGroup call already does.
-            if (written && memberHerdrSocket) {
-                EnvAllowListScrub.shareFileWithGroup(target, group);
             }
         }
     }
 
-
     /** Bound on {@link #seedTrustDialog}'s fleetd #247 compare-and-swap retry loop. */
     private static final int MAX_TRUST_JSON_CAS_ATTEMPTS = 5;
 

fleetd/src/main/java/dev/ltms/fleet/member/CompositePeerLauncher.java

@@ -14,7 +14,6 @@ import dev.ltms.fleet.placement.BackendOutagePolicy;
 import dev.ltms.fleet.placement.BackendQuarantine;
 import dev.ltms.fleet.placement.PlacementCandidate;
 import dev.ltms.fleet.placement.PlacementContext;
-import dev.ltms.fleet.placement.PlacementDecision;
 import dev.ltms.fleet.placement.PlacementException;
 import dev.ltms.fleet.placement.PlacementPolicies;
 import dev.ltms.fleet.placement.PlacementPolicy;
@@ -91,19 +90,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
     private final Supplier<Map<String, FleetConfig.Profile>> profileConfigs;
     private final Supplier<PlacementPolicy> placementPolicy;
 
-    /**
-     * fleetd #422: the central model allow-list's on/off state, read live per spawn — same reason
-     * {@link #profileConfigs} is a supplier rather than a captured map (see the class doc above and
-     * {@link #enforceModelEnabled}). A caller with no {@code models:} block to read from (the
-     * simpler, map-based constructors used throughout this class's own tests) wires this to a
-     * constant {@code null}, which {@link #models0} treats as "nothing configured, gate never
-     * fires" — the pre-#422 behaviour.
-     */
-    private final Supplier<FleetConfig.Models> models;
-
-    /** The value {@link #models0} normalizes a {@code null} supplier result to. */
-    private static final FleetConfig.Models NO_MODELS_CONFIGURED = new FleetConfig.Models(List.of());
-
     /** CB-578 stage B: credential cooldown, checked before an explicit spawn and filtered into placement. */
     private final BackendQuarantine quarantine;
 
@@ -219,44 +205,12 @@ public final class CompositePeerLauncher implements PeerLauncher {
                                  FleetConfig.Fleet fleet,
                                  BackendQuarantine quarantine,
                                  BackendOutagePolicy outagePolicy) {
-        // No models: block to read from a plain profiles Map — fleetd #422's gate is wired to a
-        // constant null (see enforceModelEnabled/models0), the pre-#422 behaviour for every caller
-        // of this overload. Use the 9-arg overload below to test the gate against a LIVE supplier.
-        this(delegates, defaultProfile, profileConfigs, placementPolicy, liveCount, fleet, quarantine,
-                outagePolicy, constant(null));
-    }
-
-    /**
-     * As above, plus a LIVE model-gate source (fleetd #422). The 8-arg overload above wires
-     * {@code models} to a constant {@code null} because it has only a static {@code Map<String,
-     * Profile>}, never a full {@code FleetConfig}, to read one from; this overload exists so a test
-     * can prove {@link #enforceModelEnabled} and its candidate filter re-read {@link
-     * FleetConfig.Models} on every call rather than a value captured once at construction — the
-     * exact distinction fleetd #422 exists to get right (see the class doc's CB-559 note on {@link
-     * #profileConfigs}, which this follows). Production wiring uses the
-     * {@code Supplier<FleetConfig>} constructor below instead, which already threads a live
-     * {@code config.get().models()} through.
-     *
-     * @param models required — pass a supplier returning {@code null} for a caller that has no
-     *               {@code models:} block to gate against, never a defaulting overload (the same
-     *               "explicit opt-out, never a silent default" rule {@code quarantine}/
-     *               {@code outagePolicy} already follow).
-     */
-    public CompositePeerLauncher(List<HerdrPeerLauncher> delegates,
-                                 String defaultProfile,
-                                 Map<String, FleetConfig.Profile> profileConfigs,
-                                 PlacementPolicy placementPolicy,
-                                 Function<String, Integer> liveCount,
-                                 FleetConfig.Fleet fleet,
-                                 BackendQuarantine quarantine,
-                                 BackendOutagePolicy outagePolicy,
-                                 Supplier<FleetConfig.Models> models) {
         // LinkedHashMap, not Map.copyOf: candidates() promises definition order and the weighted
         // policy breaks exact-weight ties on it, so a salted iteration order would make placement
         // differ from one JVM run to the next.
         this(delegates, defaultProfile,
                 constant(Collections.unmodifiableMap(new LinkedHashMap<>(profileConfigs))),
-                constant(placementPolicy), liveCount, constant(fleet), quarantine, outagePolicy, models);
+                constant(placementPolicy), liveCount, constant(fleet), quarantine, outagePolicy);
     }
 
     /**
@@ -296,10 +250,7 @@ public final class CompositePeerLauncher implements PeerLauncher {
                 liveCount,
                 () -> config.get().fleet(),
                 quarantine,
-                outagePolicy,
-                // fleetd #422: read live, same as profiles/placement/fleet above — a models.allow
-                // edit (on/off or otherwise) is visible to the very next spawn, no restart needed.
-                () -> config.get().models());
+                outagePolicy);
     }
 
     /** The all-suppliers form every other constructor funnels into. */
@@ -310,8 +261,7 @@ public final class CompositePeerLauncher implements PeerLauncher {
                                   Function<String, Integer> liveCount,
                                   Supplier<FleetConfig.Fleet> fleet,
                                   BackendQuarantine quarantine,
-                                  BackendOutagePolicy outagePolicy,
-                                  Supplier<FleetConfig.Models> models) {
+                                  BackendOutagePolicy outagePolicy) {
         this.fleet = fleet;
         this.quarantine = Objects.requireNonNull(quarantine, "quarantine");
         this.outagePolicy = Objects.requireNonNull(outagePolicy, "outagePolicy");
@@ -323,7 +273,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
         this.profileConfigs = profileConfigs;
         this.placementPolicy = placementPolicy;
         this.liveCount = liveCount;
-        this.models = Objects.requireNonNull(models, "models");
         Map<String, HerdrPeerLauncher> index = new LinkedHashMap<>();
         for (HerdrPeerLauncher d : this.delegates) {
             for (String profile : d.profiles()) {
@@ -354,16 +303,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
         return m == null ? Map.of() : m;
     }
 
-    /**
-     * The currently-configured {@code models:} block, never null (fleetd #422). Read fresh on
-     * every call, the same reason {@link #profiles0} is — a config reload's on/off edit must reach
-     * the very next spawn.
-     */
-    private FleetConfig.Models models0() {
-        FleetConfig.Models m = models.get();
-        return m == null ? NO_MODELS_CONFIGURED : m;
-    }
-
     /** The adapter owning {@code profileName} (null/blank → the default). Throws on an unknown profile. */
     private HerdrPeerLauncher route(String profileName) {
         String resolved = (profileName == null || profileName.isBlank()) ? defaultProfile : profileName;
@@ -393,7 +332,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
             enforceNotQuarantined(requestedProfile);
             enforceNotCoolingOff(requestedProfile);
             enforceMaxLoad(requestedProfile);
-            enforceModelEnabled(requestedProfile);
             PeerHandle handle = d.spawn(req);
             spawnedBy.put(handle.id(), d);
             return handle;
@@ -403,10 +341,18 @@ public final class CompositePeerLauncher implements PeerLauncher {
         // the whole profile list. An EXPLICIT profile (above) is left alone on purpose — it is the
         // operator overriding, and refusing it would break `fleet_spawn{profile:"opus"}`, which
         // carries no role and so would be judged against the dev pool it was never meant for.
+        List<PlacementCandidate> candidates = candidates(req.role());
+        String roleDefault = defaultProfileFor(req.role());
         Set<String> unreachable = new HashSet<>();
-        PlacementContext ctx = placementContextFor(req.role(), unreachable);
+        // CB-578 stage B: computed once up front — a quarantine's expiry cannot pass within one spawn
+        // call, so re-deriving it per retry would only cost work, never change the answer.
+        Set<String> quarantined = quarantinedProfiles(candidates);
+        // fleetd #201 Unit 5: a distinct set from quarantined — see PlacementContext.coolingOff.
+        Set<String> coolingOff = coolingOffProfiles(candidates);
+        PlacementContext ctx = new PlacementContext(roleDefault, candidates, liveCount, unreachable,
+                quarantined, coolingOff);
 
-        int maxAttempts = ctx.candidates().isEmpty() ? 1 : ctx.candidates().size();
+        int maxAttempts = candidates.isEmpty() ? 1 : candidates.size();
         for (int attempt = 0; attempt < maxAttempts; attempt++) {
             // Deliberately uncaught: when no candidate is left (all at cap, or all unreachable) the
             // policy already throws a clear message. Catching it to rethrow a generic
@@ -423,7 +369,8 @@ public final class CompositePeerLauncher implements PeerLauncher {
             // CB-547a: route the chosen profile but keep the caller's session identity — dropping it
             // here would silently sever the resume handle on every policy-routed spawn. CB-557: the
             // role rides along for the same reason, or a routed spawn would be labelled as a dev.
-            SpawnRequest routedReq = req.withProfile(chosen.profile());
+            SpawnRequest routedReq = new SpawnRequest(chosen.profile(), req.requestedCwd(), req.callerCwd(),
+                    req.sessionName(), req.resumeSessionId(), req.role());
             try {
                 PeerHandle handle = d.spawn(routedReq);
                 spawnedBy.put(handle.id(), d);
@@ -433,16 +380,14 @@ public final class CompositePeerLauncher implements PeerLauncher {
                         chosen.profile(), e.getMessage());
                 unreachable.add(chosen.profile());
                 // Update the context for the next selection so the policy excludes this profile.
-                ctx = placementContextFor(req.role(), unreachable);
+                ctx = new PlacementContext(roleDefault, candidates, liveCount, unreachable,
+                        quarantined, coolingOff);
             }
         }
 
-        // unreachable.size() counts DISTINCT profiles, not attempts (a HashSet dedupes a profile
-        // added twice) — say "distinct" so the count matches the sentence and the profile list that
-        // follows, rather than reading as a count of attempts made (fleetd #315).
         throw new PeerUnreachableException(
                 "no reachable worker profile available after trying " + unreachable.size()
-                        + " distinct candidate(s): " + String.join(", ", unreachable));
+                        + " candidate(s): " + String.join(", ", unreachable));
     }
 
     /**
@@ -545,49 +490,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
         }
     }
 
-    /**
-     * Refuse an explicit-profile spawn whose {@code model:} the operator has turned off in the
-     * central {@code models.allow:} list (fleetd #422). Deliberately worded apart from {@link
-     * #enforceNotQuarantined} and {@link #enforceNotCoolingOff}: those two report a BACKEND-reported
-     * outage (exhaustion, repeated errors); this one reports an OPERATOR decision, so the message
-     * says "turned off" and names the model, never "quarantined" or "cooling off". A FOURTH,
-     * independent reason to refuse a spawn — never layered onto {@code BackendQuarantine} or {@code
-     * BackendOutagePolicy}, which would misattribute an operator's own choice to the backend.
-     *
-     * <p>Reads {@link #models0()} fresh on every call — the same liveness {@link #profiles0()}
-     * already has — so flipping {@code enabled: false} and reloading takes effect on the very next
-     * spawn, no restart (criterion 4). A profile naming no model, or a model absent from {@code
-     * models.allow:} entirely (nothing to gate against), is never refused here.
-     *
-     * @throws PlacementException naming the model and the profile, distinct from quarantine/cool-off
-     */
-    private void enforceModelEnabled(String profile) {
-        FleetConfig.Profile cfg = profiles0().get(profile);
-        String model = (cfg == null) ? null : cfg.model();
-        if (model == null) {
-            return;
-        }
-        if (models0().offIds().contains(model)) {
-            throw new PlacementException("worker profile '" + profile + "' names model '" + model
-                    + "', which the operator has turned off in models.allow — refusing spawn");
-        }
-    }
-
-    /** The subset of {@code candidates} whose {@code model:} is currently turned off (fleetd #422). */
-    private Set<String> modelOffProfiles(List<PlacementCandidate> candidates) {
-        Set<String> off = models0().offIds();
-        if (off.isEmpty()) {
-            return Set.of();
-        }
-        return candidates.stream()
-                .map(PlacementCandidate::profile)
-                .filter(p -> {
-                    FleetConfig.Profile cfg = profiles0().get(p);
-                    return cfg != null && cfg.model() != null && off.contains(cfg.model());
-                })
-                .collect(Collectors.toSet());
-    }
-
     /**
      * The profile names {@code role} may be placed on, in definition order.
      *
@@ -604,23 +506,8 @@ public final class CompositePeerLauncher implements PeerLauncher {
         return known.isEmpty() ? List.copyOf(configured.keySet()) : known;
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * <p>Live: reads {@link #poolFor}, which reads {@link #profileConfigs} and {@link #fleet} fresh
-     * on every call, so a config reload is visible without a restart (fleetd #425) — unlike {@link
-     * #defaultProfile}, the field captured once at construction, which this falls back to only when
-     * {@link #poolFor} has nothing to offer at all (no profiles configured for this composite).
-     *
-     * <p>Exact only under the {@code fixed} placement policy — the one that reads this value
-     * ({@code FixedPlacementPolicy}, package-private, hence not linked) as its first, preferred
-     * candidate. {@code weighted}/{@code round-robin} placement can choose a different candidate
-     * from {@code role}'s pool even on the very first spawn; this method does not simulate that
-     * choice, matching what the {@code defaultProfile:}-derived reporting this replaces has always
-     * done.
-     */
-    @Override
-    public String defaultProfileFor(MemberRole role) {
+    /** The profile an unqualified spawn for {@code role} falls back to under {@code fixed} placement. */
+    private String defaultProfileFor(MemberRole role) {
         List<String> pool = poolFor(role);
         return pool.isEmpty() ? defaultProfile : pool.getFirst();
     }
@@ -637,142 +524,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
         return out;
     }
 
-    /**
-     * Build the {@link PlacementContext} an unqualified spawn of {@code role} would be judged
-     * against right now — the single source both {@link #spawn} and {@link #place} read, so the two
-     * can never disagree about which conditions (quarantine, cool-off, model-off) apply to which
-     * candidate (fleetd #425 rework: round 1 duplicated this into a second, blind resolver —
-     * {@link #defaultProfileFor} — which is why it regressed; round 2 found that even a single
-     * shared resolver is not enough on its own if the CALLER re-resolves through an explicit
-     * profile afterwards — see {@link PlacementDecision}).
-     *
-     * @param unreachable the caller's mutable unreachable set; {@link #spawn} grows this across
-     *                    retries and rebuilds the context from it, {@link #place} passes a fresh
-     *                    empty one since it never retries
-     */
-    private PlacementContext placementContextFor(MemberRole role, Set<String> unreachable) {
-        List<PlacementCandidate> candidates = candidates(role);
-        String roleDefault = defaultProfileFor(role);
-        // CB-578 stage B: computed once up front — a quarantine's expiry cannot pass within one spawn
-        // call, so re-deriving it per retry would only cost work, never change the answer.
-        Set<String> quarantined = quarantinedProfiles(candidates);
-        // fleetd #201 Unit 5: a distinct set from quarantined — see PlacementContext.coolingOff.
-        Set<String> coolingOff = coolingOffProfiles(candidates);
-        // fleetd #422: read live per spawn, same as quarantined/coolingOff above — a config reload
-        // that flips a model's enabled state is visible to the very next unqualified spawn.
-        Set<String> modelOff = modelOffProfiles(candidates);
-        return new PlacementContext(roleDefault, candidates, liveCount, unreachable,
-                quarantined, coolingOff, modelOff);
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>fleetd #425 rework, round 2: runs the exact same selection {@link #spawn} uses for a
-     * blank-profile request — {@link #placementContextFor} plus one {@link PlacementPolicy#select}
-     * — rather than {@link #defaultProfileFor}'s blind "pool's first entry", so a quarantined,
-     * cooling-off, or model-off pool-first candidate is routed around here exactly as it would be
-     * by a real spawn. Unlike {@link #spawn}, this never retries on {@link
-     * PeerUnreachableException}: there is no spawn attempt to fail, so "unreachable" never grows
-     * past the empty set it starts with, and a single {@link PlacementPolicy#select} call already
-     * reflects the live quarantine/cool-off/model-off state.
-     *
-     * <p>Deliberately does <em>not</em> apply {@link #enforceMaxLoad} (or any of the other three
-     * {@code enforce*} checks): those belong to {@link #spawn}'s EXPLICIT-profile branch, the
-     * operator-override path, and this method answers a different question — "where would an
-     * UNQUALIFIED spawn land". That is not the same as {@code select} ignoring these conditions —
-     * every condition {@code select} filters on (quarantine, cooling off, {@code maxLoad} under
-     * every placement policy including the default {@code fixed}, since fleetd #435, model-off,
-     * unreachable, weight-0) is already reflected in the {@link PlacementDecision} this method
-     * returns, because {@code select} walked past every excluded candidate to find it. What this
-     * method's caller must not do is take that resolved name and hand it back to {@link
-     * #spawn(SpawnRequest)} as an explicit profile: the explicit-profile branch treats the same
-     * exclusion conditions as a reason to REFUSE, where {@code select} had already treated them as
-     * a reason to fall through — round 1 of this fix did exactly that, turning a fall-through this
-     * method had already resolved around into a refusal one call later. Round 2 fixes that at the
-     * caller: {@link #spawn(SpawnRequest, PlacementDecision)} carries this exact decision to the
-     * spawn without re-resolving or re-checking it, through the same routing path {@code select}
-     * itself was consulted from.
-     *
-     * @throws PlacementException if no candidate in {@code role}'s pool is currently placeable
-     *                            (mirrors what an actual unqualified spawn would throw)
-     */
-    @Override
-    public PlacementDecision place(MemberRole role) {
-        PlacementContext ctx = placementContextFor(role, new HashSet<>());
-        return new PlacementDecision(placementPolicy.get().select(ctx).profile());
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>Delegates to {@link #place}, so the two can never disagree about the answer for the same
-     * {@code role} at the same instant — kept as a convenience for a caller that only wants the
-     * resolved name (a status report, a log line), never for a caller that will act on it by
-     * spawning: that caller must hold the {@link PlacementDecision} itself and pass it to {@link
-     * #spawn(SpawnRequest, PlacementDecision)} — see {@link PlacementDecision}'s javadoc for why
-     * resolving here and spawning separately, with the name fed back in as an explicit profile,
-     * regressed fleetd #425 twice.
-     */
-    @Override
-    public String routedProfileFor(MemberRole role) {
-        return place(role).profile();
-    }
-
-    /**
-     * {@inheritDoc}
-     *
-     * <p>Routes {@code decision.profile()} directly to its owning delegate — the identical
-     * {@code d.spawn(routedReq)} call {@link #spawn(SpawnRequest)}'s blank-profile branch makes for
-     * its first pick — WITHOUT re-running {@link #enforceNotQuarantined}, {@link
-     * #enforceNotCoolingOff}, {@link #enforceMaxLoad}, or {@link #enforceModelEnabled}: those are
-     * the EXPLICIT-profile branch's checks, and {@code decision} did not come from an operator
-     * naming a profile — it came from {@link #place}, which already applied whichever of these
-     * conditions {@link PlacementPolicy#select} actually filters on (fleetd #425 rework, round 2).
-     *
-     * <p>The two branches disagree on purpose about what an excluded profile means, and that
-     * disagreement is not what this method removes. The blank-profile routing branch (and
-     * {@link #place}) treats a quarantined/cooling-off/at-cap/model-off/unreachable/weight-0 profile
-     * as a reason to fall through to the next candidate; the EXPLICIT-profile branch treats naming
-     * that same profile as a reason to refuse outright — someone who names a profile should get a
-     * refusal, not a silent substitution onto a different backend. That is still correct after
-     * fleetd #435. What round 1 got wrong, and what this method exists to stop happening again, is
-     * turning a fall-through into a refusal by accident: resolving a name via {@link #place} and
-     * then handing that same name back to {@link #spawn(SpawnRequest)} as an explicit profile takes
-     * the refusing branch on a decision the routing branch had already approved by falling through
-     * past everything else.
-     *
-     * <p>Before fleetd #435, this exact accident was reachable through {@code maxLoad} specifically:
-     * {@code FixedPlacementPolicy} — the default policy — did not evaluate {@code maxLoad} at all
-     * for automatic selection, so {@link #place} could approve an at-cap profile that {@link
-     * #enforceMaxLoad} would then refuse one call later. fleetd #435 closed that: {@code
-     * FixedPlacementPolicy} now walks past an at-cap candidate exactly like {@code weighted}/
-     * {@code round-robin} already did, so {@link #place} can no longer return one, and this specific
-     * failure — an approved placement dying at {@code enforceMaxLoad} — cannot happen any more.
-     * What this method still buys, now that {@code maxLoad} can no longer cause it: it never
-     * re-evaluates a condition {@link #place} already decided, and it closes the window between
-     * that decision and the spawn in which the underlying state (another spawn landing on the same
-     * profile, a config reload) could otherwise move and make a stale explicit re-check wrong.
-     *
-     * <p>Deliberately does not retry on {@link PeerUnreachableException} across candidates the way
-     * {@link #spawn(SpawnRequest)}'s blank-profile branch does: retrying here would silently
-     * re-place the caller onto a different profile than the one {@code decision} named, behind the
-     * back of a caller that may already have provisioned something (a worktree's {@code repoRoot},
-     * parity overlay) specifically for that name. A caller that wants the composite's own failover
-     * should call {@link #spawn(SpawnRequest)} with a blank profile directly, not resolve through
-     * {@link #place} first. Losing that retry on a resolve-then-spawn path is an accepted, unrelated
-     * cost — see {@code SessionManager.acquireWithWorktree}'s own comment on it — never widened by
-     * this round to include {@code maxLoad}, which is what round 1 actually lost.
-     */
-    @Override
-    public PeerHandle spawn(SpawnRequest req, PlacementDecision decision) {
-        HerdrPeerLauncher d = route(decision.profile());
-        SpawnRequest routedReq = req.withProfile(decision.profile());
-        PeerHandle handle = d.spawn(routedReq);
-        spawnedBy.put(handle.id(), d);
-        return handle;
-    }
-
     @Override
     public String effectiveCwd(SpawnRequest req) {
         return route(req.profileName()).effectiveCwd(req);
@@ -783,32 +534,6 @@ public final class CompositePeerLauncher implements PeerLauncher {
         return route(profileName).parityOverlay(profileName);
     }
 
-    /**
-     * fleetd #422 follow-up: the single live read that answers both "is the models.allow: gate
-     * armed" and "which models are off", off the exact same accessor ({@link #models0()}) {@link
-     * #enforceModelEnabled} and {@link #modelOffProfiles} read — so {@code fleet_profiles}/{@code
-     * GET /profiles} (via {@link PeerLauncher#disabledModels()}, which now delegates here) can
-     * never report a different answer than the gate enforces (the fleetd #404 lesson), and the
-     * startup log line built from this can never disagree with either.
-     *
-     * <p>{@link #models0()} itself normalizes a {@code null} {@link #models} read to the shared
-     * {@link #NO_MODELS_CONFIGURED} sentinel — deliberately the one object no config-supplied
-     * {@code Models} instance can ever be identical to, since it is private to this class — so
-     * comparing by reference here recovers exactly the fact {@code models0()}'s normalization
-     * would otherwise erase: whether the live source was {@code null} (no {@code models:} block,
-     * armed = false) or a real, config-supplied block (armed = true, even one whose {@code allow:}
-     * is itself empty or absent — {@link FleetConfig.Models}'s "absent or empty allow: is off"
-     * wording governs config-load validation, a distinct question from whether this gate is armed
-     * for reporting).
-     */
-    @Override
-    public PeerLauncher.ModelGateState modelGateState() {
-        FleetConfig.Models m = models0();
-        return m == NO_MODELS_CONFIGURED
-                ? PeerLauncher.ModelGateState.notConfigured()
-                : PeerLauncher.ModelGateState.armed(m.offIds());
-    }
-
     @Override
     public void stop(String id) {
         HerdrPeerLauncher d = spawnedBy.get(id);
@@ -920,21 +645,9 @@ public final class CompositePeerLauncher implements PeerLauncher {
         return byProfile.keySet();
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * <p>fleetd #425: reports the <em>live</em> {@code dev} pool's first entry — the same value
-     * {@link #defaultProfileFor} computes for {@link MemberRole#DEV} — not the {@link
-     * #defaultProfile} field captured at construction. An unqualified {@code fleet_spawn} defaults
-     * to {@code MemberRole#DEV} (see {@link dev.ltms.fleet.peer.SpawnRequest}), so "the dev pool's
-     * live first entry" is exactly the profile such a spawn actually lands on right now — the
-     * question {@code fleet_profiles}' {@code "default"} field exists to answer. The frozen field is
-     * a role-agnostic fallback used only when {@link #poolFor} has nothing to report at all (no
-     * profiles configured), which {@link #defaultProfileFor} already handles.
-     */
     @Override
     public String defaultProfile() {
-        return defaultProfileFor(MemberRole.DEV);
+        return defaultProfile;
     }
 
     /**

fleetd/src/main/java/dev/ltms/fleet/member/EnvAllowListScrub.java

@@ -13,7 +13,6 @@ import java.nio.file.attribute.PosixFilePermissions;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.stream.Stream;
@@ -29,85 +28,33 @@ import java.util.stream.Stream;
  * control lacked: herdr applies that overlay BEFORE the shell starts, so any sourced file can undo
  * it — and did.
  *
- * <p><b>zsh reads its four startup files under three different conditions, so no single file is
- * guaranteed to run — the scrub has to cover the gap between them, not just the platforms.</b> zsh
+ * <p><b>Which file is last depends on the platform, so the scrub runs from two of them.</b> zsh
  * reads {@code .zshenv} always, {@code .zprofile} and {@code .zlogin} only for a LOGIN shell, and
- * {@code .zshrc} only for an INTERACTIVE one. A pane shell that is at least one of login or
- * interactive is covered by sourcing the scrub from {@code .zshrc} and {@code .zlogin} (below), but
- * a pane shell that is NEITHER reads only {@code .zshenv} and stops — fleetd #388, measured: a herdr
- * pane can be neither login nor interactive, and such a pane read {@code .zshenv}, never reached
- * {@code scrub.zsh}, and left no report at all. A bare {@code argv[0]} of {@code /usr/bin/zsh}
- * proves the shell is NOT a login shell; it says nothing about whether it is interactive, so it
- * must never be read as "therefore interactive" — that wrong inference is what let #388 ship.
+ * {@code .zshrc} only for an INTERACTIVE one. herdr does not open the same kind of shell
+ * everywhere — measured on herdr 0.8.0: macOS panes run {@code -zsh} (login, so {@code .zlogin}
+ * runs), Linux panes run a plain {@code /usr/bin/zsh} (interactive but NOT login, so
+ * {@code .zlogin} never runs at all). A scrub in {@code .zlogin} alone is therefore a control that
+ * silently does nothing on Linux — the exact failure this class exists to remove, one platform
+ * over.
  *
- * <p>So {@code .zshenv} carries a THIRD pass, guarded by the exact condition that defines the gap:
- * {@code [[ ! -o login && ! -o interactive ]]}. That guard is why this pass cannot double-scrub a
- * pane that {@code .zshrc} or {@code .zlogin} will also cover — one of {@code -o login}/
- * {@code -o interactive} is always true there, so the {@code .zshenv} pass never fires for them, and
- * their own unconditional sourcing is untouched. The guard also carries a sentinel
- * ({@value #SCRUB_SENTINEL}) so it fires once per PANE and not once per PROCESS: {@code .zshenv} is
- * read by every zsh a member's own tooling forks (a plain {@code zsh -c '...'} for a single
- * command is itself neither login nor interactive), and those children inherit variables their
- * parent deliberately set for them (git hooks get {@code GIT_DIR}, a venv gets
- * {@code VIRTUAL_ENV}, a build tool gets {@code NODE_OPTIONS} or {@code JAVA_TOOL_OPTIONS}).
- * Re-scrubbing every such child would blank all of that, and would also make the pane's own
- * {@code scrub-report.txt} — rewritten on every pass — describe whichever child exited last
- * instead of the pane. The sentinel is exported only AFTER {@code scrub.zsh} runs, so the pass
- * that sets it never sees it and cannot blank it; it must also be on the scrub's own allow-list
- * (see {@link #generate(Path, Set)}) so a later pass, in the same pane, cannot blank it back to
- * empty — an exported-but-empty sentinel reads as unset to the {@code -z} guard and would silently
- * re-enable scrubbing for every subsequent child of that pane.
- *
- * <p>So all three of {@code .zshenv} (gap only, guarded), {@code .zshrc}, and {@code .zlogin}
- * source the same generated {@code scrub.zsh} after sourcing their {@code $HOME} counterpart. A
- * login-and-interactive pane runs the {@code .zshrc} and {@code .zlogin} passes, and the second is
- * deliberate rather than merely harmless — it re-scrubs anything the operator's own
- * {@code ~/.zlogin} exported after {@code .zshrc} had finished. A pane that is neither runs only the
- * {@code .zshenv} pass. Re-running is idempotent: a name already blank is blanked again, and the
- * report is rewritten with the same counts.
+ * <p>So both {@code .zshrc} and {@code .zlogin} source the same generated {@code scrub.zsh} after
+ * sourcing their {@code $HOME} counterpart. On Linux only the first fires; on macOS both do, and
+ * the second pass is deliberate rather than merely harmless — it re-scrubs anything the operator's
+ * own {@code ~/.zlogin} exported after {@code .zshrc} had finished. Re-running is idempotent: a
+ * name already blank is blanked again, and the report is rewritten with the same counts.
  *
  * <p>Each generated file sources its {@code $HOME} counterpart FIRST, so {@code PATH} and every
- * toolchain binary still resolve exactly as the operator configured them; only afterwards does the
- * scrub run: every EXPORTED variable not on the derived allow-list is re-exported
+ * toolchain binary still resolve exactly as the operator configured them; only afterwards does
+ * {@code .zlogin} run the scrub: every EXPORTED variable not on the derived allow-list is re-exported
  * blank. Blank, not credential-shaped-pattern-filtered: a pattern list ({@code *TOKEN*}, …) is an
  * enumeration and misses what it did not think of — a username is the other half of a credential and
  * is shaped like none. Credential-SHAPED names among the blanked set go to the WARN log only,
  * never to the control.
  *
  * <p>The scrub also writes {@code scrub-report.txt} into its own directory: one {@code allowed N of
- * M failed F} line (N = exports left untouched, M = exports present when the scrub ran, F = names
- * the scrub attempted to blank but could not), then the NAMES — blanked ones bare, unblankable ones
- * {@code !}-prefixed — never values. The launcher reads this back at teardown and logs it, because a
- * blocked count next to an unknown denominator is not a finding.
- *
- * <p><b>fleetd #394:</b> plain {@code export "$n="} is a FATAL error for a zsh read-only or special
- * parameter (for example {@code UID}) — it aborts the whole sourced file, so every name still to
- * come is never blanked and the report above is never written at all. The blanking loop instead
- * routes each attempt through {@code eval}, which contains that error to the single iteration: the
- * loop always finishes, and a name that could not be blanked is counted as {@code failed} and
- * listed {@code !}-prefixed rather than silently disappearing. This is deliberately not a skip-list
- * of known-bad names — every enumerated name is still attempted, so a name nobody has thought of
- * yet still gets tried and, if it fails, still gets counted.
- *
- * <p>The blanking loop also re-asserts, on its own, the same {@code [A-Za-z_][A-Za-z0-9_]*} shape
- * check the enumeration loop already applied. Before {@code eval} was introduced a non-conforming
- * name reaching {@code export "$n="} was harmless either way — the quoting made it inert. With
- * {@code eval}, the name is spliced into a string and interpreted as shell syntax, so the enumeration
- * loop's check is no longer sufficient on its own to keep that call site safe — it is a guard on a
- * different loop, and the two must not silently drift apart. Re-checking right before the
- * {@code eval} keeps that call site safe by its own reading, independent of whatever the enumeration
- * loop does or stops doing in a later change.
- *
- * <p><b>fleetd #400:</b> {@code eval}'s exit status is not proof that the blank actually happened.
- * zsh coerces a bare {@code NAME=} assignment on an integer special parameter (measured on macOS zsh
- * 5.9: {@code SECONDS}, {@code RANDOM}, {@code SHLVL}, {@code HISTSIZE}, {@code COLUMNS},
- * {@code LINES}, {@code USERNAME}) to a number instead of failing — {@code eval} returns success,
- * the value is untouched, and a status-based classification reports it as blanked when it was not.
- * The fix classifies on the observed effect instead: after the attempt, the name's value is read
- * back with the {@code (P)} indirection flag and the decision is made from whether that is now
- * empty. This one check covers all three shapes a name can take at this point — a genuine blank, a
- * fatal read-only error {@code eval} merely contained, and this silent no-op — and the exit status
- * plays no part in the decision at all.
+ * M} line (N = exports left untouched, M = exports present when the scrub ran), then the blanked
+ * NAMES — never values. The launcher reads this back at teardown and logs it, because a blocked
+ * count next to an unknown denominator is not a finding.
  */
 public final class EnvAllowListScrub {
 
@@ -116,11 +63,7 @@ public final class EnvAllowListScrub {
     /** Name of the report file written into the generated directory by the scrub itself. */
     static final String REPORT_FILE = "scrub-report.txt";
 
-    /**
-     * The scrub body, generated once and sourced from {@code .zshrc} and {@code .zlogin}
-     * unconditionally, and from {@code .zshenv} when the pane shell is neither login nor
-     * interactive (fleetd #388) — see the class javadoc.
-     */
+    /** The scrub body, generated once and sourced from both {@code .zshrc} and {@code .zlogin}. */
     static final String SCRUB_FILE = "scrub.zsh";
 
     /** Prefix of every generated directory — also what {@link #reapOrphans} matches on. */
@@ -136,42 +79,14 @@ public final class EnvAllowListScrub {
     private static final String SOURCE_SCRUB =
             "source \"$ZDOTDIR/" + SCRUB_FILE + "\"\n";
 
-    /**
-     * fleetd #388: marks a pane, not a process, as already scrubbed. Set only by the guarded
-     * {@code .zshenv} pass (see {@link #NEITHER_LOGIN_NOR_INTERACTIVE_SCRUB}) after
-     * {@code scrub.zsh} has run, so it must also be folded into that pass's own allow-list — see
-     * the class javadoc's "must also be on the scrub's own allow-list" paragraph.
-     */
-    static final String SCRUB_SENTINEL = "_CB633_SCRUBBED";
-
-    /**
-     * Appended to {@code .zshenv}, after its {@code $HOME} source: the third pass, guarded on the
-     * exact condition that defines the gap {@code .zshrc}/{@code .zlogin} do not cover — a shell
-     * that is neither login nor interactive. The sentinel export happens only once the scrub has
-     * already run, and only for as long as the current pane's environment has not been rebuilt from
-     * scratch (a fresh {@code env -i} child would not inherit it — that is out of scope here, since
-     * such a child is no longer running under the pane's own environment at all).
-     */
-    private static final String NEITHER_LOGIN_NOR_INTERACTIVE_SCRUB =
-            "if [[ ! -o login && ! -o interactive && -z \"${" + SCRUB_SENTINEL + ":-}\" ]]; then\n"
-            + "  " + SOURCE_SCRUB
-            + "  export " + SCRUB_SENTINEL + "=1\n"
-            + "fi\n";
-
     private EnvAllowListScrub() {
     }
 
     /**
-     * A parsed {@code scrub-report.txt}: how many exported variables existed when the scrub ran
-     * ({@code total}), how many were left untouched ({@code allowed}), how many the scrub attempted
-     * to blank but could not ({@code failed} — fleetd #394: a zsh read-only/special parameter such
-     * as {@code UID} fatally errors on plain {@code export NAME=}, so those attempts go through
-     * {@code eval} instead so the loop keeps going and the failure is counted rather than left
-     * invisible), and the NAMES in each of the latter two categories. {@code allowed +
-     * blanked.size() + unblankable.size() == total}, and {@code unblankable.size() == failed}.
-     * Values never appear.
+     * A parsed {@code scrub-report.txt}: how many exported variables existed when the scrub ran,
+     * how many were left untouched (allowed), and the NAMES that were blanked. Values never appear.
      */
-    record ScrubReport(int allowed, int total, int failed, List<String> blanked, List<String> unblankable) {
+    record ScrubReport(int allowed, int total, List<String> blanked) {
     }
 
     /**
@@ -190,16 +105,11 @@ public final class EnvAllowListScrub {
             reapOrphans(parentDir);
             Path dir = Files.createTempDirectory(parentDir, DIR_PREFIX);
             dir.toFile().deleteOnExit();
-            // zsh truncates this pre-created receipt after these hooks are registered. Register its
-            // path too — otherwise the directory is non-empty at JVM exit and cannot be removed.
-            Files.createFile(dir.resolve(REPORT_FILE)).toFile().deleteOnExit();
-            // fleetd #388: scrub.zsh's OWN allow-list must also keep SCRUB_SENTINEL, or a later
-            // pass in the same pane blanks it back to empty and the .zshenv guard below thinks it
-            // was never scrubbed — see the class javadoc.
-            Set<String> namesForScrubScript = new HashSet<>(allowedNames);
-            namesForScrubScript.add(SCRUB_SENTINEL);
-            write(dir, SCRUB_FILE, scrubScript(namesForScrubScript));
-            write(dir, ".zshenv", homeSourcingFile(".zshenv") + NEITHER_LOGIN_NOR_INTERACTIVE_SCRUB);
+            // The report is written by zsh, after these hooks are registered, so register its path
+            // too — otherwise the directory is non-empty at JVM exit and cannot be removed at all.
+            dir.resolve(REPORT_FILE).toFile().deleteOnExit();
+            write(dir, SCRUB_FILE, scrubScript(allowedNames));
+            write(dir, ".zshenv", homeSourcingFile(".zshenv"));
             write(dir, ".zprofile", homeSourcingFile(".zprofile"));
             write(dir, ".zshrc", homeSourcingFile(".zshrc") + SOURCE_SCRUB);
             write(dir, ".zlogin", homeSourcingFile(".zlogin") + SOURCE_SCRUB);
@@ -237,11 +147,12 @@ public final class EnvAllowListScrub {
      * into it: owner keeps full access, {@code group} gets traverse+read on the directory ({@code
      * rwxr-x---}, so a member process — a login shell reading it via {@code ZDOTDIR}, or another
      * process simply opening a file under it — running under that group can find and read the
-     * files) and read-only on each file ({@code rw-r-----}), except the pre-created ZDOTDIR
-     * {@code scrub-report.txt}. That receipt gets group write ({@code rw-rw----}), so
-     * {@code scrub.zsh} can truncate and write it without granting group write on the directory.
-     * If its optional permission change fails, the member cannot write a receipt and the launcher
-     * keeps its existing WARN rather than failing the spawn.
+     * files) and read-only on each file ({@code rw-r-----}) — deliberately no group WRITE anywhere,
+     * since a member never needs to add or change what fleetd generated. (For the ZDOTDIR scrub
+     * specifically, this also means the scrub script's own report write inside the pane fails
+     * closed rather than open — see {@code scrub.zsh}'s trailing {@code 2>/dev/null} — which {@link
+     * dev.ltms.fleet.member.HerdrPeerLauncher#releaseZdotdir} already treats as "cannot be
+     * confirmed to have run" rather than success.)
      *
      * <p>Package-private and named generically on purpose: fleetd #213 built this for the ZDOTDIR
      * scrub directory, and fleetd #219 reuses it verbatim for {@link
@@ -256,15 +167,7 @@ public final class EnvAllowListScrub {
             setGroupAndPermissions(dir, principal, "rwxr-x---");
             try (Stream<Path> entries = Files.list(dir)) {
                 for (Path file : entries.toList()) {
-                    if (REPORT_FILE.equals(file.getFileName().toString())) {
-                        try {
-                            setGroupAndPermissions(file, principal, "rw-rw----");
-                        } catch (IOException | UnsupportedOperationException ignored) {
-                            // The receipt is optional. Its absence keeps the existing WARN path.
-                        }
-                    } else {
-                        setGroupAndPermissions(file, principal, "rw-r-----");
-                    }
+                    setGroupAndPermissions(file, principal, "rw-r-----");
                 }
             }
         } catch (IOException e) {
@@ -278,33 +181,6 @@ public final class EnvAllowListScrub {
         }
     }
 
-    /**
-     * fleetd #285: share ONE file with {@code group}, read-only ({@code rw-r-----}) — the same
-     * per-file mode {@link #shareWithGroup} applies to a directory's entries, and the same error
-     * shapes, but without touching a parent directory. Used for a file fleetd writes into a
-     * directory it does NOT own — {@code configDir}'s own traversal permissions stay the
-     * operator's setup — where the directory-wide {@link #shareWithGroup} would be wrong.
-     *
-     * @throws UncheckedIOException when {@code group} does not resolve on this host, the
-     *                              filesystem has no POSIX group ownership, or a
-     *                              group-ownership/permission call is refused
-     */
-    static void shareFileWithGroup(Path file, String group) {
-        try {
-            GroupPrincipal principal = file.getFileSystem().getUserPrincipalLookupService()
-                    .lookupPrincipalByGroupName(group);
-            setGroupAndPermissions(file, principal, "rw-r-----");
-        } catch (IOException e) {
-            throw new UncheckedIOException("cannot share generated file " + file + " with group '"
-                    + group + "' — the group must exist, and the fleetd operator ("
-                    + System.getProperty("user.name") + ") must be a member of it", e);
-        } catch (UnsupportedOperationException e) {
-            throw new UncheckedIOException("cannot share generated file " + file + " with group '"
-                    + group + "' — this filesystem does not support POSIX group ownership",
-                    new IOException(e));
-        }
-    }
-
     private static void setGroupAndPermissions(Path path, GroupPrincipal group, String perms) throws IOException {
         PosixFileAttributeView view = Files.getFileAttributeView(path, PosixFileAttributeView.class);
         if (view == null) {
@@ -342,13 +218,11 @@ public final class EnvAllowListScrub {
         }
         return """
                 # generated by fleetd (CB-633 memberCredentials policy=allow-list) — do not edit.
-                # Sourced unconditionally from .zshrc and again from .zlogin, each time AFTER that
-                # file has sourced its $HOME counterpart — so this runs after everything the
-                # operator sourced, on any pane that is login and/or interactive. Running twice is
-                # idempotent and deliberate: the second pass catches anything ~/.zlogin exported
-                # after ~/.zshrc had finished. Also sourced, once, from a guarded pass in .zshenv
-                # (fleetd #388) when the pane shell is NEITHER login nor interactive — the one gap
-                # those two files do not cover.
+                # Sourced from .zshrc and again from .zlogin, each time AFTER that file has sourced
+                # its $HOME counterpart — so this runs after everything the operator sourced, on a
+                # login shell (macOS panes) and on a plain interactive one (Linux panes) alike.
+                # Running twice is idempotent and deliberate: the second pass catches anything
+                # ~/.zlogin exported after ~/.zshrc had finished.
 
                 typeset -A _cb633_allowed
                 for _cb633_n in %s; do _cb633_allowed[$_cb633_n]=1; done
@@ -370,57 +244,15 @@ public final class EnvAllowListScrub {
                   _cb633_blank+=("$_cb633_n")
                 done
 
-                # fleetd #394: plain `export "$n="` is FATAL for a zsh read-only/special parameter
-                # (e.g. UID) and aborts this whole sourced file — every name still to come is never
-                # blanked, and the report below is never written, silently. `eval` contains that
-                # error to the single iteration instead: it still fails for that one name, but the
-                # loop continues and we can tell allowed / blanked / unblankable apart afterwards.
-                # This is not a skip-list of known-bad names (that would miss the next one nobody
-                # thought of) — every name in _cb633_blank is still attempted, unconditionally.
-                # Every name reaching this loop already passed the identical identifier check in the
-                # enumeration loop above — but that guard is 20 lines away in a different loop, and
-                # this line is about to splice the name into a string handed to `eval`. Before this
-                # fix the name only ever reached `export` quoted ("$n="), which is inert on a
-                # non-identifier string either way; `eval` makes THIS line the only thing standing
-                # between such a string and code execution in the member's pane, so it re-asserts the
-                # same check on its own rather than trusting a guard it does not own. Under normal
-                # operation this can never fire (the enumeration guard already filtered everything
-                # reaching _cb633_blank), so a name caught here is counted as unblankable rather than
-                # silently dropped — it is real evidence that the upstream guard was bypassed.
-                #
-                # fleetd #400: the attempt's own exit status is NOT proof of its effect. zsh coerces
-                # a bare `NAME=` assignment on an integer special parameter (SECONDS, RANDOM, SHLVL,
-                # HISTSIZE, COLUMNS, LINES, USERNAME on this host) to a number instead of failing —
-                # `eval` returns 0, the value is untouched, and the old exit-status check reported it
-                # as blanked when it was not. Classify on the observed effect instead: attempt the
-                # export, then read the name's value back with the `(P)` indirection flag and decide
-                # from whether it is now empty. One check then covers all three shapes a name can
-                # take here — a genuine blank, a fatal read-only error `eval` merely contained, and
-                # this silent no-op — without the exit status entering the decision at all.
-                typeset -a _cb633_ok _cb633_unblankable
-                _cb633_ok=()
-                _cb633_unblankable=()
-                for _cb633_n in "${_cb633_blank[@]}"; do
-                  if [[ ! "$_cb633_n" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]]; then
-                    _cb633_unblankable+=("$_cb633_n")
-                    continue
-                  fi
-                  eval "export ${_cb633_n}=" 2>/dev/null
-                  if [[ -z "${(P)_cb633_n}" ]]; then
-                    _cb633_ok+=("$_cb633_n")
-                  else
-                    _cb633_unblankable+=("$_cb633_n")
-                  fi
-                done
+                { for _cb633_n in "${_cb633_blank[@]}"; do export "$_cb633_n="; done; } 2>/dev/null
 
                 integer _cb633_kept=$(( _cb633_total - ${#_cb633_blank} ))
                 {
-                  print -r -- "allowed $_cb633_kept of $_cb633_total failed ${#_cb633_unblankable}"
-                  for _cb633_n in "${_cb633_ok[@]}"; do print -r -- "$_cb633_n"; done
-                  for _cb633_n in "${_cb633_unblankable[@]}"; do print -r -- "!$_cb633_n"; done
+                  print -r -- "allowed $_cb633_kept of $_cb633_total"
+                  for _cb633_n in "${_cb633_blank[@]}"; do print -r -- "$_cb633_n"; done
                 } > "$ZDOTDIR/%s" 2>/dev/null
 
-                unset _cb633_allowed _cb633_names _cb633_blank _cb633_ok _cb633_unblankable _cb633_n _cb633_total _cb633_kept
+                unset _cb633_allowed _cb633_names _cb633_blank _cb633_n _cb633_total _cb633_kept
                 """.formatted(names, MemberEnvAllowList.zshCasePattern(), REPORT_FILE);
     }
 
@@ -434,11 +266,6 @@ public final class EnvAllowListScrub {
      * Read and parse {@link #REPORT_FILE} out of a generated ZDOTDIR directory. Returns {@code null}
      * when absent or unreadable (the pane may have been torn down before its login shell ever got to
      * the scrub) — callers treat that as "no measurement available", never as success.
-     *
-     * <p>First line is {@code "allowed <N> of <M> failed <F>"} (fleetd #394 added the trailing
-     * {@code failed <F>} — a count of names the scrub attempted to blank but could not, e.g. a zsh
-     * read-only/special parameter). Every following non-blank line is a name: a bare name was
-     * blanked, a {@code !}-prefixed name was attempted and failed. Values never appear on either.
      */
     static ScrubReport readReport(Path zdotdir) {
         Path report = zdotdir.resolve(REPORT_FILE);
@@ -451,24 +278,17 @@ public final class EnvAllowListScrub {
                 return null;
             }
             String[] parts = lines.getFirst().substring("allowed ".length()).trim().split("\\s+");
-            if (parts.length != 5 || !"of".equals(parts[1]) || !"failed".equals(parts[3])) {
+            if (parts.length != 3 || !"of".equals(parts[1])) {
                 return null;
             }
             List<String> blanked = new ArrayList<>();
-            List<String> unblankable = new ArrayList<>();
             for (int i = 1; i < lines.size(); i++) {
-                String line = lines.get(i);
-                if (line.isBlank()) {
-                    continue;
-                }
-                if (line.startsWith("!")) {
-                    unblankable.add(line.substring(1));
-                } else {
-                    blanked.add(line);
+                if (!lines.get(i).isBlank()) {
+                    blanked.add(lines.get(i));
                 }
             }
             return new ScrubReport(Integer.parseInt(parts[0]), Integer.parseInt(parts[2]),
-                    Integer.parseInt(parts[4]), List.copyOf(blanked), List.copyOf(unblankable));
+                    List.copyOf(blanked));
         } catch (IOException | NumberFormatException e) {
             return null;
         }

fleetd/src/main/java/dev/ltms/fleet/member/HerdrPeerLauncher.java

@@ -17,7 +17,6 @@ import dev.ltms.fleet.peer.PeerHandle;
 import dev.ltms.fleet.peer.PeerLauncher;
 import dev.ltms.fleet.peer.PeerUnreachableException;
 import dev.ltms.fleet.peer.SpawnRequest;
-import dev.ltms.fleet.placement.PlacementDecision;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -595,23 +594,6 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
                 req.sessionName(), spawned.agentSessionId(), spawned.receipt());
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * <p>fleetd #450: re-enters {@link #spawn(SpawnRequest)} with {@code decision}'s profile named
-     * explicitly. This is the re-entering form the interface javadoc describes for a launcher with
-     * no placement concept of its own — an instance of this class spawns a single adapter's own
-     * profile set by explicit name only ({@link #place}/{@link #defaultProfileFor} are unoverridden
-     * here and just wrap {@link #defaultProfile()}); it does no quarantine/cool-off/maxLoad/model-off
-     * filtering of its own to re-apply. That filtering lives one layer up, in {@code
-     * CompositePeerLauncher}, which is the launcher that routes across more than one profile and
-     * therefore overrides this method with the routing form instead.
-     */
-    @Override
-    public PeerHandle spawn(SpawnRequest req, PlacementDecision decision) {
-        return spawn(req.withProfile(decision.profile()));
-    }
-
     /** The herdr daemon that owns this launcher's pane coordinates. */
     public HerdrClient herdr() {
         return agents.herdr();
@@ -715,20 +697,7 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
         if (paneId == null) {
             throw new IllegalStateException("pane.split returned no pane — cannot start a peer");
         }
-        Agent peer;
-        try {
-            peer = startUniquelyNamed(cfg, argv, paneId).agent();
-        } catch (RuntimeException e) {
-            // The peer never started — don't leave the pane we just created orphaned.
-            // Best-effort cleanup; never let it mask the real spawn failure.
-            try {
-                stop(paneId);
-            } catch (RuntimeException cleanup) {
-                log.warn("failed to close orphaned pane {} after spawn error: {}",
-                        paneId, cleanup.getMessage());
-            }
-            throw e;
-        }
+        Agent peer = startUniquelyNamed(cfg, argv, paneId).agent();
         log.info("{} started pane={} terminal={}", namePrefix, peer.paneId(), peer.terminalId());
         return peer;
     }
@@ -944,31 +913,20 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
      * {@link #reapOrphanWorkers() orphan-reap} and spawn-gate-timeout paths, plus any caller that
      * passes a pane directly, keep working without an owning id.
      *
-     * <p>Resolves the tab from the pane <em>before</em> closing it. {@code agents.close} (the pane)
-     * is the one step whose failure means the teardown itself may not have happened: an already-gone
-     * pane (repeated DELETE, crashed peer) is treated as success, but any other failure propagates so
-     * a genuinely failed teardown is not reported as done. {@code spaces.closeTab} (fleetd #293) is
-     * different — by the time it runs the pane is already closed, so it is cosmetic workspace tidying
-     * rather than a real teardown failure, and a failure there is logged and never propagates, so it
-     * cannot mask the two cleanups below it ({@link #releaseZdotdir}, and the caller's worktree
-     * removal in {@code SessionManager.release}).
+     * <p>Resolves the tab from the pane <em>before</em> closing it. An already-gone pane/tab
+     * (repeated DELETE, crashed peer) is treated as success; any other failure propagates so a
+     * genuinely failed teardown is not reported as done.
      */
     @Override
     public void stop(String idOrPane) {
-        // Teardown knows only the pane, not which profile spawned it — and, when this call is
-        // routed here through CompositePeerLauncher's single-daemon stop() shortcut (fleetd #342),
-        // not even which adapter's config actually governed the spawn: the shortcut can hand the
-        // pane to a delegate that never spawned it, whose own profiles say nothing about how THIS
-        // pane was placed. So the decision to look for a tab to clean up is made from the pane's
-        // actual state, not from this delegate's static profile config: resolve the tab
-        // unconditionally and let {@link WorkspaceControl#locatePane} tolerate "not found" (it
-        // returns null rather than throwing); the single-occupant check below is what actually
-        // protects the user's shared tabs, exactly as it always has.
+        // Teardown knows only the pane, not which profile spawned it. Attempt tab cleanup when any
+        // profile uses tab placement (so the bridge may have created a dedicated peer tab); the
+        // single-occupant check below is what actually protects the user's shared tabs.
         String paneId = paneByAgentId.remove(idOrPane);
         if (paneId == null) {
             paneId = idOrPane; // raw-pane fallback (reap, gate timeout, pane-addressed callers)
         }
-        WorkspaceControl.PaneLocation loc = spaces.locatePane(paneId);
+        WorkspaceControl.PaneLocation loc = usesTabPlacement() ? spaces.locatePane(paneId) : null;
         try {
             agents.close(paneId);
         } catch (HerdrException e) {
@@ -976,25 +934,7 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
             log.debug("pane.close({}) ignored — already gone: {}", paneId, e.getMessage());
         }
         if (loc != null && loc.tabPaneCount() == 1) {
-            // fleetd #293: the pane above is already closed by this point, so a failing tab.close is
-            // cosmetic workspace tidying, not a real teardown failure — it must not mask the two
-            // cleanups below it (releaseZdotdir, and the caller's worktree removal). Unlike
-            // agents.close above, this is not narrowed to "already gone": any failure here, whatever
-            // its cause, is one we continue past, so we log it at WARN (not debug) with the tab id a
-            // person can go close by hand.
-            try {
-                spaces.closeTab(loc.tabId());
-            } catch (RuntimeException e) {
-                // Caught as RuntimeException, not HerdrException, to match releaseZdotdir's own
-                // guard five lines below. Today the two are the same set — HerdrCodec wraps every
-                // encode/decode failure and UnixSocketHerdrClient wraps every IOException, so
-                // HerdrException is all closeTab can actually throw. Narrowing to it anyway would
-                // leave this step guarded against the expected failure and bare against any other,
-                // which is the exact asymmetry fleetd #293 exists to remove. No behaviour change
-                // today; it stops a later change inside WorkspaceControl.closeTab reopening it.
-                log.warn("tab.close({}) failed — the pane is already torn down, so continuing; the "
-                        + "tab may need manual cleanup: {}", loc.tabId(), e.getMessage());
-            }
+            spaces.closeTab(loc.tabId());
         } else if (loc != null) {
             log.debug("not closing tab {} — it holds {} panes (not a dedicated peer tab)",
                     loc.tabId(), loc.tabPaneCount());
@@ -1009,6 +949,11 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
         }
     }
 
+    /** Whether any configured profile places peers in their own tab (so tabs may need cleanup). */
+    private boolean usesTabPlacement() {
+        return profiles.values().stream().anyMatch(FleetConfig.Profile::tabPlacement);
+    }
+
     /** True when a herdr error means the target is already gone (safe to treat as done). */
     private static boolean isAlreadyGone(HerdrException e) {
         return e.code() != null && e.code().endsWith("_not_found");
@@ -1028,8 +973,7 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
      * that gap: it stops waiting immediately (never burns the rest of the timeout), runs the same
      * teardown the timeout path below runs, and throws with a message that says the backend exited
      * rather than that the pane was slow. Any other {@link HerdrException} still propagates
-     * unchanged — this gate does not interpret or recover from it, but it still closes the pane
-     * it opened before handing the exception to its caller.
+     * unchanged — this gate does not know how to recover from it.
      */
     private void waitUntilInjectableOrThrow(String paneId) {
         long start = nowMillis.getAsLong();
@@ -1043,15 +987,7 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
                 if (isAlreadyGone(e)) {
                     failFastOnGoneBackend(paneId, e, nowMillis.getAsLong() - start);
                 }
-                // This gate must not interpret an unrelated herdr error, but the caller does not
-                // receive paneId when spawn throws. Close the pane here before propagating e unchanged.
-                try {
-                    stop(paneId);
-                } catch (RuntimeException cleanup) {
-                    log.warn("failed to close orphaned pane {} after readiness-gate error: {}",
-                            paneId, cleanup.getMessage());
-                }
-                throw e;
+                throw e; // any other herdr failure is not ours to interpret — let it propagate
             }
             lastStatus = sample.status();
             if (lastStatus.injectable() || refinedInjectable(paneId, sample)) {
@@ -1661,19 +1597,11 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
             log.warn("memberCredentials allow-list: pane {} left no scrub report in {} — the "
                     + "environment scrub cannot be confirmed to have run. Either the pane ended "
                     + "before its shell finished starting, or its shell never read our generated "
-                    + "startup files. Either way, we cannot tell from here whether the scrub ran, "
-                    + "so we do not know what that member's environment contained.",
+                    + "startup files, in which case that member saw the full host environment.",
                     paneId, dir);
         } else {
             log.info("memberCredentials allow-list: pane {} allowed {} of {} environment variables",
                     paneId, report.allowed(), report.total());
-            if (report.failed() > 0) {
-                log.warn("memberCredentials allow-list: pane {} could not blank {} environment "
-                        + "variable(s) — {} (likely a zsh read-only/special parameter) — those "
-                        + "names were left in the member's environment. Confirm none of them is a "
-                        + "credential.",
-                        paneId, report.failed(), report.unblankable());
-            }
             List<String> shaped = report.blanked().stream()
                     .filter(name -> CREDENTIAL_SHAPED_NAME.matcher(name).matches())
                     .toList();
@@ -1692,59 +1620,30 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
 
     /**
      * Guards the {@code effectiveAllowed == null} branch of {@link #logCredentialGap} — the
-     * genuinely-unprotected report (deny-by-default, and the allow-list non-zsh fallback) — AND
-     * the {@code effectiveAllowed != null} / {@code keptByDerivedList} branch, the allow-list case
-     * where a name is in the gap but the derived allow-list keeps it anyway. Both branches log the
-     * same severity (WARN) about the same fact — a name genuinely reaching a member pane
-     * unprotected — so they share this one guard, keyed per NAME rather than per launcher instance:
-     * each credential-shaped name that is ever reported unprotected gets exactly one WARN, however
-     * many spawns see it and whichever of the two branches first reports it.
-     *
-     * <p>fleetd #341: {@code memberCredentials} is a live, re-read-per-spawn supplier, so the
-     * policy — and so the gap's actual member names — can change between two spawns on the same
-     * launcher. Before this fix the guard was a single {@code AtomicBoolean} tripped by either
-     * branch: spawn 1 could warn about name A and trip the flag, and a later spawn's gap containing
-     * a different name B would never be reported, even though B is just as unprotected as A was.
-     * {@code AtomicBoolean} could not express "once per distinct name" at all — only "once, ever,
-     * for whichever name got there first" — so this is a {@code Set<String>} guard instead, the
-     * same shape {@link OpenCodeLauncher#modelCheckSkippedWarned} already uses for its own
-     * once-per-distinct-thing WARN. {@link #add}'s return value (true only the first time a name is
-     * added) is what turns "log the whole gap" into "log only the names never warned about before".
-     *
-     * <p>Bounded by construction: every name added here first passed {@link
-     * #CREDENTIAL_SHAPED_NAME}'s filter over {@link #hostEnvNames}, i.e. it is an actual
-     * environment variable name from the daemon's own process — a small, OS-bounded set (the host
-     * environment has, in practice, tens to a few hundred entries), not an attacker- or
-     * request-controlled input. So this set cannot grow past "however many distinct credential-
-     * shaped names this host's environment has ever held across this launcher's lifetime," which is
-     * effectively fixed for the life of one daemon process — no separate cap is needed.
+     * genuinely-unprotected report (deny-by-default, and the allow-list non-zsh fallback) — to one
+     * WARN per launcher instance, not one per spawn.
      *
      * <p>CB-633 follow-up (#192): kept SEPARATE from {@link #allowListGapLogged} on purpose.
      * {@code memberCredentials} is a live, re-read-per-spawn supplier, so the policy can change
      * between two spawns on the same launcher. A single shared flag would let a harmless allow-list
      * INFO on spawn 1 permanently suppress the real deny-by-default WARN a later spawn deserves —
      * the report that matters most getting hidden by the report that doesn't. Two flags mean each
-     * report kind (WARN vs. INFO) fires independently of what the other kind already logged; within
-     * the WARN kind itself, the set above further separates by name, for the same reason.
+     * report kind fires exactly once, independent of what the other kind already logged.
      */
-    private final Set<String> unprotectedGapNamesWarned = ConcurrentHashMap.newKeySet();
+    private final AtomicBoolean unprotectedGapLogged = new AtomicBoolean();
 
     /**
      * Guards the {@code effectiveAllowed != null} branch of {@link #logCredentialGap} — the
      * allow-list-scrub-covered report — to one INFO per launcher instance. See {@link
-     * #unprotectedGapNamesWarned}'s javadoc for why this is a separate flag rather than a shared
-     * one; unlike that guard it stays a per-instance {@code AtomicBoolean}, not a per-name set —
-     * fleetd #341 fixed the WARN-vs-WARN suppression, not this INFO's own one-shot shape, which was
-     * not reported as broken and is out of that ticket's scope.
+     * #unprotectedGapLogged}'s javadoc for why this is a separate flag rather than a shared one.
      */
     private final AtomicBoolean allowListGapLogged = new AtomicBoolean();
 
     /**
      * fleetd #185 stage 2: guards {@link #warnUnknownMemberEnvironment} to one WARN per launcher
-     * instance, not one per spawn — the same one-shot shape {@link #unprotectedGapNamesWarned} and
-     * {@link #allowListGapLogged} guard their own branches with, kept as its own flag for the same
-     * reason those two are split: this mode is orthogonal to which of the other two branches would
-     * otherwise have fired.
+     * instance, not one per spawn — the same one-per-instance shape as {@link #unprotectedGapLogged}
+     * and {@link #allowListGapLogged}, kept as its own flag for the same reason those two are split:
+     * this mode is orthogonal to which of the other two branches would otherwise have fired.
      */
     private final AtomicBoolean unknownMemberEnvironmentWarned = new AtomicBoolean();
 
@@ -1872,21 +1771,14 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
         List<String> blankedByScrub = gap.stream()
                 .filter(name -> !MemberEnvAllowList.keeps(effectiveAllowed, name))
                 .toList();
-        // fleetd #341: filter to names this guard has never warned about before — not just
-        // "isEmpty" on the whole branch — so a name this spawn's gap shares with an EARLIER
-        // spawn's (already-warned) gap does not re-print, while a name unique to THIS gap still
-        // does, whichever of the two WARN branches reported it first.
-        List<String> newlyUnprotected = keptByDerivedList.stream()
-                .filter(unprotectedGapNamesWarned::add)
-                .toList();
-        if (!newlyUnprotected.isEmpty()) {
+        if (!keptByDerivedList.isEmpty() && unprotectedGapLogged.compareAndSet(false, true)) {
             log.warn("memberCredentials gap: {} credential-shaped env var name(s) are on neither "
                             + "known: nor allow: — the derived allow-list keeps them anyway (a profile's "
                             + "gitTokenEnv/gitHostEnv/tokenEnv/env: names one, or this spawn injects it), "
                             + "so every member pane inherits them UNBLOCKED — {}. Add each to "
                             + "memberCredentials.known (or .allow if a member legitimately needs it), or "
                             + "remove it from whatever profile setting derives it in.",
-                    newlyUnprotected.size(), newlyUnprotected);
+                    keptByDerivedList.size(), keptByDerivedList);
         }
         if (!blankedByScrub.isEmpty() && allowListGapLogged.compareAndSet(false, true)) {
             log.info("memberCredentials gap: {} credential-shaped env var name(s) are on neither "
@@ -1899,18 +1791,12 @@ public abstract class HerdrPeerLauncher implements PeerLauncher {
 
     /** The deny-by-default (and allow-list non-zsh fallback) WARN — unchanged byte-for-byte by #192. */
     private void warnGapUnprotected(List<String> gap) {
-        // fleetd #341: same "only the names never warned before" filter as the sibling branch in
-        // logCredentialGap above — see unprotectedGapNamesWarned's javadoc. Both branches share
-        // this one guard because both report the exact same fact (a name reaching a member pane
-        // unprotected) at the exact same severity; keying it by name is what lets a later spawn's
-        // DIFFERENT name still get its own WARN after an earlier spawn's already fired.
-        List<String> newlyUnprotected = gap.stream().filter(unprotectedGapNamesWarned::add).toList();
-        if (!newlyUnprotected.isEmpty()) {
+        if (unprotectedGapLogged.compareAndSet(false, true)) {
             log.warn("memberCredentials gap: {} credential-shaped env var name(s) are on neither "
                             + "known: nor allow: — every member pane inherits them UNBLOCKED — {}. "
                             + "Add each to memberCredentials.known (blocked by default) or .allow "
                             + "(if a member legitimately needs it).",
-                    newlyUnprotected.size(), newlyUnprotected);
+                    gap.size(), gap);
         }
     }
 

fleetd/src/main/java/dev/ltms/fleet/metrics/FleetMetrics.java

@@ -56,13 +56,10 @@ public final class FleetMetrics {
         m.describe(REPLIES, "counter",
                 "Worker replies by delivery path (rendezvous=resolved an open send, inbox=stranded and held).");
         m.describe(PUSH_NUDGES, "counter",
-                "CB-307 push-loop nudges to the primary (sent|exhausted). fleetd #365: \"sent\" means "
-                        + "the herdr paste-and-submit call succeeded, not that the pane read it — this "
-                        + "layer has no read-receipt concept.");
+                "CB-307 push-loop nudges to the primary (delivered|exhausted).");
         m.describe(HEARTBEAT_NUDGES, "counter",
-                "CB-551 idle-lead heartbeat nudges (sent|failed|exhausted). Quiet-cap exhaustion "
-                        + "means the lead idled with nothing pending and was told to stand down. "
-                        + "fleetd #365: \"sent\" means the herdr call succeeded, not that the lead read it.");
+                "CB-551 idle-lead heartbeat nudges (delivered|failed|exhausted). Quiet-cap exhaustion "
+                        + "means the lead idled with nothing pending and was told to stand down.");
         m.describe(SPAWNS, "counter",
                 "Worker spawn attempts by peer kind and outcome (ready|timeout|guard_rejected).");
         m.describe(HERDR_CALLS, "counter",

fleetd/src/main/java/dev/ltms/fleet/msg/AmqpReplyInbox.java

@@ -8,7 +8,6 @@ import com.rabbitmq.client.DeliverCallback;
 import com.rabbitmq.client.Recoverable;
 import com.rabbitmq.client.RecoveryListener;
 import com.rabbitmq.client.Return;
-import com.rabbitmq.client.impl.DefaultExceptionHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -23,7 +22,6 @@ import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * AMQP-backed {@link ReplyInbox} (CB-307 Stage 2): genuine cross-restart durability behind the same
@@ -95,23 +93,8 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
     private final Channel channel;
     /** All channel operations (publish/declare/ack/cancel) serialize on this — a Channel is not thread-safe. */
     private final Object channelLock = new Object();
-    /**
-     * target → (msgId → held delivery). Per-target map is guarded by synchronizing on itself.
-     *
-     * <p><strong>CB-318 tombstone.</strong> The value {@link #RELEASED} is a reserved sentinel: it
-     * marks a target whose {@link #release} has already run, so {@link #deliverCallback} can tell a
-     * delivery landing after release() apart from a fresh target it has never seen. See both methods'
-     * javadoc for why a plain {@code held.remove(target)} is not enough.
-     */
+    /** target → (msgId → held delivery). Per-target map is guarded by synchronizing on itself. */
     private final ConcurrentHashMap<String, LinkedHashMap<String, Held>> held = new ConcurrentHashMap<>();
-
-    /**
-     * CB-318 sentinel stored in {@link #held} for a target whose {@link #release} has already run.
-     * Never mutated — every read site compares it by reference ({@code ==}) before touching it as a
-     * map, because it is a single object shared across every released target and calling a mutator on
-     * it would corrupt state for all of them.
-     */
-    private static final LinkedHashMap<String, Held> RELEASED = new LinkedHashMap<>();
     /** Targets whose queue is declared and consumer is running, mapped to their broker consumer tag. */
     private final ConcurrentHashMap<String, String> consumerTags = new ConcurrentHashMap<>();
 
@@ -154,22 +137,17 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
     /** As {@link #open(String)}, with an explicit consumer prefetch (CB-527: caps the held backlog per target). */
     public static AmqpReplyInbox open(String uri, int prefetch) {
         try {
-            return new AmqpReplyInbox(connectionFactory(uri).newConnection(AmqpConnectionFailureLogger.REPLY_INBOX), prefetch);
+            ConnectionFactory factory = new ConnectionFactory();
+            factory.setUri(uri);
+            // Self-heal transient blips; topology recovery re-declares queues and re-attaches consumers.
+            factory.setAutomaticRecoveryEnabled(true);
+            factory.setTopologyRecoveryEnabled(true);
+            return new AmqpReplyInbox(factory.newConnection("fleetd-reply-inbox"), prefetch);
         } catch (Exception e) {
             throw new IllegalStateException("cannot connect to AMQP broker at " + uri, e);
         }
     }
 
-    static ConnectionFactory connectionFactory(String uri) throws Exception {
-        ConnectionFactory factory = new ConnectionFactory();
-        factory.setUri(uri);
-        // Self-heal transient blips; topology recovery re-declares queues and re-attaches consumers.
-        factory.setAutomaticRecoveryEnabled(true);
-        factory.setTopologyRecoveryEnabled(true);
-        factory.setExceptionHandler(new AmqpConnectionFailureLogger(AmqpConnectionFailureLogger.REPLY_INBOX, log));
-        return factory;
-    }
-
     /** Wrap an already-open connection with {@link #DEFAULT_PREFETCH} (injection seam for the contract test). */
     AmqpReplyInbox(Connection connection) {
         this(connection, DEFAULT_PREFETCH);
@@ -223,12 +201,6 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
                 channel.queueDeclare(queue, true, false, false, null); // durable, non-exclusive, keep on idle
                 String tag = channel.basicConsume(queue, false, deliverCallback(target), _ -> { });
                 consumerTags.put(target, tag);
-                // CB-318: drop a stale RELEASED tombstone from a prior ownership of this same target
-                // string, so a delivery under this fresh consumer is held normally instead of being
-                // nacked forever by deliverCallback's RELEASED check. Safe to do here, still under
-                // channelLock: no delivery for the consumer tag just registered above can reach
-                // deliverCallback before this basicConsume call returns.
-                held.remove(target, RELEASED);
                 log.debug("AMQP inbox owns queue {} for target {}", queue, target);
             } catch (IOException e) {
                 throw new IllegalStateException("cannot own queue " + queue, e);
@@ -236,103 +208,18 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
         }
     }
 
-    /**
-     * Release ownership of {@code target}: cancel its consumer, then nack-with-requeue every
-     * delivery still held for it instead of just dropping the local record.
-     *
-     * <p><strong>Cancelling a consumer does not requeue its in-flight deliveries.</strong> In AMQP,
-     * a delivery that was pushed to a consumer stays unacked, attached to the still-open
-     * {@link #channel}, until that channel or the connection closes — {@code basicCancel} alone does
-     * neither. So before this method existed with a requeue step, it dropped {@link #held}'s entries
-     * for {@code target} while the broker still considered them outstanding: never acked, never
-     * nacked, never requeued, and no longer reachable by {@link #peek} — permanently invisible. This
-     * is unlike {@link #handleRecovery} and {@link #close()}, whose bare {@code held.clear()} is
-     * correct because each has already made the broker requeue (a real connection drop, or
-     * {@code channel.close()} respectively) before clearing local state.
-     *
-     * <p><strong>Order: cancel first, then nack.</strong> A delivery tag stays valid for
-     * {@code basicNack} on this channel regardless of whether its consumer is still attached — only
-     * a channel/connection close invalidates it — so cancelling {@code target}'s consumer first does
-     * not risk the tags. Doing it the other way round does: nacking a delivery with {@code requeue}
-     * while its consumer is still active hands the message straight back to that <em>same</em>
-     * consumer the instant a prefetch slot frees up (confirmed against a real broker — see
-     * {@code AmqpReplyInboxContractTest.releaseCancelsConsumerAndRequeuesHeldDeliveryForRecovery}),
-     * which races this method's own {@code held.remove(target)}: the redelivery can land after the
-     * clear and leave a stale entry behind, so {@link #peek} is no longer reliably empty right after
-     * {@link #release}. Cancelling first closes that consumer, so the requeued message goes back to
-     * the queue for whichever consumer picks it up next (a later {@link #own}), not this one.
-     *
-     * <p><strong>Failure of the requeue is best-effort, not fatal.</strong> {@link #release} runs
-     * during teardown ({@code Fleetd} calls it right after {@code MessageService.abandon}), and a
-     * throw here would abort cleanups the caller depends on — the same argument fleetd #293 settled
-     * for {@code HerdrPeerLauncher.stop()}'s tab-close step. So a failed {@code basicNack} is logged
-     * at WARN, naming the target and delivery tag that leaked, and release proceeds; the delivery
-     * stays unacked on the broker rather than being silently dropped, so it is still recoverable by a
-     * later connection drop even though this release did not manage to requeue it immediately. A
-     * failed {@code basicCancel} still throws, unchanged from before this fix — that failure means
-     * the consumer may still be attached, so best-effort requeue is not attempted underneath it.
-     *
-     * <p><strong>CB-318: {@code held.remove(target)} alone leaves a second window open.</strong> The
-     * bullet above already explains why cancelling first does not save a tag from going stale — but
-     * that only accounts for a delivery landing before this method starts touching {@link #held}.
-     * {@code basicCancel} stops <em>new</em> dispatches; it does not flush one already handed to the
-     * consumer work pool. So a delivery can still land on that pool's thread and reach
-     * {@link #deliverCallback} at any point during, or after, this method's body — and a plain
-     * {@code held.remove(target)} does nothing to stop it: {@code deliverCallback}'s
-     * {@code computeIfAbsent} finds the key gone and happily creates a brand-new map under it, which
-     * this method — already past its {@code remove} — never looks at again. That entry then sits
-     * delivered-but-unacked on {@link #channel} until the whole inbox closes: never requeued, never
-     * redelivered, and {@link #peek} is never called again for a target nothing owns any more.
-     *
-     * <p>The fix is {@link #held}{@code .compute(target, ...)} instead of {@code remove}: it takes
-     * whatever was held (to nack, same as before) and, in the same atomic step, leaves the
-     * {@link #RELEASED} tombstone behind instead of an absent key. {@code computeIfAbsent} and
-     * {@code compute} calls for the same key are mutually exclusive in {@link ConcurrentHashMap} —
-     * whichever of this call and a concurrent {@code deliverCallback} runs first is fully visible to
-     * the other, with no gap between them. So a delivery that loses the race sees a real map here and
-     * gets nacked by the loop below, same as always; a delivery that wins the race (runs first) is
-     * itself nacked by that same loop, once it settles into {@code held}. A delivery that arrives once
-     * this method has stored {@link #RELEASED} finds it via {@code computeIfAbsent} and refuses itself
-     * — see {@link #deliverCallback}. Either way nothing is silently retained forever, satisfying the
-     * ticket's invariant against dropping a message. This closes the window rather than merely
-     * narrowing it — correctness does not depend on how much time elapses between the swap and this
-     * method returning.
-     */
     @Override
     public void release(String target) {
         synchronized (channelLock) {
             String tag = consumerTags.remove(target);
-            if (tag != null) {
-                try {
-                    channel.basicCancel(tag);
-                } catch (IOException e) {
-                    throw new IllegalStateException("cannot cancel consumer for " + target, e);
-                }
+            held.remove(target);                   // stale delivery tags must not survive release
+            if (tag == null) {
+                return;
             }
-            AtomicReference<LinkedHashMap<String, Held>> previouslyHeld = new AtomicReference<>();
-            held.compute(target, (_, v) -> {
-                previouslyHeld.set(v);
-                return RELEASED;
-            });
-            var perTarget = previouslyHeld.get();
-            if (perTarget != null && perTarget != RELEASED) {
-                synchronized (perTarget) {
-                    for (Held h : perTarget.values()) {
-                        try {
-                            channel.basicNack(h.deliveryTag(), false, true); // requeue, don't drop
-                        } catch (IOException | RuntimeException e) {
-                            // Caught broadly (not just IOException) for the same reason #293 catches
-                            // RuntimeException in HerdrPeerLauncher.stop(): best-effort teardown must
-                            // not be guarded only against the expected failure and bare against any
-                            // other. The message stays unacked on the broker either way — not lost,
-                            // just not proactively requeued — until a connection drop frees it.
-                            log.warn("release({}): could not requeue held delivery (msgId={}, tag={})"
-                                            + " back to the broker — it stays unacked until a connection"
-                                            + " drop frees it: {}",
-                                    target, h.message().msgId(), h.deliveryTag(), e.getMessage());
-                        }
-                    }
-                }
+            try {
+                channel.basicCancel(tag);
+            } catch (IOException e) {
+                throw new IllegalStateException("cannot cancel consumer for " + target, e);
             }
         }
     }
@@ -385,7 +272,7 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
     @Override
     public List<InboxMessage> peek(String target) {
         var perTarget = held.get(target);
-        if (perTarget == null || perTarget == RELEASED) {
+        if (perTarget == null) {
             return List.of();
         }
         synchronized (perTarget) {
@@ -394,17 +281,17 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
     }
 
     @Override
-    public boolean ack(String target, String msgId) {
+    public void ack(String target, String msgId) {
         var perTarget = held.get(target);
-        if (perTarget == null || perTarget == RELEASED) {
-            return false;
+        if (perTarget == null) {
+            return;
         }
         Held h;
         synchronized (perTarget) {
             h = perTarget.remove(msgId);
         }
         if (h == null) {
-            return false;                          // never held (or already acked) — no-op
+            return;                                // never held (or already acked) — no-op
         }
         try {
             synchronized (channelLock) {
@@ -418,7 +305,6 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
             }
             throw new IllegalStateException("cannot ack reply " + msgId + " on " + queueName(target), e);
         }
-        return true;
     }
 
     private DeliverCallback deliverCallback(String target) {
@@ -430,20 +316,6 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
             }
             String content = new String(delivery.getBody(), StandardCharsets.UTF_8);
             var perTarget = held.computeIfAbsent(target, _ -> new LinkedHashMap<>());
-            if (perTarget == RELEASED) {
-                // CB-318: release() already ran for this target and left the RELEASED tombstone in
-                // held (see release()'s javadoc) — computeIfAbsent() is guaranteed to see it rather
-                // than recreate a fresh map, because ConcurrentHashMap serializes compute/
-                // computeIfAbsent calls for the same key against each other. Refuse the delivery
-                // instead of holding it somewhere release() will never look at again: requeue it, the
-                // same way release() nacks its own held entries, so a later owner (or a connection
-                // drop) can still recover it. This does not need channelLock across a broker round
-                // trip — basicNack, like the duplicate-ack case just below, does not wait for one.
-                synchronized (channelLock) {
-                    channel.basicNack(tag, false, true);
-                }
-                return;
-            }
             boolean duplicate;
             synchronized (perTarget) {
                 if (perTarget.containsKey(msgId)) {
@@ -578,44 +450,3 @@ public final class AmqpReplyInbox implements ReplyInbox, AutoCloseable {
         }
     }
 }
-
-/**
- * Keeps RabbitMQ's forgiving exception behaviour while adding the connection identity that its
- * default logger drops. Package-private so both AMQP connections use the same two names.
- */
-final class AmqpConnectionFailureLogger extends DefaultExceptionHandler {
-
-    static final String REPLY_INBOX = "fleetd-reply-inbox";
-    static final String LEAD_MAILBOX = "fleetd-lead-mailbox";
-
-    private final String connectionName;
-    private final Logger logger;
-
-    AmqpConnectionFailureLogger(String connectionName, Logger logger) {
-        this.connectionName = connectionName;
-        this.logger = logger;
-    }
-
-    String connectionName() {
-        return connectionName;
-    }
-
-    @Override
-    protected void log(String message, Throwable cause) {
-        if (isSocketClosedOrConnectionReset(cause)) {
-            logger.warn("AMQP connection {}: {} (Exception message: {})", connectionName, message, cause.getMessage());
-        } else {
-            logger.error("AMQP connection {}: {}", connectionName, message, cause);
-        }
-    }
-
-    private static boolean isSocketClosedOrConnectionReset(Throwable cause) {
-        // Deliberate copy of ForgivingExceptionHandler's private static helper; check it on amqp-client upgrades.
-        if (!(cause instanceof IOException)) {
-            return false;
-        }
-        return "Connection reset".equals(cause.getMessage())
-                || "Socket closed".equals(cause.getMessage())
-                || "Connection reset by peer".equals(cause.getMessage());
-    }
-}

fleetd/src/main/java/dev/ltms/fleet/msg/InMemoryReplyInbox.java

@@ -59,17 +59,16 @@ public final class InMemoryReplyInbox implements ReplyInbox {
     }
 
     @Override
-    public boolean ack(String target, String msgId) {
+    public void ack(String target, String msgId) {
         if (!owned.contains(target)) {
-            return false;
+            return;
         }
         var perTarget = store.get(target);
-        if (perTarget == null) {
-            return false;
-        }
-        //noinspection SynchronizationOnLocalVariableOrMethodParameter
-        synchronized (perTarget) {
-            return perTarget.remove(msgId) != null;
+        if (perTarget != null) {
+            //noinspection SynchronizationOnLocalVariableOrMethodParameter
+            synchronized (perTarget) {
+                perTarget.remove(msgId);
+            }
         }
     }
 }

fleetd/src/main/java/dev/ltms/fleet/msg/LeadChannel.java

@@ -4,8 +4,8 @@ import java.util.List;
 
 /**
  * The lead-to-lead message channel this daemon speaks, as its callers need it — one lead's own
- * mailbox: publish to a peer's coord-id, look at what has arrived for me, ack what I have
- * delivered, and (fleetd #361) inspect any coord-id's mailbox from the outside without owning it.
+ * mailbox: publish to a peer's coord-id, look at what has arrived for me, and ack what I have
+ * delivered.
  *
  * <p>Extracted from {@link LeadMailbox} purely as a seam. {@code LeadMailbox} is the one production
  * implementation and owns a live AMQP connection, so a test that wanted to exercise the routing in
@@ -32,99 +32,9 @@ public interface LeadChannel {
     /** Non-destructive FIFO snapshot of the messages held for this daemon's own coord-id. */
     List<LeadMessage> peek();
 
-    /**
-     * Drop {@code msgId} from the held set and ack it on the broker. A repeated ack that this
-     * connection already completed may be a no-op. Any other unknown msgId must throw rather than
-     * report an ack that did not reach the broker.
-     */
+    /** Drop {@code msgId} from the held set and ack it on the broker. A no-op if it is not held. */
     void ack(String msgId);
 
     /** This daemon's own lead coordination id — the mailbox it owns, and the {@code from} it sends as. */
     String selfCoordId();
-
-    /**
-     * Whether a message sitting in {@link #peek}'s held set (fetched but not yet {@link #ack}ed) is
-     * still safe if this daemon crashes or restarts right now — the conclusion of two independent
-     * facts about how this channel owns its own queue: the queue was declared <em>durable</em>, and
-     * the consumer that filled {@code held} uses <em>manual ack</em>, so an unacked delivery is still
-     * owned by the broker rather than only in this process's memory. Both must hold for {@code true};
-     * an implementation must derive this from what it actually did when it declared and consumed its
-     * queue, never return a literal — fleetd #440 found {@code FleetMcp}'s {@code heldDurable} field
-     * doing exactly that, unable to ever report {@code false} even after the fact stopped being true.
-     */
-    boolean heldDurable();
-
-    /**
-     * A non-destructive look at {@code coordId}'s mailbox — does it exist, how many messages are
-     * waiting on it, and how many consumers are attached — without owning, consuming, or otherwise
-     * changing it. {@code consumers == 0} on an existing mailbox is the observable form of "nobody
-     * is reading this right now": a publish to it will sit queued rather than reach a pane.
-     *
-     * <p><strong>Never throws</strong> — this is a best-effort fact-finding call, not an operation a
-     * caller must handle failing. But it must never turn "I could not check" into a false negative:
-     * {@link MailboxState#absent(String)} means the broker positively confirmed there is no such
-     * queue, and {@link MailboxState#unknown(String)} — a distinct value — means the look could not
-     * be completed at all (broker unreachable, timed out, connection closed). A caller that
-     * collapses those two into one, as fleetd #361 initially did, cannot tell "that peer is down"
-     * from "I could not check", and a reader of {@code pending}/{@code consumers} cannot tell a
-     * measured zero from a zero standing in for "not measured".
-     *
-     * <p><strong>Must never share fate with {@link #publish} or {@link #peek}/{@link #ack}.</strong>
-     * fleetd #361: in AMQP 0-9-1 a passive queue declare of a queue that does not exist closes the
-     * channel it was declared on with a 404. An implementation backed by a real broker connection
-     * must inspect on a channel it can afford to lose — never the channel {@link #publish} or the
-     * consume loop depends on — so that looking at a peer that happens to be down can never break
-     * this daemon's own send or receive path.
-     */
-    MailboxState inspect(String coordId);
-
-    /**
-     * The result of {@link #inspect}. {@code presence} tells apart three states a caller must not
-     * conflate: a confirmed-existing mailbox ({@link Presence#EXISTS}, the only case where
-     * {@code pending}/{@code consumers} are measured facts), a confirmed-absent one
-     * ({@link Presence#ABSENT} — the broker positively said "no such queue"), and one this call
-     * simply could not determine ({@link Presence#UNKNOWN} — broker unreachable, timed out,
-     * connection closed). {@code pending}/{@code consumers} are always {@code 0} and meaningless
-     * outside {@link Presence#EXISTS}; a renderer must gate on {@link #exists()} (or {@code
-     * presence} directly), never present them as measured otherwise.
-     *
-     * @param coordId   the coord-id inspected
-     * @param presence  whether the mailbox is confirmed to exist, confirmed absent, or unknown
-     * @param pending   messages ready for delivery but not yet in a consumer's hands (0 unless EXISTS)
-     * @param consumers how many consumers are attached (0 unless EXISTS)
-     */
-    record MailboxState(String coordId, Presence presence, int pending, int consumers) {
-
-        /** Whether {@link #inspect} was able to reach a definite answer, of either kind. */
-        public enum Presence { EXISTS, ABSENT, UNKNOWN }
-
-        /** {@code true} only when the broker confirmed this exact queue is currently declared. */
-        public boolean exists() {
-            return presence == Presence.EXISTS;
-        }
-
-        /**
-         * {@code true} when {@link #inspect} reached a definite answer (exists or confirmed
-         * absent); {@code false} when it could not determine either way. A caller must never treat
-         * {@code !known()} the same as a confirmed absence — the mailbox may well exist.
-         */
-        public boolean known() {
-            return presence != Presence.UNKNOWN;
-        }
-
-        /** The broker confirmed this queue exists, with these measured counts. */
-        public static MailboxState exists(String coordId, int pending, int consumers) {
-            return new MailboxState(coordId, Presence.EXISTS, pending, consumers);
-        }
-
-        /** The broker positively confirmed there is no such queue (e.g. a 404 on passive declare). */
-        public static MailboxState absent(String coordId) {
-            return new MailboxState(coordId, Presence.ABSENT, 0, 0);
-        }
-
-        /** The look could not be completed — broker unreachable, timed out, or connection closed. */
-        public static MailboxState unknown(String coordId) {
-            return new MailboxState(coordId, Presence.UNKNOWN, 0, 0);
-        }
-    }
 }

fleetd/src/main/java/dev/ltms/fleet/msg/LeadCoordLoop.java

@@ -5,7 +5,6 @@ import dev.ltms.fleet.herdr.AgentStatus;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ScheduledExecutorService;
@@ -44,9 +43,6 @@ public final class LeadCoordLoop {
 
     private static final Logger log = LoggerFactory.getLogger(LeadCoordLoop.class);
 
-    /** A bounded window is enough: redelivery can only follow a recent failed ack or recovery. */
-    private static final int RECENT_DELIVERY_LIMIT = 1_024;
-
     /** How an arriving peer message is rendered into the lead's pane — the sender's coord-id, then its text. */
     static final String DELIVERY_FORMAT = "[lead %s] %s";
 
@@ -55,8 +51,6 @@ public final class LeadCoordLoop {
     private final Supplier<Map<String, String>> leads;
     private final ScheduledExecutorService scheduler;
     private final long intervalMs;
-    /** msgIds already written to the pane, so recovery redelivery is acked without another pane write. */
-    private final LinkedHashMap<String, Boolean> delivered = new LinkedHashMap<>();
 
     private volatile boolean running;
 
@@ -123,13 +117,6 @@ public final class LeadCoordLoop {
         if (held.isEmpty()) {
             return;
         }
-        LeadMessage msg = held.getFirst();
-        if (wasDelivered(msg.msgId())) {
-            // This lives here, rather than in LeadMailbox, because only this loop knows a pane write
-            // happened. The mailbox only knows broker delivery tags and must still redeliver after a crash.
-            ackDelivered(msg);
-            return;
-        }
         String lead = resolveLocalLead();
         if (lead == null) {
             // Left unacked on purpose: the broker keeps holding it until a lead pane exists.
@@ -149,6 +136,7 @@ public final class LeadCoordLoop {
                     lead, status, held.size());
             return;
         }
+        LeadMessage msg = held.getFirst();
         try {
             agents.send(lead, DELIVERY_FORMAT.formatted(msg.from(), msg.content()));
         } catch (RuntimeException e) {
@@ -157,13 +145,6 @@ public final class LeadCoordLoop {
                     msg.msgId(), msg.from(), lead, e.toString());
             return;
         }
-        rememberDelivered(msg.msgId());
-        if (ackDelivered(msg)) {
-            log.debug("lead coordination: delivered message {} from {} to lead {}", msg.msgId(), msg.from(), lead);
-        }
-    }
-
-    private boolean ackDelivered(LeadMessage msg) {
         try {
             channel.ack(msg.msgId());
         } catch (RuntimeException e) {
@@ -171,24 +152,9 @@ public final class LeadCoordLoop {
             // deliberate direction of this trade.
             log.warn("lead coordination: delivered message {} but could not ack it: {}",
                     msg.msgId(), e.toString());
-            return false;
-        }
-        return true;
-    }
-
-    private boolean wasDelivered(String msgId) {
-        synchronized (delivered) {
-            return delivered.containsKey(msgId);
-        }
-    }
-
-    private void rememberDelivered(String msgId) {
-        synchronized (delivered) {
-            delivered.put(msgId, Boolean.TRUE);
-            if (delivered.size() > RECENT_DELIVERY_LIMIT) {
-                delivered.remove(delivered.keySet().iterator().next());
-            }
+            return;
         }
+        log.debug("lead coordination: delivered message {} from {} to lead {}", msg.msgId(), msg.from(), lead);
     }
 
     /**

fleetd/src/main/java/dev/ltms/fleet/msg/LeadHeartbeatLoop.java

@@ -96,14 +96,7 @@ public final class LeadHeartbeatLoop {
         this.metrics = metrics;
     }
 
-    /**
-     * Count one nudge outcome when a registry is wired; a no-op in unit tests.
-     *
-     * <p>fleetd #365: the {@code "sent"} outcome (renamed from {@code "delivered"}) records only
-     * that {@link #injectNudge} — a one-way herdr {@code agent.prompt} paste-and-submit — returned
-     * without throwing, not that the lead's pane actually read or acted on the text. This layer has
-     * no read-receipt concept, so "sent" is the honest word for what this call can ever establish.
-     */
+    /** Count one nudge outcome when a registry is wired; a no-op in unit tests. */
     private void countNudge(String outcome) {
         if (metrics != null) {
             metrics.inc(FleetMetrics.HEARTBEAT_NUDGES, "outcome", outcome);
@@ -252,7 +245,7 @@ public final class LeadHeartbeatLoop {
             agents.send(leadTerminal, fleet.nudgeText());
             log.debug("idle-heartbeat: nudge sent to lead {} (quiet nudges so far in this stretch: {})",
                     leadTerminal, quietCount);
-            countNudge("sent");
+            countNudge("delivered");
         } catch (RuntimeException e) {
             log.warn("idle-heartbeat: failed to nudge lead {}: {}", leadTerminal, e.toString());
             countNudge("failed");

fleetd/src/main/java/dev/ltms/fleet/msg/LeadMailbox.java

@@ -10,7 +10,6 @@ import com.rabbitmq.client.DeliverCallback;
 import com.rabbitmq.client.Recoverable;
 import com.rabbitmq.client.RecoveryListener;
 import com.rabbitmq.client.Return;
-import com.rabbitmq.client.ShutdownSignalException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -59,8 +58,7 @@ import java.util.concurrent.TimeoutException;
  * <p><strong>Recovery.</strong> The connection is opened with automatic + topology recovery
  * enabled, mirroring {@code AmqpReplyInbox}: on reconnect the broker hands out fresh delivery tags,
  * so the held snapshot is cleared (dedup by {@code msgId} still prevents any double-queue on
- * redelivery). {@link LeadCoordLoop} separately deduplicates pane writes, since it alone knows
- * which messages reached a lead. Any publish still awaiting its confirm is failed rather than left to idle out
+ * redelivery) and any publish still awaiting its confirm is failed rather than left to idle out
  * the confirm timeout against a sequence number that means nothing on the new channel.
  */
 public final class LeadMailbox implements LeadChannel, AutoCloseable {
@@ -86,16 +84,6 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
     private final Object channelLock = new Object();
     /** msgId → held delivery, for this mailbox's own queue only (there is exactly one). */
     private final LinkedHashMap<String, Held> held = new LinkedHashMap<>();
-    /**
-     * fleetd #440: the answer to {@link #heldDurable()}, set once by {@link #own()} from the exact
-     * booleans it passed to {@code queueDeclare}/{@code basicConsume} — never a separate literal that
-     * could drift from what those calls actually did.
-     */
-    private boolean heldDurable;
-    /** Successful broker acks on this connection, retained only to make a repeated caller ack quiet. */
-    private final LinkedHashMap<String, Boolean> recentlyAcked = new LinkedHashMap<>();
-    /** Bounds {@link #recentlyAcked}: it is only an idempotency aid, never delivery state. */
-    private static final int RECENT_ACK_LIMIT = 1_024;
 
     /**
      * A dedicated channel for {@link #publish}, kept separate from {@link #channel} (consume + ack)
@@ -134,22 +122,17 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
     /** As {@link #open(String, String)}, with an explicit consumer prefetch. */
     public static LeadMailbox open(String uri, String selfCoordId, int prefetch) {
         try {
-            return new LeadMailbox(connectionFactory(uri).newConnection(AmqpConnectionFailureLogger.LEAD_MAILBOX), selfCoordId, prefetch);
+            ConnectionFactory factory = new ConnectionFactory();
+            factory.setUri(uri);
+            // Self-heal transient blips; topology recovery re-declares the queue and re-attaches the consumer.
+            factory.setAutomaticRecoveryEnabled(true);
+            factory.setTopologyRecoveryEnabled(true);
+            return new LeadMailbox(factory.newConnection("fleetd-lead-mailbox"), selfCoordId, prefetch);
         } catch (Exception e) {
             throw new IllegalStateException("cannot connect to AMQP coordination broker at " + uri, e);
         }
     }
 
-    static ConnectionFactory connectionFactory(String uri) throws Exception {
-        ConnectionFactory factory = new ConnectionFactory();
-        factory.setUri(uri);
-        // Self-heal transient blips; topology recovery re-declares queues and re-attaches consumers.
-        factory.setAutomaticRecoveryEnabled(true);
-        factory.setTopologyRecoveryEnabled(true);
-        factory.setExceptionHandler(new AmqpConnectionFailureLogger(AmqpConnectionFailureLogger.LEAD_MAILBOX, log));
-        return factory;
-    }
-
     /** Wrap an already-open connection with {@link #DEFAULT_PREFETCH} (injection seam for tests). */
     LeadMailbox(Connection connection, String selfCoordId) {
         this(connection, selfCoordId, DEFAULT_PREFETCH);
@@ -173,15 +156,16 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
         }
         // On automatic recovery the broker redelivers unacked messages with FRESH delivery-tags; the
         // tags we were holding are now stale. Drop the held snapshot so the re-attached consumer
-        // repopulates it with valid tags (dedup by msgId still prevents any double-queue). LeadCoordLoop
-        // remembers successful pane writes separately, so that redelivery cannot write a pane twice. Any publish
+        // repopulates it with valid tags (dedup by msgId still prevents any double-queue). Any publish
         // confirm still in flight when the connection dropped is equally stale — fail it now rather
         // than let it silently ride out CONFIRM_TIMEOUT_MS.
         if (connection instanceof Recoverable recoverable) {
             recoverable.addRecoveryListener(new RecoveryListener() {
                 @Override
                 public void handleRecovery(Recoverable recoverable) {
-                    clearHeldForRecovery();
+                    synchronized (held) {
+                        held.clear();
+                    }
                     failPendingPublishesOnRecovery();
                     log.info("AMQP lead mailbox connection recovered; cleared held messages for fresh redelivery");
                 }
@@ -197,22 +181,13 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
     /** Declare + consume this daemon's own {@code lead.<selfCoordId>.inbox}. Called once, at construction. */
     private void own() throws IOException {
         String queue = queueName(selfCoordId);
-        boolean durableQueue = true; // durable, non-exclusive, keep on idle
-        boolean autoAck = false; // manual ack
         synchronized (channelLock) {
-            channel.queueDeclare(queue, durableQueue, false, false, null);
-            channel.basicConsume(queue, autoAck, deliverCallback(), _ -> { });
+            channel.queueDeclare(queue, true, false, false, null); // durable, non-exclusive, keep on idle
+            channel.basicConsume(queue, false, deliverCallback(), _ -> { }); // autoAck=false: manual ack
         }
-        // fleetd #440: held mail is durable only while both hold — a durable queue AND manual ack.
-        this.heldDurable = durableQueue && !autoAck;
         log.debug("lead mailbox owns queue {} for coord-id {}", queue, selfCoordId);
     }
 
-    @Override
-    public boolean heldDurable() {
-        return heldDurable;
-    }
-
     /**
      * Publish {@code msg} to {@code toCoordId}'s mailbox and block until the broker's publisher
      * confirm for it lands. Does <em>not</em> imply owning or consuming {@code toCoordId}'s queue.
@@ -279,89 +254,6 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
         }
     }
 
-    /**
-     * fleetd #361: look at {@code coordId}'s mailbox on a fresh, immediately-closed throwaway
-     * channel — never {@link #channel} (consume/ack) or {@link #publishChannel} (publish). A
-     * passive queue declare of a queue that does not exist closes the channel it was declared on
-     * with a 404; using a disposable probe channel means that closure can never touch either
-     * long-lived channel this instance depends on for {@link #publish} or the consume loop.
-     *
-     * <p>Classifies failures rather than collapsing them, both measured against a real broker in
-     * {@code LeadMailboxTest} rather than assumed from the AMQP 0-9-1 spec text:
-     * <ul>
-     *   <li>a genuine 404 — an {@link IOException} wrapping a {@link ShutdownSignalException} whose
-     *       {@link AMQP.Channel.Close#getReplyCode()} is {@code 404} — reports
-     *       {@link MailboxState#absent}; every other declare failure reports
-     *       {@link MailboxState#unknown} instead of quietly becoming the same "absent" value;
-     *   <li>{@code catch (RuntimeException e)} on both attempts matters as much as the checked
-     *       catches: a connection that is already closed makes {@link Connection#createChannel()}
-     *       throw {@link com.rabbitmq.client.AlreadyClosedException} (a {@link RuntimeException},
-     *       not an {@link IOException}) — an {@code inspect} that only caught {@code IOException}
-     *       would let that escape, breaking the "never throws" contract this method promises.
-     * </ul>
-     *
-     * <p><strong>Honesty about which catch is measured and which is defensive:</strong> the
-     * {@code createChannel()} catch above is exercised end-to-end against a real broker by
-     * {@code LeadMailboxTest.inspectReportsUnknownRatherThanThrowingWhenTheConnectionIsAlreadyClosed}.
-     * The second {@code catch (RuntimeException e)}, around the passive declare itself — for the
-     * narrower race where the connection drops <em>between</em> {@code createChannel()} succeeding
-     * and the declare landing — has no such test; reaching it needs a connection that dies at that
-     * exact instant, which is not a scenario this suite drives on purpose. It stays purely
-     * defensive: correct by the same reasoning as the first catch, but unproven the way the first
-     * one is proven.
-     */
-    @Override
-    public MailboxState inspect(String coordId) {
-        String queue = queueName(coordId);
-        Channel probe;
-        try {
-            probe = connection.createChannel();
-        } catch (IOException | RuntimeException e) {
-            log.debug("lead mailbox inspect: cannot open a probe channel for {}: {}", coordId, e.toString());
-            return MailboxState.unknown(coordId);
-        }
-        try {
-            AMQP.Queue.DeclareOk declared = probe.queueDeclarePassive(queue);
-            return MailboxState.exists(coordId, declared.getMessageCount(), declared.getConsumerCount());
-        } catch (IOException e) {
-            // The broker (or the client library) has already closed `probe` for us either way; only
-            // a confirmed 404 means "no such queue" — anything else (a different declare failure) is
-            // "could not determine", never silently reported as the same value as a genuine absence.
-            return isMissingQueue(e) ? MailboxState.absent(coordId) : MailboxState.unknown(coordId);
-        } catch (RuntimeException e) {
-            // E.g. the connection dropped between createChannel() and the declare landing.
-            log.debug("lead mailbox inspect: declare failed unexpectedly for {}: {}", coordId, e.toString());
-            return MailboxState.unknown(coordId);
-        } finally {
-            try {
-                if (probe.isOpen()) {
-                    probe.close();
-                }
-            } catch (Exception e) {
-                log.debug("lead mailbox inspect: probe channel close for {}: {}", coordId, e.toString());
-            }
-        }
-    }
-
-    /**
-     * {@code true} only for the specific shape a missing-queue passive declare actually produces —
-     * measured against a real broker, not assumed from the spec text (see {@code
-     * LeadMailboxTest.passiveDeclareOfAMissingQueueThrowsAnIOExceptionWrappingA404ShutdownSignal}):
-     * an {@link IOException} whose cause is a {@link ShutdownSignalException} carrying an
-     * {@link AMQP.Channel.Close} reason with {@code replyCode == 404}. Any other shape (a different
-     * reply code, a {@code ShutdownSignalException} cause whose reason is not a
-     * {@code Channel.Close}, or no cause at all) is a declare failure of some other kind and must
-     * not be read as "confirmed absent" — pinned hermetically, with no broker needed, by
-     * {@code LeadMailboxIsMissingQueueTest} for exactly those three false shapes. Package-private
-     * (not {@code private}) so that test can call it directly.
-     */
-    static boolean isMissingQueue(IOException e) {
-        if (!(e.getCause() instanceof ShutdownSignalException sse)) {
-            return false;
-        }
-        return sse.getReason() instanceof AMQP.Channel.Close close && close.getReplyCode() == AMQP.NOT_FOUND;
-    }
-
     /** Convenience: {@link #peek} the current snapshot, then {@link #ack} every message in it. */
     public List<LeadMessage> drain() {
         List<LeadMessage> snapshot = peek();
@@ -369,26 +261,15 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
         return snapshot;
     }
 
-    /**
-     * Remove the held message {@code msgId} and ack it on the broker.
-     *
-     * <p>A repeated ack that this connection already completed is a no-op, tracked in the bounded
-     * {@link #recentlyAcked} set. Any other missing entry throws: recovery clears {@link #held} while
-     * the broker still owns the unacked delivery, and quiet success there would hide a required retry.
-     * The set is bounded because it only distinguishes a recent duplicate caller ack from an unknown
-     * delivery; it is not a substitute for broker state across a reconnect.
-     */
+    /** Remove the held message {@code msgId} and ack it on the broker. No-op if not held. */
     @Override
     public void ack(String msgId) {
         Held h;
         synchronized (held) {
             h = held.remove(msgId);
-            if (h == null && recentlyAcked.containsKey(msgId)) {
-                return;
-            }
         }
         if (h == null) {
-            throw new IllegalStateException("cannot ack lead message " + msgId + ": it is not held");
+            return;                                // never held (or already acked) — no-op
         }
         try {
             synchronized (channelLock) {
@@ -402,19 +283,6 @@ public final class LeadMailbox implements LeadChannel, AutoCloseable {
             }
             throw new IllegalStateException("cannot ack lead message " + msgId, e);
         }
-        synchronized (held) {
-            recentlyAcked.put(msgId, Boolean.TRUE);
-            if (recentlyAcked.size() > RECENT_ACK_LIMIT) {
-                recentlyAcked.remove(recentlyAcked.keySet().iterator().next());
-            }
-        }
-    }
-
-    /** Clear stale delivery tags after recovery; package-private so the recovery contract test drives this exact path. */
-    void clearHeldForRecovery() {
-        synchronized (held) {
-            held.clear();
-        }
     }
 
     private DeliverCallback deliverCallback() {

fleetd/src/main/java/dev/ltms/fleet/msg/MessageService.java

@@ -138,53 +138,6 @@ public final class MessageService {
     public record AskResult(AskOutcome outcome, String answer) {
     }
 
-    /**
-     * How a worker's {@code fleet_reply} ({@link #reply(String, String)}) actually landed
-     * (fleetd #365) — the two doors that expose it, {@code fleet_reply} and {@code POST
-     * /sessions/{id}/reply}, both used to report the single word "delivered" whichever of these
-     * happened, so a caller could not tell an active handoff from a reply merely held for later
-     * drain. Both are successes; they are not the same fact.
-     */
-    public enum ReplyOutcome {
-        /** Resolved a {@code fleet_send}/{@code fleet_ask} that was actively waiting on this reply. */
-        RESOLVED_SEND("resolved_send", true,
-                "delivered — resolved the fleet_send that was waiting for it"),
-        /**
-         * No live waiter was open, but the reply completed a parked async ticket directly
-         * ({@link #askAnsweredAsyncTasks}) — a {@code fleet_poll} caller sees it immediately.
-         */
-        RESOLVED_ASYNC_TICKET("resolved_async_ticket", true,
-                "delivered — resolved a pending async ticket (visible to fleet_poll)"),
-        /** Nothing was waiting; the reply was queued in the inbox for a later drain (CB-307). */
-        QUEUED("queued", false,
-                "queued — no send or ticket was waiting; held in the inbox for a later drain");
-
-        private final String wireName;
-        private final boolean delivered;
-        private final String description;
-
-        ReplyOutcome(String wireName, boolean delivered, String description) {
-            this.wireName = wireName;
-            this.delivered = delivered;
-            this.description = description;
-        }
-
-        /** Stable machine-readable name for a JSON/metrics label (REST's {@code outcome} field). */
-        public String wireName() {
-            return wireName;
-        }
-
-        /** Whether something was actively waiting and received this reply right now. */
-        public boolean delivered() {
-            return delivered;
-        }
-
-        /** Shared human-readable text — the one place both {@code fleet_reply} and REST word this. */
-        public String description() {
-            return description;
-        }
-    }
-
     /** Lifecycle phase of an async delegation ticket. */
     public enum Phase {
         /** Delegated and in flight — queued for the worker or being worked. */
@@ -234,24 +187,6 @@ public final class MessageService {
         private volatile Long completedNanos;
         private volatile Reply question;
         private volatile String turnId;
-        /**
-         * Set when this task's {@code fleet_ask} lapsed with no answer (fleetd #307):
-         * {@link #clearAsyncQuestion} then forgets {@link #turnId} (nulls it and drops the task from
-         * {@code asyncTasksByTurn}) so {@link #hasAsyncQuestion} stops reporting the target BUSY — a
-         * later {@code fleet_send} to it must be accepted, not refused. But the worker's turn is
-         * still genuinely live: it resumed on its own and will eventually call its real
-         * {@code fleet_reply}. Losing {@link #turnId} loses {@link #askAnsweredAsyncTasks}' only
-         * signal that such a reply belongs to this task, so that reply used to fall straight to the
-         * inbox and strand — {@code fleet_poll} stayed {@code PENDING} forever, later force-failed by
-         * {@link #abandon} with the misleading "session released before it replied". This flag is a
-         * second, independent signal that survives the forgetting: {@link #askAnsweredAsyncTasks}
-         * accepts it in place of a live {@link #turnId}, without ever re-adding the task to
-         * {@code asyncTasksByTurn} (so the BUSY release is untouched). Cleared implicitly once
-         * {@link #future} resolves — every match in {@link #askAnsweredAsyncTasks} already requires
-         * {@code !future.isDone()}, so a task that recovered (or was later failed by
-         * {@link #abandon}) can never match again regardless of this flag's value.
-         */
-        private volatile boolean askTimedOut;
 
         private Task(String ticket, String target, LongSupplier nowNanos) {
             this.ticket = ticket;
@@ -460,73 +395,45 @@ public final class MessageService {
      * {@link Rendezvous#resolveQuestion} must keep today's {@code NO_WAITER} behaviour — questions
      * are interactive and must never be queued.
      *
-     * <p><strong>Ambiguous match also falls to the inbox.</strong> {@link #askAnsweredAsyncTasks} can
-     * return more than one entry — a reachable state, not a hypothetical one (see its own javadoc:
-     * an {@code fleet_ask} that lapsed with no answer, fleetd #307, frees the target for a completely fresh
-     * delegation, which can itself go on to ask-and-lapse before the first worker's real reply
-     * arrives). Returning whichever candidate a {@code ConcurrentHashMap} iteration reaches first
-     * would let a genuine reply complete the <em>wrong</em> ticket — silently handing the lead
-     * something that reads like a correct answer to a delegation the worker never touched, which is
-     * worse than a failure because the lead acts on it. When more than one candidate exists, guessing
-     * is not safe: fall back to the inbox exactly as the zero-candidate case does, and let
-     * {@link #abandon} apply the eventual recovery deterministically instead.
+     * <p><strong>Ambiguous match also falls to the inbox.</strong> {@link #askAnsweredAsyncTasks}
+     * cannot actually return more than one entry today (see its own javadoc for why — in short,
+     * {@link #hasAsyncQuestion} keeps a target BUSY, so no second task can reach this state, for as
+     * long as an earlier one's {@code turnId} is still stamped). That is an emergent guarantee from
+     * two other facts, not one this method enforces, so this branch stays in as defence in depth
+     * rather than being removed as dead code: if it ever weakens, returning whichever candidate a
+     * {@code ConcurrentHashMap} iteration reaches first would let a genuine reply complete the
+     * <em>wrong</em> ticket — silently handing the lead something that reads like a correct answer to
+     * a delegation the worker never touched, which is worse than a failure because the lead acts on
+     * it. When more than one candidate exists, guessing is not safe: fall back to the inbox exactly
+     * as the zero-candidate case does, and let {@link #abandon} apply the eventual recovery
+     * deterministically instead.
      *
-     * <p><strong>{@code content} is required (fleetd #302).</strong> Both doors that reach this
-     * method must reject a missing/blank reply the same way, so the check lives here rather than in
-     * either caller: {@code FleetMcp.reply} already refuses a {@code null} content before it ever
-     * calls this method (its own required-arg guard), and no test or production call site anywhere
-     * in the codebase relies on replying with empty content — confirmed by searching every call site
-     * of this method before adding the check, not assumed. Without this guard, a REST {@code
-     * POST /sessions/{id}/reply} whose body omits {@code content} (or a client library that maps a
-     * missing field to {@code ""}) used to reach {@link Rendezvous#resolve} with an empty string,
-     * silently completing the lead's blocking wait with nothing — indistinguishable from a worker
-     * that genuinely replied with nothing, which is worse than a loud failure because it destroys the
-     * information that the reply never arrived.
-     *
-     * @throws IllegalArgumentException if {@code content} is {@code null} or blank — the caller must
-     *         report this as a client error (REST: 400 {@code bad_request}) rather than resolve
-     *         anything
-     * @return which of the three ways (fleetd #365) the reply actually landed — never {@code null}
+     * @return always {@code true} — the reply resolved a live send, completed a parked ticket, or
+     *         was queued
      */
-    public ReplyOutcome reply(String session, String content) {
-        if (content == null || content.isBlank()) {
-            throw new IllegalArgumentException("content is required");
-        }
+    public boolean reply(String session, String content) {
         if (rendezvous.resolve(session, content)) {
             count(FleetMetrics.REPLIES, "path", "rendezvous");
-            return ReplyOutcome.RESOLVED_SEND; // a live send took it — unchanged fast path
+            return true;                       // a live send took it — unchanged fast path
         }
-        // #137/fleetd #307: no live rendezvous waiter, but this may be the worker's real fleet_reply resuming
-        // a turn that either answer() (#137) or ask() (fleetd #307) already gave up waiting on:
-        //  - answer()'s own bounded wait (the primary's fleet_send{turnId} call, capped well under a
-        //    minute) can time out and close its waiter long before the worker — now actually resuming
-        //    real work — finishes and replies.
-        //  - ask()'s own wait for the primary can time out first, with the worker resuming on its own
-        //    and finishing unanswered.
-        // Either way that reply used to have nowhere to land but the session inbox, leaving the async
-        // ticket's future unresolved forever: fleet_poll{ticket} stayed PENDING until fleet_stop's
-        // abandon() forced it FAILED with a misleading "session released before it replied" reason,
-        // even though the reply had, in fact, arrived. Completing the matching ticket directly here
-        // means fleet_poll{ticket} sees the real reply instead.
+        // #137: no live rendezvous waiter, but this may be the worker's real fleet_reply resuming a
+        // turn that {@link #answer} already gave up waiting on. answer()'s own bounded wait (the
+        // primary's fleet_send{turnId} call, capped well under a minute) can time out and close its
+        // waiter long before the worker — now actually resuming real work — finishes and replies. That
+        // reply used to have nowhere to land but the session inbox, leaving the async ticket's future
+        // unresolved forever: fleet_poll{ticket} stayed PENDING until fleet_stop's abandon() forced it
+        // FAILED with a misleading "session released before it replied" reason, even though the reply
+        // had, in fact, arrived. Completing the matching ticket directly here means fleet_poll{ticket}
+        // sees the real reply instead.
         List<Task> candidates = askAnsweredAsyncTasks(session);
         if (candidates.size() == 1) {
             Task orphan = candidates.get(0);
             if (orphan.future.complete(new Reply(Outcome.REPLIED, content))) {
-                // fleetd #329 (F3): read orphan.turnId once. It used to be read twice, under no
-                // lock — once for this null check, once as the removal key — the same double-read
-                // shape fleetd #324 fixed in finishAsyncTask. clearAsyncQuestion's unlocked
-                // forgetTurn=true path (ask()'s timeout cleanup) can null the field between the two
-                // reads; capturing it once removes the torn read here too.
-                String turnId = orphan.turnId;
-                if (turnId != null) {
-                    if (replyOrphanTurnIdRaceHookForTest != null) {
-                        // Test-only (fleetd #329, F3): see the field's own javadoc.
-                        replyOrphanTurnIdRaceHookForTest.run();
-                    }
-                    asyncTasksByTurn.remove(turnId, orphan);
+                if (orphan.turnId != null) {
+                    asyncTasksByTurn.remove(orphan.turnId, orphan);
                 }
                 count(FleetMetrics.REPLIES, "path", "async-recovered");
-                return ReplyOutcome.RESOLVED_ASYNC_TICKET; // the ticket itself took it — no inbox stranding
+                return true;                   // the ticket itself took it — no inbox stranding at all
             }
         } else if (candidates.size() > 1) {
             List<String> tickets = candidates.stream().map(t -> t.ticket).toList();
@@ -544,46 +451,38 @@ public final class MessageService {
         if (pushLoop != null) {
             pushLoop.onReplyQueued(session);
         }
-        return ReplyOutcome.QUEUED;             // held, not lost — but not delivered either
+        return true;                           // held, not lost
     }
 
     /**
-     * Every still-open async task on {@code target} whose worker is genuinely expected to send a
-     * real {@code fleet_reply} next with nothing left registered to catch it: either its
-     * {@code fleet_ask} was already answered — {@link Task#turnId} is stamped but {@link
-     * Task#question} was cleared by {@link #answer} — or its {@code fleet_ask} lapsed unanswered and
-     * {@link Task#askTimedOut} marks that (fleetd #307; {@link Task#turnId} is {@code null} by then, forgotten
-     * so the target is not left BUSY — see {@link Task#askTimedOut}'s own javadoc). Either way the
-     * task's future is not resolved yet. Empty if no such task exists, including the common case
-     * where {@code target}'s worker never used {@code fleet_ask} at all (a task that was never asked
-     * has both {@code turnId == null} and {@code askTimedOut == false}, so it can never match here and
-     * only ever completes through the ordinary rendezvous fast path in {@link #reply}).
+     * Every still-open async task on {@code target} whose {@code fleet_ask} was already answered —
+     * its {@link Task#turnId} is stamped but its {@link Task#question} was cleared by {@link #answer}
+     * — yet whose future is not resolved yet (#137). Empty if no such task exists, including the
+     * common case where {@code target}'s worker never used {@code fleet_ask} at all (a task that was
+     * never asked has {@code turnId == null}, so it can never match here and only ever completes
+     * through the ordinary rendezvous fast path in {@link #reply}).
      *
-     * <p><strong>Can return more than one entry — reachable, not just defence in depth.</strong>
-     * {@link #send} refuses to open a waiter on {@code target} while {@link #hasAsyncQuestion} is
-     * true, and that check matches ANY task whose {@code turnId} is still stamped in
-     * {@code asyncTasksByTurn}. While a task's {@code turnId} stays stamped — {@link #answer} leaves
-     * it in place ({@code clearAsyncQuestion(turnId, false)}) until {@link #finishAsyncTask} removes
-     * the stamp and completes the future in the same call — no second task on the same target can
-     * reach an eligible state, because {@link #send} would refuse it as BUSY first. That single-task
-     * guarantee holds only for the {@code turnId}-stamped half of this method's match: an
-     * {@link Task#askTimedOut} task is, by construction, no longer stamped in {@code asyncTasksByTurn}
-     * (that is the whole point of forgetting {@code turnId} in {@link #clearAsyncQuestion}), so the
-     * target is free the moment one ask lapses. A fresh, independent {@code sendAsync} to the same
-     * target can then be dispatched, itself pause on {@code fleet_ask}, and itself time out — landing
-     * a second {@code askTimedOut} task on the very target the first one is still waiting to answer
-     * for. Two (or more) genuinely open tasks on one target is therefore a real, reachable state
-     * today, not a hypothetical: {@link #reply} treats it as unresolvable and falls back to the
-     * inbox rather than guess which task a reply belongs to (guessing wrong would hand the lead a
-     * plausible-looking answer to a delegation the worker never touched — worse than a failure,
-     * because the lead acts on it); {@link #abandon} instead picks the oldest deterministically (its
-     * own {@code matching} list has a different, wider match — see its javadoc).
+     * <p><strong>Returns at most one entry today — verified, not assumed.</strong> {@link #send}
+     * refuses to open a waiter on {@code target} while {@link #hasAsyncQuestion} is true, and that
+     * check matches ANY task whose {@code turnId} is still stamped in {@code asyncTasksByTurn} —
+     * not only while its question is still open. {@link #answer} deliberately leaves that stamp in
+     * place ({@code clearAsyncQuestion(turnId, false)}) until the resumed turn's own future actually
+     * resolves, at which point {@link #finishAsyncTask} both removes the stamp AND completes that
+     * task's future in the same call. So a second task can never reach "{@code turnId} stamped, future
+     * still open" — the exact pair this method matches on — while a first one already holds it: by
+     * the time the stamp is gone, so is the eligibility. This is an emergent property of those two
+     * facts holding together, not something this method (or its callers) enforces on its own — flip
+     * {@code forgetTurn} to {@code true} in that one {@link #answer} call and it silently stops being
+     * true, with nothing left to fail loudly. The callers below still handle "more than one" as
+     * defence in depth against exactly that, not because they exercise it today: {@link #reply}
+     * treats it as unresolvable and falls back to the inbox; {@link #abandon} would pick the oldest
+     * deterministically (its own {@code matching} list has no such guarantee — see its javadoc).
      */
     private List<Task> askAnsweredAsyncTasks(String target) {
         List<Task> candidates = new ArrayList<>();
         for (Task task : tasks.values()) {
-            if (target.equals(task.target) && task.question == null && !task.future.isDone()
-                    && (task.turnId != null || task.askTimedOut)) {
+            if (target.equals(task.target) && task.question == null && task.turnId != null
+                    && !task.future.isDone()) {
                 candidates.add(task);
             }
         }
@@ -755,47 +654,27 @@ public final class MessageService {
             boolean isRecovery = task == recoveryTask && recovered != null;
             Reply outcome = isRecovery ? recovered : new Reply(Outcome.WORKER_FAILED, reason);
             String turnId = task.turnId;
-            // fleetd #335: completing THIS task's future must not depend on any other task's
-            // cleanup succeeding — every task in `matching` is owed its own outcome regardless of
-            // what happens below, so decide and record that before doing anything that can throw.
-            boolean completedHere = task.future.complete(outcome);
-            if (completedHere && outcome.outcome() == Outcome.WORKER_FAILED) {
-                asyncFailed = true;
-            }
-            try {
-                if (abandonCleanupHookForTest != null) {
-                    // Test-only (fleetd #335 site 1): see the field's own javadoc.
-                    abandonCleanupHookForTest.run();
+            if (task.future.complete(outcome)) {
+                if (outcome.outcome() == Outcome.WORKER_FAILED) {
+                    asyncFailed = true;
                 }
-                if (completedHere) {
-                    if (turnId != null) {
-                        // #275: whether this task was swept out of ASKING or was already answered and
-                        // only waiting on its resumed turn's real reply (#137), nothing will ever
-                        // complete this turnId now — drop it from this class's own bookkeeping AND the
-                        // reverse-rendezvous itself, so hasAsyncQuestion(target) stops reporting a turn
-                        // that is actually done, and a late answer() sees it as lapsed rather than
-                        // resolving a question nothing is listening for any more.
-                        asyncTasksByTurn.remove(turnId, task);
-                        rendezvous.closeAsk(turnId);
-                    }
-                } else if (isRecovery) {
-                    // The recovered reply was already drained out of the inbox, but this task resolved
-                    // through another path (e.g. a concurrent reply() or a second abandon() racing this
-                    // one) between us choosing it and completing it here. Put the reply back rather than
-                    // lose it silently — it may still belong to some other still-open task, or the next
-                    // caller that drains this target's inbox.
-                    inbox.publish(target, UUID.randomUUID().toString(), recovered.text());
+                if (turnId != null) {
+                    // #275: whether this task was swept out of ASKING or was already answered and
+                    // only waiting on its resumed turn's real reply (#137), nothing will ever
+                    // complete this turnId now — drop it from this class's own bookkeeping AND the
+                    // reverse-rendezvous itself, so hasAsyncQuestion(target) stops reporting a turn
+                    // that is actually done, and a late answer() sees it as lapsed rather than
+                    // resolving a question nothing is listening for any more.
+                    asyncTasksByTurn.remove(turnId, task);
+                    rendezvous.closeAsk(turnId);
                 }
-            } catch (RuntimeException e) {
-                // fleetd #335: inbox.publish reaches a broker (AmqpReplyInbox throws
-                // IllegalStateException on an unroutable/unconfirmed/interrupted publish) and this
-                // loop has no other teardown path — a caller on the release path, or the health
-                // monitor's GONE/NEVER_READY sweep. Losing this exception uncaught would abort the
-                // loop and leave every task still to come in `matching` PENDING forever (fleetd
-                // #335 site 1). completedHere is already recorded above, so only this task's
-                // best-effort bookkeeping is lost — log it and let the loop reach the rest.
-                log.error("abandon: per-task cleanup failed for ticket {} (target {}, turnId {})",
-                        task.ticket, target, turnId, e);
+            } else if (isRecovery) {
+                // The recovered reply was already drained out of the inbox, but this task resolved
+                // through another path (e.g. a concurrent reply() or a second abandon() racing this
+                // one) between us choosing it and completing it here. Put the reply back rather than
+                // lose it silently — it may still belong to some other still-open task, or the next
+                // caller that drains this target's inbox.
+                inbox.publish(target, UUID.randomUUID().toString(), recovered.text());
             }
         }
         if (failed) {
@@ -826,13 +705,9 @@ public final class MessageService {
     /**
      * Acknowledge a specific reply by {@code msgId} for {@code target}. Removes it from the inbox
      * so that a subsequent drain or peek no longer returns it.
-     *
-     * @return {@code true} if an entry was actually removed, {@code false} if {@code msgId} was not
-     *     in {@code target}'s inbox (wrong id, wrong target, or already acked). The caller —
-     *     {@link dev.ltms.fleet.mcp.FleetMcp#ack} — must not report success on {@code false}.
      */
-    public boolean ackReply(String target, String msgId) {
-        return inbox.ack(target, msgId);
+    public void ackReply(String target, String msgId) {
+        inbox.ack(target, msgId);
     }
 
     /**
@@ -933,26 +808,16 @@ public final class MessageService {
                 if (onAccepted != null) {
                     onAccepted.run();
                 }
-                Injector.Delivery delivery = injector.enqueue(target, content, token);
+                CompletableFuture<Void> delivered = injector.enqueue(target, content, token);
                 try {
                     Rendezvous.Resolution r = reply.get(remainingMillis(deadlineNanos), TimeUnit.MILLISECONDS);
                     return recorded(new Reply(outcomeOf(r.kind()), r.text(), r.turnId()));
                 } catch (TimeoutException e) {
-                    boolean wasDelivered = delivery.completion().isDone()
-                            && !delivery.completion().isCompletedExceptionally();
-                    if (!wasDelivered) {
-                        if (timeoutCancellationRaceHookForTest != null) {
-                            // Test-only (fleetd #345): see the field's own javadoc.
-                            timeoutCancellationRaceHookForTest.run();
-                        }
-                        // The target monitor makes cancellation atomic with onStatus picking this
-                        // Pending up. If pickup won, report TIMED_OUT_WORKING because the text landed.
-                        wasDelivered = injector.cancel(delivery) == Injector.Cancellation.DELIVERED;
-                    }
+                    boolean wasDelivered = delivered.isDone() && !delivered.isCompletedExceptionally();
                     log.debug("send to {} timed out (delivered={})", target, wasDelivered);
                     if (!wasDelivered) {
-                        // CB-640: record that delivery did not happen for fleet health (see
-                        // queuedDeliveries). The exact Pending was cancelled, so it cannot arrive later.
+                        // CB-640: still sitting in the injector's queue, waiting for the member to
+                        // go idle — record the fact for fleet health (see queuedDeliveries).
                         queuedDeliveries.put(target, Boolean.TRUE);
                     }
                     return recorded(new Reply(
@@ -1015,41 +880,7 @@ public final class MessageService {
             return new AskResult(AskOutcome.ANSWERED, answer);
         } catch (TimeoutException e) {
             log.debug("fleet_ask from {} went unanswered in {}ms", workerSession, timeoutMillis);
-            // Only the fresh owner tears down the shared turn (mirrors the finally block below).
-            // A duplicate's own timeoutMillis says nothing about whether the SHARED ask is actually
-            // done — it must leave the close/forget bookkeeping to the fresh owner, exactly as it
-            // already leaves closeAsk to it.
-            if (ticket.fresh()) {
-                // fleetd #334: close the ask turn BEFORE forgetting this task's turnId mapping below.
-                // Before this fix the order was reversed — the mapping was forgotten here first, and
-                // rendezvous.closeAsk only ran afterward, in the shared finally. A primary's answer()
-                // call racing this exact timeout could then find rendezvous.askSession(turnId) still
-                // non-null (the ask still "answerable") after the Task mapping was already gone:
-                // answer()'s own asyncTasksByTurn lookup returned null, its task != null guard skipped
-                // the completion, and the async ticket sat at PENDING forever even though answer()
-                // itself reported the worker's real reply. Closing here first removes that window:
-                // any answer() call that still observes askSession(turnId) != null is necessarily
-                // racing a point BEFORE the forgetting below runs (both happen on this one thread, in
-                // this order, with nothing that yields in between), so the Task mapping is still there
-                // for it to find; any call that observes askSession(turnId) == null now correctly
-                // bails out STALE_TURN (see answer()'s own top check) before ever reaching
-                // asyncTasksByTurn. rendezvous.closeAsk is idempotent — a no-op once the turn is
-                // already removed, see its own javadoc — so the shared finally below re-running it
-                // for this same fresh call is harmless.
-                rendezvous.closeAsk(ticket.turnId());
-                if (askTimeoutRaceHookForTest != null) {
-                    // Test-only (fleetd #334): see the field's own javadoc.
-                    askTimeoutRaceHookForTest.run();
-                }
-                // fleetd #307: mark the task BEFORE clearAsyncQuestion(forgetTurn=true) below drops it
-                // out of asyncTasksByTurn and nulls its turnId — that forgetting is deliberate and
-                // stays (it is what keeps the target from staying BUSY forever), but it would
-                // otherwise also erase askAnsweredAsyncTasks' only signal that the worker's eventual
-                // real fleet_reply still belongs to this task, stranding it in the inbox with a false
-                // "never replied" verdict.
-                markAskTimedOut(ticket.turnId());
-                clearAsyncQuestion(ticket.turnId(), true);
-            }
+            clearAsyncQuestion(ticket.turnId(), true);
             return new AskResult(AskOutcome.TIMED_OUT, null);
         } catch (ExecutionException e) {
             Throwable cause = e.getCause();
@@ -1096,16 +927,7 @@ public final class MessageService {
         }
         try {
             CompletableFuture<Rendezvous.Resolution> reply = rendezvous.open(workerSession);
-            // #282: mirror send()'s registration (:802) so a SECOND fleet_ask inside this same
-            // resumed turn can re-associate the async ticket with its new turnId via
-            // markAsyncQuestion — without this, that second ask has no Task to attach to, and
-            // markAsyncQuestion silently returns null.
-            Task task = asyncTasksByTurn.get(turnId);
-            if (task != null) {
-                asyncTasksByWaiter.put(reply, task);
-            }
             if (!rendezvous.answerAsk(turnId, content)) {
-                asyncTasksByWaiter.remove(reply);
                 rendezvous.close(workerSession, reply);
                 return new Reply(Outcome.STALE_TURN, null); // lapsed between the lookup and the unblock
             }
@@ -1113,66 +935,7 @@ public final class MessageService {
             try {
                 Rendezvous.Resolution r = reply.get(remainingMillis(deadlineNanos), TimeUnit.MILLISECONDS);
                 Reply result = new Reply(outcomeOf(r.kind()), r.text(), r.turnId());
-                // #282: this waiter can resolve with a FRESH question rather than a terminal reply —
-                // the worker chained a second fleet_ask before replying. Mirror sendAsync's own guard
-                // (:1000) and leave the ticket open (markAsyncQuestion above already re-armed it under
-                // the new turnId) instead of completing it here with a QUESTION "reply".
-                // Measured when #282 was merged: this guard is DEFENCE IN DEPTH, not the thing
-                // that makes the chained ask work. ask() calls markAsyncQuestion (:860) before
-                // resolveQuestion (:861), so by the time this thread wakes, the task has already
-                // moved to the new turnId — this outcome check, not a Task lookup, is what tells the
-                // two cases apart (see fleetd #329 below). Removing this guard alone leaves the test
-                // green. Keep it anyway: it mirrors sendAsync's sibling guard, and that sibling's own
-                // comment (:1017) warns the two orderings are not something to rely on. Do NOT delete
-                // it as dead code without re-checking that ordering, and do not treat it as the sole
-                // protection either.
-                //
-                // fleetd #329 (F1): complete the SAME Task object this method already looked up at
-                // :991, rather than re-resolving it from turnId a second time. The old
-                // finishAsyncTask(turnId, result) did its own asyncTasksByTurn.get(turnId) here, and
-                // that second lookup races ask()'s own timeout path: ask()'s ticket.answer().get(...)
-                // can time out (or lose that exact race) at essentially the same instant this method's
-                // rendezvous.answerAsk(turnId, ...) above already succeeded, running
-                // markAskTimedOut + clearAsyncQuestion(turnId, true) with no lock at all — which
-                // forgets turnId (removes it from asyncTasksByTurn, nulls Task.turnId) before this
-                // thread ever gets here. The worker's real reply then arrived, this method's own wait
-                // woke up with it, and the by-turnId lookup found nothing: the async ticket's future
-                // was never completed, so fleet_poll{ticket} stayed PENDING forever even though
-                // answer() itself correctly returned REPLIED. Reusing the reference captured at :991
-                // — before that race window opens — sidesteps the second lookup entirely: it is the
-                // identical Task whatever asyncTasksByTurn or Task.turnId say by the time we reach
-                // this point, so finishAsyncTask(Task, Reply) can still complete its future and detach
-                // it using whatever turnId it now reads. The #282 chained-ask case is unaffected
-                // because it is still gated purely by result.outcome() == QUESTION above, which does
-                // not depend on this lookup — widening what "task" means here cannot complete a ticket
-                // the chained ask deliberately left open.
-                //
-                // A null task is NOT only "this was never an async ticket". That reading was in this
-                // comment when #329 merged and it is wrong; it is still not the whole story after
-                // #334. A genuine async ticket can still land here with task == null — a blocking
-                // (wait:true) send's fleet_ask never has a Task at all, so that case is expected and
-                // fine. What #334 fixed was a SECOND, unintended way to get here with task == null:
-                // ask()'s timeout path used to run clearAsyncQuestion(turnId, true) — which drops the
-                // asyncTasksByTurn entry — in its catch block, while rendezvous.closeAsk(turnId) ran
-                // later, in its finally. Between those two the ask was still answerable but the map
-                // entry was already gone, so the lookup at :1053 returned null and this ticket was
-                // never completed. Measured on 2026-09-04: a probe firing only that first half before
-                // answer() ran printed "answer=REPLIED phase=PENDING reply=null" — the same stranded
-                // ticket #329 set out to fix, one step earlier in the same race; the probe used
-                // forgetTurnForTest, which omits ask()'s markAskTimedOut, and that omission does not
-                // change the outcome, because askTimedOut is read only by askAnsweredAsyncTasks, and
-                // reply() never reaches it while this method's own waiter is live. #334's fix
-                // reorders ask()'s timeout catch to run closeAsk before the forgetting (see the
-                // fresh-owner block there), which removes this path entirely rather than narrowing
-                // it further: once closeAsk has run, rendezvous.askSession(turnId) is null and
-                // answer() returns STALE_TURN from its own top check, before it ever reaches this
-                // lookup — see aLateAnswerDuringAskTimeoutTeardownStillCompletesTheAsyncTicket in
-                // MessageServiceTest, which pins the exact window with askTimeoutRaceHookForTest.
-                // So by the time this line runs, task == null means only the ordinary blocking-send
-                // case (or #329's own already-fixed race elsewhere) — not this one.
-                if (result.outcome() != Outcome.QUESTION && task != null) {
-                    finishAsyncTask(task, result);
-                }
+                finishAsyncTask(turnId, result);
                 return result;
             } catch (TimeoutException e) {
                 // The worker resumed but hasn't replied yet — no completion fallback arms an answered
@@ -1185,7 +948,6 @@ public final class MessageService {
                 Thread.currentThread().interrupt();
                 throw new IllegalStateException("interrupted awaiting reply from " + workerSession, e);
             } finally {
-                asyncTasksByWaiter.remove(reply);
                 rendezvous.close(workerSession, reply);
             }
         } finally {
@@ -1222,25 +984,14 @@ public final class MessageService {
             // this fires exactly once, from whichever path completes it: finishAsyncTask(task, result)
             // below on any non-QUESTION outcome of send() — a worker's fleet_reply, the CB-106
             // completion fallback, a CB-109 wedge, TIMED_OUT, BUSY, or BACKEND_EXHAUSTED — the same
-            // finishAsyncTask reached via answer()'s own finishAsyncTask(task, result) once a QUESTION
+            // finishAsyncTask reached via answer()'s finishAsyncTask(turnId, result) once a QUESTION
             // is resolved, completeExceptionally(t) just below when send() itself throws, or a CB-516
             // abandon() on teardown. Without this, MessageService.reply's rendezvous fast path (the
             // one an async ticket always takes) never told the push loop anything happened — see the
             // class javadoc on sendAsync/CB-107.
             task.future.whenComplete((reply, ex) -> {
                 boolean failed = ex != null || reply == null || !reply.completed();
-                try {
-                    pushLoop.onTicketTerminal(ticket, target, failed);
-                } catch (Throwable t) {
-                    // fleetd #335 (site 2): this stage's own CompletableFuture is discarded, so an
-                    // uncaught throw here (e.g. a RejectedExecutionException from
-                    // ReplyPushLoop's scheduler, already shut down while this in-flight send's
-                    // whenComplete fires during the daemon's own shutdown sequence — messages.close()
-                    // only stops accepting NEW async work, it does not cancel a delivery already
-                    // running) vanishes with no log line and no metric, and the push loop never learns
-                    // the ticket went terminal — the exact thing this hook exists to tell it.
-                    log.error("push loop failed to learn ticket {} (target {}) went terminal", ticket, target, t);
-                }
+                pushLoop.onTicketTerminal(ticket, target, failed);
             });
         }
         asyncExecutor.submit(() -> {
@@ -1253,22 +1004,7 @@ public final class MessageService {
                     finishAsyncTask(task, result);
                 }
             } catch (Throwable t) {
-                // fleetd #329 (F2): finishAsyncTask above already completes task.future — on its very
-                // first line — before doing anything else, so anything that throws afterward (inside
-                // finishAsyncTask's own cleanup, or from a future addition to this try block) lands
-                // here with the future already resolved. completeExceptionally on an already-completed
-                // future is a silent no-op: it returns false and does nothing, so without the check
-                // below the exception simply vanished — no log, no metric, nothing. Measured (see the
-                // ticket): temporarily reintroducing the fleetd #324 NPE reproduced 19 real exceptions
-                // on the ordinary path, with 74/74 tests staying green and not one log line produced.
-                // Do not stop completing the future first — finishAsyncTask completing before it
-                // cleans up is what makes a late failure harmless to the ticket's own result — only
-                // add the missing visibility for the case where that step, or whatever ran after it,
-                // has already lost the race to report through the future.
-                if (!task.future.completeExceptionally(t)) {
-                    log.error("async send {} -> {} threw after its ticket was already resolved",
-                            ticket, target, t);
-                }
+                task.future.completeExceptionally(t);
             }
         });
         pruneTerminalTickets();
@@ -1321,27 +1057,6 @@ public final class MessageService {
         return new TaskView(ticket, Phase.FAILED, null, null, detail, null);
     }
 
-    /**
-     * Test seam only — carries no production behaviour, and nothing in this class calls it;
-     * {@link #pruneTerminalTickets} still reads {@link Task#completedNanos} directly.
-     *
-     * <p>Reports whether {@code ticket}'s completion hook (the {@code whenComplete} registered in
-     * {@link Task}'s constructor) has actually run yet. Exists because {@link #poll} can report
-     * {@link Phase#DONE} for a ticket before that hook fires: {@code CompletableFuture.complete()}
-     * publishes its result and only afterwards runs dependent actions such as {@code whenComplete}
-     * (fleetd #399), so a caller that observes the future done via {@link #poll} is not thereby
-     * guaranteed to also observe {@link Task#completedNanos} stamped. A test that must order both
-     * events — e.g. before advancing an injected clock past the TTL, to avoid stamping the
-     * *advanced* time and masking a real eviction bug — waits on this instead of on
-     * {@link Phase#DONE}.
-     *
-     * @return {@code false} for an unknown ticket or one whose completion hook has not run yet
-     */
-    boolean isCompletionStampedForTest(String ticket) {
-        Task task = tasks.get(ticket);
-        return task != null && task.completedNanos != null;
-    }
-
     /** Best-effort live worker status for a pending poll; never throws (a lookup error is just noise). */
     private String liveStatus(String target) {
         try {
@@ -1391,37 +1106,13 @@ public final class MessageService {
     private Task markAsyncQuestion(CompletableFuture<Rendezvous.Resolution> waiter, String text, String turnId) {
         Task task = waiter == null ? null : asyncTasksByWaiter.get(waiter);
         if (task != null) {
-            String previousTurnId = task.turnId;
             task.question = new Reply(Outcome.QUESTION, text, turnId);
             task.turnId = turnId;
             asyncTasksByTurn.put(turnId, task);
-            // #282: a second fleet_ask in the same resumed turn re-arms an already-answered task
-            // (answer() re-registers it in asyncTasksByWaiter) under a FRESH turnId — drop the old
-            // key so asyncTasksByTurn does not keep growing by one stale entry per chained ask.
-            if (previousTurnId != null && !previousTurnId.equals(turnId)) {
-                asyncTasksByTurn.remove(previousTurnId, task);
-            }
         }
         return task;
     }
 
-    /**
-     * Mark {@code turnId}'s task as having a {@code fleet_ask} that lapsed with no answer (fleetd #307), so
-     * {@link #askAnsweredAsyncTasks} still recognizes the worker's eventual real {@code fleet_reply}
-     * as belonging to it after {@link #clearAsyncQuestion}'s {@code forgetTurn=true} erases
-     * {@link Task#turnId} — see {@link Task#askTimedOut}. Must be called before that forgetting, while
-     * {@code turnId} can still resolve the task in {@code asyncTasksByTurn}; a lookup afterward would
-     * find nothing. Only when it matches the task's current turn — same guard as
-     * {@link #clearAsyncQuestion} — so a chained second {@code fleet_ask} (#282) that already moved
-     * the task to a fresh {@code turnId} cannot mark it for a turn that is no longer its own.
-     */
-    private void markAskTimedOut(String turnId) {
-        Task task = asyncTasksByTurn.get(turnId);
-        if (task != null && turnId.equals(task.turnId)) {
-            task.askTimedOut = true;
-        }
-    }
-
     /** Clear an answered or lapsed question, but only when it matches the ticket's current turn. */
     private void clearAsyncQuestion(String turnId, boolean forgetTurn) {
         // CB-582: tell the push loop first — like ticketCollected, a removal for a turnId it never
@@ -1440,174 +1131,20 @@ public final class MessageService {
         }
     }
 
-    /**
-     * Complete and detach an async ticket after its worker's actual terminal reply.
-     *
-     * <p><strong>fleetd #324.</strong> {@code task.turnId} is read into {@code turnId} exactly once.
-     * It used to be read twice — once for the null check, once as the removal key — and {@code
-     * volatile} makes each of those reads individually fresh but does not make the pair atomic.
-     * {@link #answer} calls this while holding {@code sessionLocks} for the target; {@link #ask}'s
-     * own timeout path calls {@link #clearAsyncQuestion} (which nulls {@link Task#turnId}) under no
-     * lock at all. When that unlocked null-out landed between the two reads here, the second read saw
-     * {@code null} and {@code asyncTasksByTurn.remove(null, task)} threw {@code NullPointerException}
-     * on the lead's own {@code answer()} call — even though {@code task.future.complete(result)} on
-     * the line above had already run, so the answer was in fact delivered. Capturing the field once
-     * removes the torn read; see the ticket for why the wider asymmetry between the locked and
-     * unlocked sides is not fixed by this alone.
-     */
+    /** Complete and detach an async ticket after its worker's actual terminal reply. */
     private void finishAsyncTask(Task task, Reply result) {
         task.future.complete(result);
-        if (afterFinishAsyncTaskCompleteHookForTest != null) {
-            // Test-only (fleetd #329, F2): see the field's own javadoc.
-            afterFinishAsyncTaskCompleteHookForTest.run();
-        }
-        String turnId = task.turnId;
-        if (turnId != null) {
-            if (finishAsyncTaskRaceHook != null) {
-                // Test-only (fleetd #324): see the field's own javadoc.
-                finishAsyncTaskRaceHook.run();
-            }
-            asyncTasksByTurn.remove(turnId, task);
+        if (task.turnId != null) {
+            asyncTasksByTurn.remove(task.turnId, task);
         }
     }
 
-    /**
-     * Null in production; test seam for fleetd #324 — invoked from {@link #finishAsyncTask(Task,
-     * Reply)} right after {@code task.turnId}'s null-check passes and before the (now-local) value is
-     * used for the removal. A test installs this to force, deterministically, the exact interleaving
-     * that a real race between this method and {@link #ask}'s unlocked timeout cleanup can otherwise
-     * only produce by chance: firing it here reproduces "the field went null between the check and the
-     * use" against the pre-fix code, and demonstrates the fix tolerates it (the captured local is used
-     * unconditionally, so a hook that nulls the field afterward cannot affect this call).
-     */
-    private volatile Runnable finishAsyncTaskRaceHook;
-
-    /**
-     * Test-only (fleetd #324): install {@link #finishAsyncTaskRaceHook}. Package-private so the test,
-     * in the same package, can reach it without widening any production API.
-     */
-    void setFinishAsyncTaskRaceHookForTest(Runnable hook) {
-        this.finishAsyncTaskRaceHook = hook;
-    }
-
-    /**
-     * Null in production; test seam for fleetd #329 (F2) — invoked from {@link #finishAsyncTask(Task,
-     * Reply)} unconditionally, immediately after {@code task.future.complete(result)} runs (before
-     * {@link Task#turnId} is even read, so it fires regardless of whether this task was ever asked).
-     * A test installs this to force an exception into exactly the shape fleetd #329 identified:
-     * something throws inside {@link #sendAsync}'s executor task after the async ticket's future is
-     * already resolved, so the surrounding {@code catch (Throwable t)} can only report failure through
-     * {@code completeExceptionally} — a silent no-op on an already-completed future. Engineering a
-     * real exception to land in that exact post-completion window is what the ticket itself had to do
-     * by temporarily deleting a production guard (fleetd #324's {@code turnId != null} check); this
-     * hook drives the identical shape deterministically instead.
-     */
-    private volatile Runnable afterFinishAsyncTaskCompleteHookForTest;
-
-    /**
-     * Test-only (fleetd #329, F2): install {@link #afterFinishAsyncTaskCompleteHookForTest}.
-     * Package-private so the test, in the same package, can reach it without widening any production
-     * API.
-     */
-    void setAfterFinishAsyncTaskCompleteHookForTest(Runnable hook) {
-        this.afterFinishAsyncTaskCompleteHookForTest = hook;
-    }
-
-    /**
-     * Null in production; test seam for fleetd #345 — invoked in {@link #send}'s timeout path after
-     * {@link Injector.Delivery#completion()} reports incomplete and before {@link Injector#cancel}
-     * takes the target monitor. A test installs this to make {@code onStatus} pick the exact queued
-     * delivery up in that window, so {@code cancel} returns {@link Injector.Cancellation#DELIVERED}.
-     * This deterministically covers the caller's need to use that result rather than relying on a
-     * timing-sensitive real race.
-     */
-    private volatile Runnable timeoutCancellationRaceHookForTest;
-
-    /**
-     * Test-only (fleetd #345): install {@link #timeoutCancellationRaceHookForTest}. Package-private
-     * so the test, in the same package, can reach it without widening any production API.
-     */
-    void setTimeoutCancellationRaceHookForTest(Runnable hook) {
-        this.timeoutCancellationRaceHookForTest = hook;
-    }
-
-    /**
-     * Null in production; test seam for fleetd #329 (F3) — invoked from {@link #reply} right after
-     * the single local read of {@code orphan.turnId} passes its null-check and before that (now-local)
-     * value is used as the {@code asyncTasksByTurn} removal key. Mirrors {@link
-     * #finishAsyncTaskRaceHook} exactly, for the structurally identical double-read fleetd #324 fixed
-     * in {@link #finishAsyncTask}: a test installs this to force, deterministically, {@code
-     * clearAsyncQuestion}'s unlocked {@code forgetTurn=true} path nulling {@link Task#turnId} in that
-     * exact window, and to confirm the single-read fix tolerates it (the captured local is used
-     * unconditionally, so a hook that nulls the field afterward cannot affect this call).
-     */
-    private volatile Runnable replyOrphanTurnIdRaceHookForTest;
-
-    /**
-     * Test-only (fleetd #329, F3): install {@link #replyOrphanTurnIdRaceHookForTest}. Package-private
-     * so the test, in the same package, can reach it without widening any production API.
-     */
-    void setReplyOrphanTurnIdRaceHookForTest(Runnable hook) {
-        this.replyOrphanTurnIdRaceHookForTest = hook;
-    }
-
-    /**
-     * Test-only (fleetd #324): run the exact production cleanup {@link #ask}'s own timeout path runs
-     * unlocked — {@link #clearAsyncQuestion(String, boolean)} with {@code forgetTurn=true} — so a test
-     * can reproduce that specific mutation instead of hand-rolling an approximation of it.
-     */
-    void forgetTurnForTest(String turnId) {
-        clearAsyncQuestion(turnId, true);
-    }
-
-    /**
-     * Null in production; test seam for fleetd #335 (site 1) — invoked from {@link #abandon(String,
-     * String, boolean)}'s per-task loop, once per task, right before that task's own cleanup
-     * (turnId bookkeeping, or the stranded-reply put-back) runs. A test installs this to inject a
-     * throw at that exact point deterministically.
-     *
-     * <p>The one production call there that can really throw is {@code inbox.publish} in the
-     * put-back branch — {@link AmqpReplyInbox#publish} reaches a broker and throws {@link
-     * IllegalStateException} on an unroutable, unconfirmed, or interrupted publish — but reaching
-     * that branch requires a second completion of the very task {@code abandon} is about to
-     * complete to win the race first (see the branch's own comment), and the #137 follow-up
-     * investigation above already found the combination this needs (a stranded reply coinciding
-     * with an open matching task) unreachable through the public API, not merely hard to time.
-     * This hook reproduces the resulting shape — a per-task cleanup throw — directly, the same
-     * technique {@link #finishAsyncTaskRaceHook} and {@link
-     * #afterFinishAsyncTaskCompleteHookForTest} already use for their own hard-to-time races.
-     */
-    private volatile Runnable abandonCleanupHookForTest;
-
-    /**
-     * Test-only (fleetd #335, site 1): install {@link #abandonCleanupHookForTest}. Package-private
-     * so the test, in the same package, can reach it without widening any production API.
-     */
-    void setAbandonCleanupHookForTest(Runnable hook) {
-        this.abandonCleanupHookForTest = hook;
-    }
-
-    /**
-     * Null in production; test seam for fleetd #334 — invoked from {@link #ask}'s {@code
-     * TimeoutException} catch, only for the fresh owner, right after {@code rendezvous.closeAsk}
-     * has run and before {@link #markAskTimedOut} / {@link #clearAsyncQuestion} forget this task's
-     * turnId mapping. A test installs this to call {@link #answer} for the very same {@code turnId}
-     * synchronously from inside that exact window, deterministically reproducing the race a real
-     * concurrent {@code answer()} call could otherwise only win by timing luck: with the ask already
-     * closed, that call must see {@code rendezvous.askSession(turnId) == null} and return {@link
-     * Outcome#STALE_TURN} immediately, never reaching {@code asyncTasksByTurn} at all — proving the
-     * window fleetd #334 describes (mapping forgotten while the ask was still "answerable") is
-     * closed, rather than merely narrowed the way fleetd #329 narrowed the sibling race in {@link
-     * #finishAsyncTask}.
-     */
-    private volatile Runnable askTimeoutRaceHookForTest;
-
-    /**
-     * Test-only (fleetd #334): install {@link #askTimeoutRaceHookForTest}. Package-private so the
-     * test, in the same package, can reach it without widening any production API.
-     */
-    void setAskTimeoutRaceHookForTest(Runnable hook) {
-        this.askTimeoutRaceHookForTest = hook;
+    /** Complete the async ticket correlated to a specific answered turn. */
+    private void finishAsyncTask(String turnId, Reply result) {
+        Task task = asyncTasksByTurn.get(turnId);
+        if (task != null) {
+            finishAsyncTask(task, result);
+        }
     }
 
     /** A new send must not open a waiter while an async ticket owns this worker's paused turn. */

fleetd/src/main/java/dev/ltms/fleet/msg/ReplyInbox.java

@@ -46,13 +46,6 @@ public interface ReplyInbox {
     /** Non-destructive snapshot of pending replies for {@code target} (FIFO), empty list if none. */
     List<InboxMessage> peek(String target);
 
-    /**
-     * Remove the reply {@code msgId} for {@code target} once the primary has taken it.
-     *
-     * @return {@code true} if an entry was actually removed, {@code false} if there was nothing to
-     *     remove (unknown {@code target}, unowned {@code target}, or a {@code msgId} not held for
-     *     it). A {@code false} is not an error — acking a {@code target} this daemon does not own is
-     *     part of the normal contract, not a failure.
-     */
-    boolean ack(String target, String msgId);
+    /** Remove the reply {@code msgId} for {@code target} once the primary has taken it. No-op if absent. */
+    void ack(String target, String msgId);
 }

fleetd/src/main/java/dev/ltms/fleet/msg/ReplyPushLoop.java

@@ -2,7 +2,6 @@ package dev.ltms.fleet.msg;
 
 import dev.ltms.fleet.herdr.AgentControl;
 import dev.ltms.fleet.herdr.AgentStatus;
-import dev.ltms.fleet.herdr.HerdrException;
 import dev.ltms.fleet.mcp.PrimaryRegistry;
 import dev.ltms.fleet.metrics.FleetMetrics;
 import dev.ltms.fleet.metrics.Metrics;
@@ -14,7 +13,6 @@ import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ScheduledExecutorService;
@@ -132,15 +130,7 @@ public final class ReplyPushLoop {
         this.metrics = metrics;
     }
 
-    /**
-     * Count one nudge outcome when a registry is wired; a no-op in unit tests.
-     *
-     * <p>fleetd #365: the {@code "sent"} outcome (renamed from {@code "delivered"}) records only
-     * that {@code agents.send} — a one-way herdr {@code agent.prompt} paste-and-submit — returned
-     * without throwing. Nothing in this loop, or anywhere downstream of it, confirms the pane
-     * actually read or acted on the text; there is no read-receipt concept at this layer. "Sent"
-     * says exactly that; "delivered" claimed more than this call can ever establish.
-     */
+    /** Count one nudge outcome when a registry is wired; a no-op in unit tests. */
     private void countNudge(String outcome) {
         if (metrics != null) {
             metrics.inc(FleetMetrics.PUSH_NUDGES, "outcome", outcome);
@@ -230,26 +220,6 @@ public final class ReplyPushLoop {
                 .collect(Collectors.toUnmodifiableSet());
     }
 
-    /**
-     * Test seam only (fleetd #418): carries no production behaviour, and nothing in this class
-     * calls it. Exposes {@link #pendingQuestionTurnIdsFor} — the exact state {@link #decide} reads
-     * to decide whether a question keeps a lead's schedule alive.
-     *
-     * <p>{@code MessageService.ask()} does three things in order before a question is fully open to
-     * this loop: it flips the ticket's {@code poll()} phase to {@code Phase.ASKING}, then resolves
-     * the reverse-rendezvous waiter, then calls {@link #onQuestionOpened}, which is what actually
-     * populates {@link #pendingQuestions}. A test that barriers on {@code Phase.ASKING} observes only
-     * the first of those three steps — under load the asker thread can be descheduled between steps
-     * one and three, so the barrier releases before this method's underlying map is populated, and
-     * {@link #decide} correctly reports nothing pending yet. A test that must order itself after the
-     * state {@link #decide} actually reads waits on this instead of on the phase.
-     *
-     * @return an unmodifiable snapshot; empty for a lead with no open questions
-     */
-    Set<String> pendingQuestionTurnIdsForTest(String lead) {
-        return pendingQuestionTurnIdsFor(lead);
-    }
-
     private List<PendingIncident> pendingIncidentsFor(String lead) {
         return pendingIncidents.values().stream().filter(i -> lead.equals(i.key().lead())).toList();
     }
@@ -405,80 +375,6 @@ public final class ReplyPushLoop {
         return Action.WAIT_BUSY;
     }
 
-    /**
-     * Resolve who to nudge about {@code target}, the way every public entry point below wants it:
-     * {@link PrimaryRegistry#nudgeTargetFor}, but only after checking the delegating lead it names
-     * is still actually there (fleetd #368).
-     *
-     * <p><strong>The bug this closes.</strong> {@code PrimaryRegistry.forgetDelegation} is wired to
-     * exactly one event — a worker's release — because that is the only teardown the daemon already
-     * observes for a session in this map. Nothing removes a binding when the LEAD half goes away: a
-     * lead that is closed, crashes, or is relaunched leaves {@code leadByTarget} entries pointing at
-     * a terminal that no longer exists. {@code nudgeTargetFor} falls back to the single known
-     * primary only when the map holds nothing for {@code target} — a stale non-null entry beats the
-     * fallback every time, which is exactly backwards: the fallback's own javadoc argues it is safe
-     * precisely in the case a stale entry now hides.
-     *
-     * <p><strong>The fix.</strong> Before trusting a recorded delegation, probe the lead the same
-     * way {@link #decide} already does every tick ({@code agents.status}) — cheap, since it is a
-     * local herdr round-trip, and it is the same signal {@code AgentControl.paneByTerminal} already
-     * trusts to tell a genuinely dead target from a live one. A lead that fails the probe is treated
-     * as if it had never been recorded: the stale entry is forgotten (self-healing, exactly like
-     * {@code AgentControl.paneByTerminal} already does on {@code agent_not_found}) and resolution is
-     * retried, which now reaches the fallback {@code nudgeTargetFor} was built to reach — the same
-     * empty-map state its javadoc already argues is correct.
-     *
-     * <p><strong>fleetd #368 review — only a positive "gone" reading forgets the binding.</strong>
-     * The first version of this method treated <em>any</em> {@code RuntimeException} from the probe
-     * as death, which is the #359 mistake repeated: a transient socket blip or a codec error on a
-     * perfectly live lead would silently and permanently unbind it, with no re-record ever coming.
-     * That is destructive on one bad reading, exactly what #359 shipped a two-reading guard to avoid
-     * for the analogous lead-tab-liveness question. {@link #isLive} now matches
-     * {@code AgentControl.agentCall}'s own narrower rule (see its {@code agent_not_found} check): only
-     * that specific, affirmative "herdr has no such agent" signal counts as gone. Every other failure
-     * — timeout, transport error, a decode error — is treated as still live and the binding is left
-     * alone, because guessing wrong here is unrecoverable while guessing "live" merely costs one more
-     * retry on the next tick, which {@link #decide} already tolerates.
-     */
-    private Optional<String> resolveLiveLead(String target) {
-        Optional<String> lead = primaryRegistry.nudgeTargetFor(target);
-        if (lead.isEmpty() || isLive(lead.get())) {
-            return lead;
-        }
-        log.debug("push: lead {} delegated to for {} is no longer live, forgetting the stale binding "
-                + "and falling back", lead.get(), target);
-        primaryRegistry.forgetDelegation(target);
-        return primaryRegistry.nudgeTargetFor(target);
-    }
-
-    /**
-     * Whether {@code lead} should still be trusted: {@code false} only when herdr affirmatively
-     * reports the terminal gone ({@code agent_not_found}), never on a merely inconclusive failure.
-     *
-     * <p>fleetd #368 review: an earlier version returned {@code false} for any {@code RuntimeException},
-     * which made a transient herdr hiccup on a live lead indistinguishable from the lead actually
-     * being dead — and the caller's response to {@code false} ({@code forgetDelegation}) is
-     * destructive and permanent. Narrowed to the one code {@code AgentControl.agentCall} itself
-     * already treats as a genuine, resolvable absence (see its {@code agent_not_found} handling) —
-     * every other {@code RuntimeException} is treated as "still live" and the binding survives to be
-     * probed again next time, which costs nothing worse than one more retry.
-     */
-    private boolean isLive(String lead) {
-        try {
-            agents.status(lead);
-            return true;
-        } catch (RuntimeException e) {
-            boolean gone = e instanceof HerdrException he && "agent_not_found".equals(he.code());
-            if (gone) {
-                log.debug("push: lead {} no longer exists ({})", lead, e.toString());
-            } else {
-                log.debug("push: liveness check for lead {} was inconclusive ({}); treating as live "
-                        + "rather than risk destroying a live binding", lead, e.toString());
-            }
-            return !gone;
-        }
-    }
-
     // --- public entrypoints ----------------------------------------------------------------------
 
     /**
@@ -489,7 +385,7 @@ public final class ReplyPushLoop {
      * backstop until a lead is recorded.
      */
     public void onReplyQueued(String target) {
-        var lead = resolveLiveLead(target);
+        var lead = primaryRegistry.nudgeTargetFor(target);
         if (lead.isEmpty()) {
             log.debug("push: no lead is known to be waiting on {}, skipping reminder", target);
             return;
@@ -517,7 +413,7 @@ public final class ReplyPushLoop {
      * @param failed whether the ticket ended in a failure phase rather than {@code DONE}
      */
     public void onTicketTerminal(String ticket, String target, boolean failed) {
-        var lead = resolveLiveLead(target);
+        var lead = primaryRegistry.nudgeTargetFor(target);
         if (lead.isEmpty()) {
             log.debug("push: no lead is known to be waiting on ticket {} (target {}), skipping nudge",
                     ticket, target);
@@ -552,7 +448,7 @@ public final class ReplyPushLoop {
      * @param question the question text
      */
     public void onQuestionOpened(String ticket, String target, String turnId, String question) {
-        var lead = resolveLiveLead(target);
+        var lead = primaryRegistry.nudgeTargetFor(target);
         if (lead.isEmpty()) {
             log.debug("push: no lead is known to be waiting on {}'s question (turnId {}), skipping nudge",
                     target, turnId);
@@ -580,7 +476,7 @@ public final class ReplyPushLoop {
                                   Collection<String> profiles, int remainingCoolOffSeconds) {
         Map<String, List<String>> targetsByLead = new ConcurrentHashMap<>();
         for (String target : targets) {
-            var lead = resolveLiveLead(target);
+            var lead = primaryRegistry.nudgeTargetFor(target);
             if (lead.isEmpty()) {
                 log.warn("push: backend incident {} has no known lead for target {}", incidentId, target);
                 continue;
@@ -602,7 +498,7 @@ public final class ReplyPushLoop {
      * Without an owning lead, emit a warning because no control can act on the target.
      */
     public void onBackendTargetUnmapped(String target, String reason) {
-        var lead = resolveLiveLead(target);
+        var lead = primaryRegistry.nudgeTargetFor(target);
         if (lead.isEmpty()) {
             log.warn("push: backend target {} could not map to a credential: {}", target, reason);
             return;
@@ -758,7 +654,7 @@ public final class ReplyPushLoop {
                     lead, replyReminderCount + 1, maxReminders, ticketReminderCount + 1, maxReminders,
                     questionReminderCount + 1, maxReminders,
                     replyTargets.size(), tickets.size(), questions.size());
-            countNudge("sent");
+            countNudge("delivered");
             for (PendingIncident incident : incidents) {
                 if (pendingIncidents.remove(incident.key(), incident)) {
                     deliveredIncidents.add(incident.key());

fleetd/src/main/java/dev/ltms/fleet/peer/PeerLauncher.java

@@ -1,7 +1,5 @@
 package dev.ltms.fleet.peer;
 
-import dev.ltms.fleet.placement.PlacementDecision;
-
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
@@ -145,160 +143,9 @@ public interface PeerLauncher {
 
     /**
      * The profile a no-argument {@link #spawn(SpawnRequest)} uses, or {@code null} if none is configured.
-     *
-     * <p>fleetd #425: for an implementation with role pools (a no-argument spawn is read as {@link
-     * MemberRole#DEV}, see {@link SpawnRequest}), this must be the profile a live spawn of that role
-     * would actually be placed on right now, not a value captured once at startup — a caller such as
-     * {@code fleet_profiles} relies on this to report a live, not frozen, fact.
      */
     String defaultProfile();
 
-    /**
-     * The profile an unqualified spawn of {@code role} would resolve to right now — the role-aware,
-     * live counterpart of {@link #defaultProfile()} (fleetd #425).
-     *
-     * <p>A caller that must provision something profile-specific (working directory, parity overlay
-     * files) <em>before</em> the actual spawn — {@code SessionManager.acquireWithWorktree} is the one
-     * that exists today — needs the exact profile that spawn will use, for the caller's real role,
-     * not a role-agnostic guess. Calling {@link #defaultProfile()} for that purpose reads {@code
-     * MemberRole#DEV}'s answer regardless of the caller's actual role, which is wrong for any other
-     * role and can provision for a profile the spawn never lands on.
-     *
-     * <p>Default implementation returns {@link #defaultProfile()}, ignoring {@code role} — the right
-     * answer for a launcher with no role-pool concept of its own (e.g. a single {@code
-     * HerdrPeerLauncher} adapter, which is never reached this way in production: {@code
-     * CompositePeerLauncher} always fronts it and resolves roles itself).
-     *
-     * <p>fleetd #453: this default is deliberately <em>not</em> abstract — unlike {@link
-     * #spawn(SpawnRequest, PlacementDecision)} (fleetd #450), there is no live defect in inheriting
-     * it today, and the only current single-adapter implementer ({@code HerdrPeerLauncher}) is
-     * correct to do so. But it stays correct only as long as that holds: <strong>if a launcher ever
-     * routes more than one profile per role, it MUST override this method</strong>, or every role
-     * silently resolves to {@link #defaultProfile()} with no error and no log line. {@code
-     * HerdrPeerLauncher.spawn(SpawnRequest, PlacementDecision)} — the override in {@code
-     * dev.ltms.fleet.member}, not the declaration below — names this method and {@link #place}
-     * explicitly as "unoverridden here" for exactly this reason. Read it before adding role-pool
-     * routing to any {@code HerdrPeerLauncher} subclass.
-     *
-     * <p>Who is forced to read which paragraph, because it is not symmetric. A new class that
-     * implements this interface directly must write a body for {@link #spawn(SpawnRequest,
-     * PlacementDecision)}, which is abstract here, so it lands on this javadoc. A subclass of
-     * {@code HerdrPeerLauncher} does not: that class already implements the method, and the
-     * subclass inherits the body. So for a subclass this paragraph is advice, not a gate.
-     */
-    default String defaultProfileFor(MemberRole role) {
-        return defaultProfile();
-    }
-
-    /**
-     * The profile an <em>unqualified</em> spawn of {@code role} would actually be routed to right
-     * now — the same candidate list, the same {@code quarantined}/{@code coolingOff}/{@code
-     * modelOff} filtering, and the same {@code PlacementPolicy} that {@link #spawn} itself
-     * consults for a blank-profile request (fleetd #425 rework).
-     *
-     * <p>This is <em>not</em> {@link #defaultProfileFor}: that method answers "what is first in
-     * {@code role}'s pool", blind to quarantine, cool-off, and the model on/off gate — the right
-     * answer for a role-agnostic, best-effort report ({@code fleet_profiles}' {@code "default"}
-     * field), but the wrong one for a caller that needs the profile a spawn will actually land on.
-     * A quarantined or model-off pool-first profile makes {@link #defaultProfileFor} return a name
-     * an unqualified spawn will never be routed to.
-     *
-     * <p>Just the resolved name, not the full {@link PlacementDecision} — a caller that only wants
-     * to know the answer (a status report, a log line) can call this; a caller that will later
-     * <em>act</em> on the answer by spawning — provisioning a worktree for a specific profile
-     * before the peer exists is the one that matters — must call {@link #place} and carry the
-     * {@link PlacementDecision} itself through to {@link #spawn(SpawnRequest, PlacementDecision)}
-     * instead of calling this method and feeding the string back in as an explicit profile. Doing
-     * that re-enters {@link #spawn(SpawnRequest)}'s explicit-profile branch, which disagrees with
-     * the routing branch on purpose about what an excluded profile means: the routing branch (and
-     * {@link #place}) falls through a quarantined/cooling-off/at-cap/model-off/unreachable/weight-0
-     * profile to the next candidate, while the explicit branch refuses outright — correct for an
-     * operator who named that profile on purpose, wrong for a name that only ever came from placement
-     * itself. That accidental refusal is exactly the regression fleetd #425 rework round 2 fixes:
-     * the default implementation below delegates to {@link #place}, so the two can never drift apart,
-     * but a caller that resolves through this method alone and spawns separately can still recreate
-     * the round-1 defect for itself. (Before fleetd #435, this accident was also reachable through
-     * {@code maxLoad} specifically, because {@code FixedPlacementPolicy} — the default policy — did
-     * not evaluate it at all for automatic selection; #435 closed that gap, so a placement decision
-     * can no longer be at cap in the first place. The refusal-vs-fall-through disagreement above is
-     * the part that was never about {@code maxLoad} and is still real.)
-     *
-     * @throws RuntimeException (implementation-specific, typically a placement exception) if no
-     *                          candidate in {@code role}'s pool is currently placeable
-     */
-    default String routedProfileFor(MemberRole role) {
-        return place(role).profile();
-    }
-
-    /**
-     * Resolve, <em>without spawning</em>, the {@link PlacementDecision} an unqualified spawn of
-     * {@code role} would make right now — the same candidate list, the same {@code
-     * quarantined}/{@code coolingOff}/{@code modelOff} filtering, and the same {@code
-     * PlacementPolicy} {@link #spawn(SpawnRequest)}'s blank-profile branch itself consults (fleetd
-     * #425 rework).
-     *
-     * <p>Pair this with {@link #spawn(SpawnRequest, PlacementDecision)}, never with {@link
-     * #spawn(SpawnRequest)} fed the decision's profile as an explicit name — see {@link
-     * PlacementDecision}'s own javadoc for why that second form regressed.
-     *
-     * <p>Default implementation wraps {@link #defaultProfile()}, ignoring {@code role} and every
-     * placement condition — the right answer for a launcher with no pool or placement-policy
-     * concept of its own, matching {@link #defaultProfileFor}'s own default.
-     *
-     * <p>fleetd #453: same reasoning as {@link #defaultProfileFor}'s own #453 note — this default
-     * is deliberately not abstract (no live defect today, correct for the sole single-adapter
-     * implementer), but <strong>a launcher that ever routes more than one profile per role MUST
-     * override this method too</strong>, or placement silently ignores {@code role} for it. See
-     * {@code HerdrPeerLauncher.spawn(SpawnRequest, PlacementDecision)}'s javadoc, which names this
-     * method as "unoverridden here" and why that is correct only for a single-profile adapter.
-     *
-     * @throws RuntimeException (implementation-specific, typically a placement exception) if no
-     *                          candidate in {@code role}'s pool is currently placeable
-     */
-    default PlacementDecision place(MemberRole role) {
-        return new PlacementDecision(defaultProfile());
-    }
-
-    /**
-     * Spawn against an already-resolved {@link PlacementDecision} from {@link #place}, honoring it
-     * completely: none of the conditions {@link #place} already applied — quarantine, cooling off,
-     * {@code maxLoad} (evaluated by every placement policy including the default {@code fixed},
-     * since fleetd #435), model-off — are re-evaluated here; {@code decision} already reflects them.
-     * This is not skipping a check {@code place} left undone; it is not repeating one {@code place}
-     * already did, and not re-opening the window between that decision and this spawn in which the
-     * underlying state could otherwise move. This is what lets a resolve-then-spawn caller
-     * ({@code SessionManager.acquireWithWorktree}, which must know the profile before it can
-     * provision a worktree for it) and a plain blank-profile {@link #spawn(SpawnRequest)} caller
-     * land on the exact same outcome for the exact same placement state (fleetd #425 rework,
-     * round 2).
-     *
-     * <p>{@code req}'s own {@link SpawnRequest#profileName()} is ignored in favor of {@code
-     * decision.profile()} — the caller is expected to have built {@code req} with a blank or
-     * matching profile; passing a request that names a <em>different</em>, explicit profile than
-     * the decision it is paired with is a caller bug this method does not attempt to detect.
-     *
-     * <p>No default implementation (fleetd #450): the two correct bodies disagree on purpose, so an
-     * implementer must choose one rather than silently inherit whichever this interface happened to
-     * provide. An implementer with no placement concept of its own — spawns a single profile, e.g.
-     * {@code HerdrPeerLauncher} — should delegate to {@link #spawn(SpawnRequest)} with the decision's
-     * profile named explicitly, since there is no separate routing path to honor there: the
-     * explicit-profile branch it re-enters and the routing branch {@link #place} would have used are
-     * the same thing. <strong>A launcher that routes across more than one profile — the way {@code
-     * CompositePeerLauncher} routes across every configured adapter — MUST NOT re-enter {@link
-     * #spawn(SpawnRequest)}.</strong> Doing so re-applies that single-argument method's
-     * explicit-profile checks ({@code enforceNotQuarantined}, {@code enforceNotCoolingOff}, {@code
-     * enforceMaxLoad}, {@code enforceModelEnabled} in {@code CompositePeerLauncher}), which can
-     * refuse the very profile {@link #place} just chose, if the underlying placement state moved in
-     * the window between the {@link #place} call and this one — the exact window this method and
-     * {@link PlacementDecision} exist to close (fleetd #444). Before #450 this was a {@code default}
-     * method that only {@code CompositePeerLauncher} overrode; a future placement-doing launcher
-     * could have inherited the re-entering body silently and never known. Making it abstract turns
-     * that silent inheritance into a compile error.
-     *
-     * @throws IllegalArgumentException if the decision names an unknown profile
-     */
-    PeerHandle spawn(SpawnRequest req, PlacementDecision decision);
-
     /**
      * Resolve the effective working directory for a spawn {@code req} without actually spawning.
      * Resolution order: requestedCwd → profile cwd → callerCwd → daemon cwd.
@@ -345,66 +192,4 @@ public interface PeerLauncher {
      * @return {@code true} when a reset was sent and its status transition must settle before reuse
      */
     boolean clearContext(String id);
-
-    /**
-     * Model ids the operator has currently turned off in the central {@code models.allow:} list
-     * (fleetd #422) — empty for a launcher with nothing to gate against. {@code fleet_profiles}/
-     * {@code GET /profiles} (via {@code FleetMcp.profilesView}) call this to report which models
-     * are off, and MUST read this exact accessor rather than deriving their own answer: the fleetd
-     * #404 lesson is that a status field reading a different source than the behaviour it describes
-     * can drift from what the gate ({@code CompositePeerLauncher.enforceModelEnabled} and its
-     * candidate filter) actually enforces. A default of {@code Set.of()} keeps every other {@link
-     * PeerLauncher} implementer (the herdr adapters, and the two test-fake implementers) unchanged.
-     *
-     * <p>fleetd #422 follow-up: this alone cannot tell "no {@code models:} block at all" from "a
-     * {@code models:} block where nothing is currently off" — both report an empty set here. Delegates
-     * to {@link #modelGateState()} so the two facts always come from the one read {@link
-     * #modelGateState()}'s implementer makes; do not override this method separately from that one.
-     */
-    default Set<String> disabledModels() {
-        return modelGateState().off();
-    }
-
-    /**
-     * Whether the central {@code models.allow:} gate (fleetd #422) is armed at all, together with
-     * which model ids are currently off — fleetd #422 follow-up. {@link #disabledModels()} alone
-     * cannot distinguish two states that both report an empty set: a host with no {@code models:}
-     * block (nothing is gated, and nothing can be) and a host WITH a {@code models:} block where
-     * nothing is currently turned off (the gate is armed and reporting zero). This method exists so
-     * a caller — the startup log, {@code fleet_profiles}/{@code GET /profiles} — can tell the two
-     * apart, the same reason {@code CompletionResolver.UnsetMeaning} exists: an accessor that can
-     * legitimately report "empty" must never let a caller guess why.
-     *
-     * <p>Default {@link ModelGateState#notConfigured()} — every launcher without a {@code models:}
-     * block to read from (the herdr adapters, and the two test-fake implementers), matching {@link
-     * #disabledModels()}'s own default of an empty set.
-     */
-    default ModelGateState modelGateState() {
-        return ModelGateState.notConfigured();
-    }
-
-    /**
-     * fleetd #422 follow-up: the result of {@link #modelGateState()} — see that method's javadoc
-     * for why "armed" and "off" must be reported together from one read rather than as two
-     * separately-derived facts that a reload landing between them could make disagree.
-     *
-     * @param configured {@code true} when a {@code models:} block exists at all (armed), regardless
-     *                   of whether anything in it is currently turned off; {@code false} when there
-     *                   is no block to gate against
-     * @param off        the model ids currently turned off; always empty when {@code configured} is
-     *                   {@code false}
-     */
-    record ModelGateState(boolean configured, Set<String> off) {
-        public ModelGateState {
-            off = Set.copyOf(off);
-        }
-
-        public static ModelGateState notConfigured() {
-            return new ModelGateState(false, Set.of());
-        }
-
-        public static ModelGateState armed(Set<String> off) {
-            return new ModelGateState(true, off);
-        }
-    }
 }

fleetd/src/main/java/dev/ltms/fleet/peer/SpawnRequest.java

@@ -29,9 +29,4 @@ public record SpawnRequest(String profileName, String requestedCwd, String calle
                         String sessionName, String resumeSessionId) {
         this(profileName, requestedCwd, callerCwd, sessionName, resumeSessionId, null);
     }
-
-    /** Return a copy of this request with {@code profileName} replaced by {@code profile}. */
-    public SpawnRequest withProfile(String profile) {
-        return new SpawnRequest(profile, requestedCwd, callerCwd, sessionName, resumeSessionId, role);
-    }
 }

fleetd/src/main/java/dev/ltms/fleet/placement/FixedPlacementPolicy.java

@@ -5,12 +5,10 @@ import java.util.List;
 
 /**
  * Backward-compatible placement: an unqualified spawn always resolves to the configured default
- * profile, exactly as {@code CompositePeerLauncher} did before CB-518. Reachability is a narrower
- * exception (fleetd #315, below): a profile is never checked for reachability up front, only
- * skipped once it has already failed in <em>this same</em> spawn call's retry loop — see the
- * unreachable case below.
+ * profile, exactly as {@code CompositePeerLauncher} did before CB-518. This ignores caps and
+ * reachability so that a pre-existing config behaves identically after upgrade.
  *
- * <p>Six exceptions walk past the default instead of returning it unconditionally:
+ * <p>Three exceptions walk past the default instead of returning it unconditionally:
  * <ul>
  *   <li>Quarantine (CB-578 stage B): a quarantined default is a credential that just refused on
  *       a usage limit, not a transient capacity or reachability concern.
@@ -18,40 +16,13 @@ import java.util.List;
  *       ({@code BackendOutagePolicy}) — a separate, shorter-lived source from quarantine. When a
  *       profile is both quarantined and cooling off, only the quarantine reason is reported
  *       (exhaustion takes priority), matching {@code CompositePeerLauncher}'s explicit-spawn order.
- *   <li>At cap (fleetd #435): a profile whose live count has reached its {@code maxLoad}
- *       ({@link PlacementPolicyUtil#atCap}) — a documented, unconditional capacity limit (see
- *       {@code FleetConfig.Profile#maxLoad}), so {@code fixed} must gate on it exactly as {@code
- *       weighted}/{@code round-robin} already do via {@link PlacementPolicyUtil#available}. Before
- *       this fix {@code fixed} built its own {@link PlacementCandidate} for the default with {@code
- *       maxLoad} forced to {@code null}, so a capped default was chosen anyway on every unqualified
- *       spawn — the cap was advisory, not enforced, for the one placement policy every config uses
- *       by default. Reported only when quarantine and cooling off are both absent, matching {@code
- *       CompositePeerLauncher}'s explicit-spawn check order (quarantine, then cooling off, then max
- *       load, then model-off).
- *   <li>Model off (fleetd #422): a profile whose {@code model:} the operator has turned off in
- *       {@code models.allow:} — an operator decision, never a backend-reported outage, so it is a
- *       fifth, independent source from quarantine, cooling off, and at-cap (never merged with any
- *       of them), exactly as {@code CompositePeerLauncher.enforceModelEnabled} and {@link
- *       PlacementPolicyUtil#available} treat it. When a profile is model-off <em>and</em> quarantined,
- *       cooling off, or at cap, only the higher-priority reason is reported, matching {@code
- *       CompositePeerLauncher}'s explicit-spawn check order (quarantine, then cooling off, then max
- *       load, then model-off).
- *   <li>Unreachable (fleetd #315): {@code CompositePeerLauncher.spawn} retries a failed candidate
- *       on the next one and rebuilds the {@link PlacementContext} so {@code ctx.unreachable()}
- *       names every profile that already failed with {@code PeerUnreachableException} in this same
- *       call. Without this check {@code select} kept handing back the same dead default forever —
- *       the retry loop's own comment says "so the policy excludes this profile", and this is what
- *       makes that true for {@code fixed} too, matching {@code weighted}/{@code round-robin}
- *       (both filter on {@code ctx.unreachable()} via {@link PlacementPolicyUtil#available}).
  *   <li>Weight 0 (CB-554): {@code fixed} is still automatic selection, so a profile the operator
  *       marked "never auto-select me" ({@code weight <= 0}) must be skipped here exactly as
  *       {@code weighted}/{@code round-robin} skip it — an explicit {@code fleet_spawn} naming
  *       the profile is unaffected, only this automatic fallback walk.
  * </ul>
- * A fleet where nothing is ever quarantined, cooling off, at cap, model-off, unreachable, or
- * weight-0 never exercises any of these paths, so today's behaviour is unchanged — in particular,
- * the very first selection of a spawn call always sees an empty {@code unreachable} set, so the
- * first choice is untouched.
+ * A fleet where nothing is ever quarantined, cooling off, or weight-0 never exercises any of these
+ * paths, so today's behaviour is unchanged.
  */
 final class FixedPlacementPolicy implements PlacementPolicy {
 
@@ -59,14 +30,12 @@ final class FixedPlacementPolicy implements PlacementPolicy {
     public PlacementCandidate select(PlacementContext ctx) {
         String d = ctx.defaultProfile();
         if (d != null && !d.isBlank() && !ctx.quarantined().contains(d) && !ctx.coolingOff().contains(d)
-                && !ctx.modelOff().contains(d) && !ctx.unreachable().contains(d) && !weightExcluded(ctx, d)
-                && !capExcluded(ctx, d)) {
+                && !weightExcluded(ctx, d)) {
             return new PlacementCandidate(d, null, 1.0f, null);
         }
         for (PlacementCandidate c : ctx.candidates()) {
             if (!ctx.quarantined().contains(c.profile()) && !ctx.coolingOff().contains(c.profile())
-                    && !ctx.modelOff().contains(c.profile()) && !ctx.unreachable().contains(c.profile())
-                    && !c.excluded() && !PlacementPolicyUtil.atCap(ctx, c)) {
+                    && !c.excluded()) {
                 return new PlacementCandidate(c.profile(), null, c.weight(), c.maxLoad());
             }
         }
@@ -75,18 +44,8 @@ final class FixedPlacementPolicy implements PlacementPolicy {
             // Exhaustion quarantine takes priority: reported only when quarantine is absent, so the
             // message never claims "cooling off" for a profile that is really backend-exhausted.
             boolean dCoolingOff = !dQuarantined && ctx.coolingOff().contains(d);
-            // fleetd #435: at-cap sits between cooling off and model-off, matching
-            // CompositePeerLauncher's explicit-spawn check order (quarantine, cooling off, max load,
-            // then model-off) — reported only when quarantine/cooling-off are both absent.
-            boolean dAtCap = !dQuarantined && !dCoolingOff && capExcluded(ctx, d);
-            // fleetd #422: model-off is a fifth, independent source (an operator decision) — but
-            // quarantine/cooling-off/at-cap still take priority when more than one applies, matching
-            // CompositePeerLauncher's explicit-spawn check order (quarantine, cooling off, max load,
-            // then model-off).
-            boolean dModelOff = !dQuarantined && !dCoolingOff && !dAtCap && ctx.modelOff().contains(d);
-            boolean dUnreachable = ctx.unreachable().contains(d);
             boolean dWeightExcluded = weightExcluded(ctx, d);
-            if (dQuarantined || dCoolingOff || dAtCap || dModelOff || dUnreachable || dWeightExcluded) {
+            if (dQuarantined || dCoolingOff || dWeightExcluded) {
                 List<String> reasons = new ArrayList<>();
                 if (dQuarantined) {
                     reasons.add("is quarantined (backend exhausted)");
@@ -94,17 +53,6 @@ final class FixedPlacementPolicy implements PlacementPolicy {
                 if (dCoolingOff) {
                     reasons.add("is cooling off after repeated backend errors");
                 }
-                if (dAtCap) {
-                    PlacementCandidate c = candidateFor(ctx, d);
-                    int live = ctx.liveCount().apply(d);
-                    reasons.add("is at maxLoad (" + live + " live >= " + c.maxLoad() + " cap)");
-                }
-                if (dModelOff) {
-                    reasons.add("names a model the operator has turned off in models.allow");
-                }
-                if (dUnreachable) {
-                    reasons.add("is unreachable");
-                }
                 if (dWeightExcluded) {
                     reasons.add("has weight 0 (excluded from automatic selection)");
                 }
@@ -114,38 +62,18 @@ final class FixedPlacementPolicy implements PlacementPolicy {
         }
         if (!ctx.candidates().isEmpty()) {
             throw new PlacementException("all worker profiles are excluded from automatic "
-                    + "selection (quarantined, cooling off, at cap, model-off, unreachable, or weight-0)");
+                    + "selection (quarantined, cooling off, or weight-0)");
         }
         throw new PlacementException("no worker profiles configured");
     }
 
     /** Whether {@code profile} carries {@code weight <= 0} (CB-554) among {@code ctx}'s candidates. */
     private static boolean weightExcluded(PlacementContext ctx, String profile) {
-        PlacementCandidate c = candidateFor(ctx, profile);
-        return c != null && c.excluded();
-    }
-
-    /**
-     * Whether {@code profile} has reached its {@code maxLoad} cap (fleetd #435), using the shared
-     * {@link PlacementPolicyUtil#atCap} definition — the same one {@code weighted}/{@code
-     * round-robin} already consult via {@link PlacementPolicyUtil#available}. Looked up by name,
-     * the same way {@link #weightExcluded} is: the default fast path above builds its own {@link
-     * PlacementCandidate} with {@code maxLoad} forced to {@code null} (it carries no cap of its
-     * own), so the candidate actually configured for {@code profile} has to be found in {@code
-     * ctx.candidates()} first.
-     */
-    private static boolean capExcluded(PlacementContext ctx, String profile) {
-        PlacementCandidate c = candidateFor(ctx, profile);
-        return c != null && PlacementPolicyUtil.atCap(ctx, c);
-    }
-
-    /** The configured candidate named {@code profile} in {@code ctx}, or {@code null} if none. */
-    private static PlacementCandidate candidateFor(PlacementContext ctx, String profile) {
         for (PlacementCandidate c : ctx.candidates()) {
             if (c.profile().equals(profile)) {
-                return c;
+                return c.excluded();
             }
         }
-        return null;
+        return false;
     }
 }

fleetd/src/main/java/dev/ltms/fleet/placement/PlacementContext.java

@@ -22,29 +22,11 @@ import java.util.function.Function;
  *                       the two apart so its refusal message says "cooling off", not "exhausted",
  *                       when only this one is active. A profile can be in both sets at once; when it
  *                       is, exhaustion quarantine is reported (it takes priority).
- * @param modelOff       profiles whose {@code model:} is currently turned off in {@code
- *                       models.allow:} (fleetd #422) — an operator decision, not a backend-reported
- *                       outage, so a SEPARATE, independent source from both {@code quarantined} and
- *                       {@code coolingOff}. A profile can be in this set together with either (or
- *                       both) of the others; {@link PlacementPolicyUtil} counts it into its own
- *                       bucket rather than merging it into theirs, the same reason
- *                       {@code coolingOff} is kept apart from {@code quarantined}.
  */
 public record PlacementContext(String defaultProfile,
                                List<PlacementCandidate> candidates,
                                Function<String, Integer> liveCount,
                                Set<String> unreachable,
                                Set<String> quarantined,
-                               Set<String> coolingOff,
-                               Set<String> modelOff) {
-
-    /**
-     * Back-compat form before the fleetd #422 model on/off gate was added — no candidate's model
-     * is off. Keeps pre-#422 call sites (tests included) compiling and behaving identically.
-     */
-    public PlacementContext(String defaultProfile, List<PlacementCandidate> candidates,
-                            Function<String, Integer> liveCount, Set<String> unreachable,
-                            Set<String> quarantined, Set<String> coolingOff) {
-        this(defaultProfile, candidates, liveCount, unreachable, quarantined, coolingOff, Set.of());
-    }
+                               Set<String> coolingOff) {
 }

fleetd/src/main/java/dev/ltms/fleet/placement/PlacementDecision.java

@@ -1,49 +0,0 @@
-package dev.ltms.fleet.placement;
-
-import dev.ltms.fleet.peer.MemberRole;
-import dev.ltms.fleet.peer.PeerLauncher;
-import dev.ltms.fleet.peer.SpawnRequest;
-
-/**
- * An already-completed placement choice — the outcome of one {@link PeerLauncher#place} call,
- * carried forward so a later {@link PeerLauncher#spawn(SpawnRequest, PlacementDecision)} can honor
- * it directly instead of re-resolving the profile a second time (fleetd #425 rework, round 2).
- *
- * <p>The problem this exists to close: a caller that must know the profile <em>before</em> it can
- * spawn — {@code SessionManager.acquireWithWorktree} provisions a worktree's {@code repoRoot} and
- * parity overlay for a specific profile before the peer process exists — used to resolve that name
- * with {@code PeerLauncher.routedProfileFor(role)} and then hand the SAME string back to {@link
- * PeerLauncher#spawn(SpawnRequest)} as an EXPLICIT profile. That re-resolution is not free: naming
- * a profile explicitly makes {@code CompositePeerLauncher.spawn} take its THROWING branch
- * ({@code enforceNotQuarantined}/{@code enforceNotCoolingOff}/{@code enforceMaxLoad}/{@code
- * enforceModelEnabled}), while an unqualified spawn's ROUTING branch never runs those checks at
- * all — it instead FALLS THROUGH to the next candidate on exactly the same conditions the throwing
- * branch refuses on. That disagreement is deliberate: an operator who names a profile should get a
- * refusal, not a silent substitution. The bug is turning the fall-through into a refusal by
- * accident — resolving a name through the routing side and then re-entering the refusing side with
- * it, for a decision the routing side had already approved by walking past everything else.
- * Before fleetd #435, this accident was also reachable through {@code maxLoad} specifically: the
- * default {@code fixed} placement policy did not evaluate {@code maxLoad} at all for automatic
- * selection, so a profile placement itself just approved could still die at {@code enforceMaxLoad}
- * one call later, purely because the caller's route to the spawn passed through an explicit
- * profile name instead of the routing branch — a failure a worktree-less unqualified spawn would
- * never hit. fleetd #435 closed that specific gap ({@code fixed} now evaluates {@code maxLoad}
- * exactly like every other placement policy), so a {@link PlacementDecision} can no longer be
- * at-cap in the first place — but the refusal-vs-fall-through disagreement above was never about
- * {@code maxLoad}, and resolving a name and re-entering the refusing branch with it is still wrong
- * for every OTHER condition placement filters on.
- *
- * <p>{@link PeerLauncher#spawn(SpawnRequest, PlacementDecision)} closes that by spawning through
- * the identical code path the routing branch itself uses, keyed off the SAME decision {@link
- * PeerLauncher#place} returned — no re-checking of any condition placement already evaluated. A
- * resolve-then-spawn caller and a blank-profile {@link PeerLauncher#spawn(SpawnRequest)} caller can
- * then never disagree about which conditions apply to the same placement state, and neither one
- * re-opens the window between the placement decision and the spawn in which the underlying state
- * could otherwise move.
- *
- * @param profile the profile this decision resolved to (may be {@code null} only when no profile is
- *                configured at all — the same corner case {@link PeerLauncher#defaultProfile()}
- *                already tolerates)
- */
-public record PlacementDecision(String profile) {
-}

fleetd/src/main/java/dev/ltms/fleet/placement/PlacementPolicyUtil.java

@@ -11,40 +11,28 @@ final class PlacementPolicyUtil {
     private PlacementPolicyUtil() {
     }
 
-    /**
-     * True when {@code c} has reached its {@code maxLoad} cap: {@code liveCount(c.profile()) >=
-     * c.maxLoad()}. A {@code null} maxLoad means unlimited, so it is never at cap.
-     *
-     * <p>Extracted as the single shared definition of "at cap" (fleetd #435): before this fix it
-     * was computed inline in both {@link #available} and {@link #emptyException}, and {@code
-     * FixedPlacementPolicy} — not a caller of either — quietly kept its own {@code select} free of
-     * any cap check at all, so a capped default profile was chosen anyway under the default
-     * placement policy. Every automatic policy must call this, not re-derive it.
-     */
-    static boolean atCap(PlacementContext ctx, PlacementCandidate c) {
-        Integer cap = c.maxLoad();
-        return cap != null && ctx.liveCount().apply(c.profile()) >= cap;
-    }
-
     /**
      * Candidates that are not weight-excluded (CB-554: explicit {@code weight <= 0}, checked
      * first because it is a static config choice rather than transient state), not
      * known-unreachable, not quarantined (CB-578 stage B), not cooling off after repeated backend
-     * errors (fleetd #201 Unit 5 — a separate, shorter-lived source from quarantine), not naming a
-     * model the operator has turned off (fleetd #422 — a third, independent source: an operator
-     * decision, never a backend-reported outage), and have not reached their maxLoad (see {@link
-     * #atCap}). A {@code null} maxLoad means unlimited.
+     * errors (fleetd #201 Unit 5 — a separate, shorter-lived source from quarantine), and have not
+     * reached their maxLoad. A {@code null} maxLoad means unlimited.
      */
     static List<PlacementCandidate> available(PlacementContext ctx) {
         List<PlacementCandidate> out = new ArrayList<>();
         for (PlacementCandidate c : ctx.candidates()) {
             if (c.excluded() || ctx.unreachable().contains(c.profile())
                     || ctx.quarantined().contains(c.profile())
-                    || ctx.coolingOff().contains(c.profile())
-                    || ctx.modelOff().contains(c.profile())
-                    || atCap(ctx, c)) {
+                    || ctx.coolingOff().contains(c.profile())) {
                 continue;
             }
+            Integer cap = c.maxLoad();
+            if (cap != null) {
+                int live = ctx.liveCount().apply(c.profile());
+                if (live >= cap) {
+                    continue;
+                }
+            }
             out.add(c);
         }
         return out;
@@ -52,13 +40,12 @@ final class PlacementPolicyUtil {
 
     /**
      * Build a clear exception describing why every candidate was dropped: all weight-0, all
-     * quarantined, all cooling off, all model-off, all at capacity, all unreachable, or a mix. Each
-     * candidate is counted into exactly one bucket (weight-excluded first, then quarantined, then
-     * cooling off, then model-off) so a candidate excluded for more than one reason is never
-     * double-counted — a candidate that is both quarantined (CB-578 stage B, backend exhausted) and
-     * cooling off (fleetd #201 Unit 5, repeated backend errors) counts only as quarantined, matching
-     * {@code CompositePeerLauncher}'s explicit-spawn ordering: exhaustion quarantine takes priority
-     * when more than one applies.
+     * quarantined, all cooling off, all at capacity, all unreachable, or a mix. Each candidate is
+     * counted into exactly one bucket (weight-excluded first, then quarantined, then cooling off)
+     * so a candidate excluded for more than one reason is never double-counted — a candidate that is
+     * both quarantined (CB-578 stage B, backend exhausted) and cooling off (fleetd #201 Unit 5,
+     * repeated backend errors) counts only as quarantined, matching {@code CompositePeerLauncher}'s
+     * explicit-spawn ordering: exhaustion quarantine takes priority when both are active.
      */
     static PlacementException emptyException(PlacementContext ctx) {
         int weightExcluded = 0;
@@ -66,19 +53,17 @@ final class PlacementPolicyUtil {
         int unreachable = 0;
         int quarantined = 0;
         int coolingOff = 0;
-        int modelOff = 0;
         for (PlacementCandidate c : ctx.candidates()) {
+            Integer cap = c.maxLoad();
             if (c.excluded()) {
                 weightExcluded++;
             } else if (ctx.quarantined().contains(c.profile())) {
                 quarantined++;
             } else if (ctx.coolingOff().contains(c.profile())) {
                 coolingOff++;
-            } else if (ctx.modelOff().contains(c.profile())) {
-                modelOff++;
             } else if (ctx.unreachable().contains(c.profile())) {
                 unreachable++;
-            } else if (atCap(ctx, c)) {
+            } else if (cap != null && ctx.liveCount().apply(c.profile()) >= cap) {
                 atCap++;
             }
         }
@@ -98,10 +83,6 @@ final class PlacementPolicyUtil {
             return new PlacementException(
                     "all worker profiles are cooling off after repeated backend errors");
         }
-        if (modelOff == total) {
-            return new PlacementException(
-                    "all worker profiles name a model the operator has turned off");
-        }
         if (atCap == total) {
             return new PlacementException("all worker profiles are at maxLoad");
         }
@@ -111,9 +92,8 @@ final class PlacementPolicyUtil {
         return new PlacementException("no worker profile available: " + atCap + " at maxLoad, "
                 + unreachable + " unreachable, " + quarantined + " quarantined, "
                 + coolingOff + " cooling off, "
-                + modelOff + " model-off, "
                 + weightExcluded + " weight-0, "
-                + (total - atCap - unreachable - quarantined - coolingOff - modelOff - weightExcluded)
+                + (total - atCap - unreachable - quarantined - coolingOff - weightExcluded)
                 + " remaining");
     }
 }

fleetd/src/main/java/dev/ltms/fleet/power/CaffeinateSleepAssertionMechanism.java

@@ -1,93 +0,0 @@
-package dev.ltms.fleet.power;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.io.IOException;
-import java.util.Locale;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-/**
- * Holds macOS idle sleep off by keeping a {@code caffeinate -i} child process alive for the life
- * of the returned {@link SleepAssertion}.
- *
- * <p>{@code -i} asserts only against <em>idle</em> sleep — it does not stop the lid closing or an
- * operator-requested sleep from taking effect. That is deliberate: this class exists to stop an
- * unattended host from sleeping out from under a member's long turn, never to override the
- * operator. {@code -s}/{@code -d} (which also block system/display sleep on demand) are
- * intentionally not used here.
- *
- * <p>{@link #acquire()} never throws. It returns {@code null} — a no-op — off macOS, and again if
- * starting the {@code caffeinate} child fails for any reason (binary missing, process table full,
- * …); either case is logged once at INFO, not on every occurrence, so a daemon that runs for
- * weeks with the tool unavailable does not fill its log.
- */
-public final class CaffeinateSleepAssertionMechanism implements SleepAssertionMechanism {
-
-    private static final Logger log = LoggerFactory.getLogger(CaffeinateSleepAssertionMechanism.class);
-
-    private final AtomicBoolean loggedOnce = new AtomicBoolean(false);
-
-    /** {@code true} when running on macOS, the only platform {@code caffeinate} ships on. */
-    public static boolean isSupportedPlatform() {
-        return isSupportedPlatform(System.getProperty("os.name"));
-    }
-
-    /** Package-visible so a test can drive the platform check without touching a real property. */
-    static boolean isSupportedPlatform(String osName) {
-        return osName != null && osName.toLowerCase(Locale.ROOT).contains("mac");
-    }
-
-    @Override
-    public SleepAssertion acquire() {
-        if (!isSupportedPlatform()) {
-            logOnce("not running on macOS (os.name={}); the idle-sleep guard is a no-op on this platform",
-                    System.getProperty("os.name"));
-            return null;
-        }
-        try {
-            Process process = new ProcessBuilder("caffeinate", "-i")
-                    .redirectOutput(ProcessBuilder.Redirect.DISCARD)
-                    .redirectError(ProcessBuilder.Redirect.DISCARD)
-                    .start();
-            return new CaffeinateAssertion(process);
-        } catch (IOException | RuntimeException e) {
-            logOnce("could not start 'caffeinate -i' ({}); the host may idle-sleep while members are live",
-                    e.toString());
-            return null;
-        }
-    }
-
-    private void logOnce(String format, Object arg) {
-        if (loggedOnce.compareAndSet(false, true)) {
-            log.info("idle-sleep guard: " + format, arg);
-        }
-    }
-
-    /** Wraps the live {@code caffeinate} child; {@link #close} force-destroys it, idempotently. */
-    private static final class CaffeinateAssertion implements SleepAssertion {
-
-        private final Process process;
-
-        CaffeinateAssertion(Process process) {
-            this.process = process;
-        }
-
-        @Override
-        public void close() {
-            if (!process.isAlive()) {
-                return;
-            }
-            process.destroy();
-            try {
-                if (!process.waitFor(2, TimeUnit.SECONDS)) {
-                    process.destroyForcibly();
-                }
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-                process.destroyForcibly();
-            }
-        }
-    }
-}

fleetd/src/main/java/dev/ltms/fleet/power/IdleSleepGuard.java

@@ -1,105 +0,0 @@
-package dev.ltms.fleet.power;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.function.IntSupplier;
-
-/**
- * Holds an OS-level assertion against idle sleep for exactly as long as at least one fleet
- * member is live.
- *
- * <p><strong>Why this exists:</strong> a fleetd host was measured idle-sleeping after as little
- * as one minute of inactivity (its {@code pmset -g custom} reports {@code sleep 1} on battery).
- * Overnight the daemon's AMQP link to the broker dropped 13 times, and cross-checking every drop
- * minute against {@code pmset -g log} found a sleep or wake event in the same minute or the one
- * before, every time. The AMQP churn is only the visible symptom — the real problem is that a
- * member mid-turn freezes with the host, and a long turn with nobody typing is exactly the case
- * that goes idle.
- *
- * <p><strong>How it tracks "live":</strong> this is driven by {@code SessionManager}'s existing
- * {@code onAcquire}/{@code onRelease} lifecycle hooks (added for CB-520/CB-516, previously wired
- * to nothing but the reply inbox) rather than a second member count kept in parallel. Wire it as:
- * <pre>{@code
- * IdleSleepGuard guard = new IdleSleepGuard(mechanism, sessions::size);
- * sessions.onAcquire(_ -> guard.recheck());
- * sessions.onRelease(_ -> guard.recheck());
- * }</pre>
- * Every acquire/release event re-reads {@code SessionManager#size()} — the same registry {@code
- * fleet_list}'s live/capacity numbers are themselves computed from — and only an actual 0→1 or
- * 1→0 crossing touches the OS. A listener exception is already caught and logged by {@code
- * SessionManager} itself (it must never let a listener failure block the acquire/release it is
- * reacting to), so {@link #recheck()} does not need its own top-level try/catch to honor that.
- *
- * <p><strong>Failure posture:</strong> every method here is safe to call whether or not {@link
- * SleepAssertionMechanism#acquire()} actually works. A mechanism that returns {@code null} (wrong
- * platform, missing tool, spawn failure) simply means this guard never holds anything — it never
- * throws and never blocks a spawn, a release, or shutdown.
- */
-public final class IdleSleepGuard implements AutoCloseable {
-
-    private static final Logger log = LoggerFactory.getLogger(IdleSleepGuard.class);
-
-    private final SleepAssertionMechanism mechanism;
-    private final IntSupplier liveCount;
-    private final Object lock = new Object();
-    private SleepAssertion held;
-
-    public IdleSleepGuard(SleepAssertionMechanism mechanism, IntSupplier liveCount) {
-        this.mechanism = mechanism;
-        this.liveCount = liveCount;
-    }
-
-    /**
-     * Re-read the live count and acquire or release the held assertion to match: nothing held and
-     * at least one member live ⇒ acquire; something held and no member live ⇒ release. A steady
-     * count (still zero, still positive) is a no-op either way, so a single spawn or release only
-     * ever touches the OS on the crossing, not on every call.
-     */
-    public void recheck() {
-        synchronized (lock) {
-            int live = liveCount.getAsInt();
-            if (live > 0 && held == null) {
-                held = mechanism.acquire();
-                if (held != null) {
-                    log.debug("idle-sleep guard armed: {} live member(s)", live);
-                }
-            } else if (live == 0 && held != null) {
-                releaseHeldLocked();
-            }
-        }
-    }
-
-    /** {@code true} while an assertion is actually held. Exposed for tests. */
-    boolean isHeld() {
-        synchronized (lock) {
-            return held != null;
-        }
-    }
-
-    /**
-     * Release whatever is held, if anything. Idempotent and safe to call at any time, including
-     * repeatedly — a daemon shutdown hook calls this unconditionally so no assertion (and no
-     * {@code caffeinate} child) survives the process, even if the drain that would otherwise have
-     * driven the live count to zero was itself interrupted or threw.
-     */
-    @Override
-    public void close() {
-        synchronized (lock) {
-            if (held != null) {
-                releaseHeldLocked();
-            }
-        }
-    }
-
-    /** Caller must hold {@link #lock}. */
-    private void releaseHeldLocked() {
-        try {
-            held.close();
-        } catch (RuntimeException e) {
-            log.warn("idle-sleep guard: failed to release its assertion cleanly: {}", e.toString());
-        } finally {
-            held = null;
-        }
-    }
-}

fleetd/src/main/java/dev/ltms/fleet/power/SleepAssertion.java

@@ -1,11 +0,0 @@
-package dev.ltms.fleet.power;
-
-/**
- * A held OS-level assertion against idle sleep. {@link #close} must be idempotent — safe to call
- * more than once — and must never throw, matching {@link IdleSleepGuard}'s "never break the
- * fleet" contract.
- */
-public interface SleepAssertion extends AutoCloseable {
-    @Override
-    void close();
-}

fleetd/src/main/java/dev/ltms/fleet/power/SleepAssertionMechanism.java

@@ -1,21 +0,0 @@
-package dev.ltms.fleet.power;
-
-/**
- * The OS mechanism {@link IdleSleepGuard} uses to hold and release an idle-sleep assertion. This
- * is the seam a test exercises instead of the real effect (a live {@code caffeinate} child) — see
- * {@code IdleSleepGuardTest}.
- *
- * <p>Implementations must never throw. Every failure — wrong platform, missing tool, a spawn
- * error — must show up as {@link #acquire()} returning {@code null}, so a caller can treat "no
- * assertion held" and "the mechanism could not be used" identically and the fleet keeps running
- * either way.
- */
-public interface SleepAssertionMechanism {
-
-    /**
-     * Acquire a fresh assertion against idle sleep, or {@code null} when this mechanism is not
-     * usable right now (wrong platform, the tool is missing, the child process could not start).
-     * Never throws.
-     */
-    SleepAssertion acquire();
-}

fleetd/src/main/java/dev/ltms/fleet/rest/FleetApp.java

@@ -9,7 +9,6 @@ import dev.ltms.fleet.auth.Principal;
 import dev.ltms.fleet.guard.GuardException;
 import dev.ltms.fleet.metrics.FleetMetrics;
 import dev.ltms.fleet.metrics.Metrics;
-import dev.ltms.fleet.mcp.FleetMcp;
 import dev.ltms.fleet.herdr.Agent;
 import dev.ltms.fleet.herdr.HerdrClient;
 import dev.ltms.fleet.herdr.HerdrException;
@@ -19,7 +18,6 @@ import dev.ltms.fleet.peer.PeerUnreachableException;
 import dev.ltms.fleet.placement.PlacementException;
 import dev.ltms.fleet.msg.MessageService;
 import dev.ltms.fleet.session.SessionManager;
-import dev.ltms.fleet.session.ShuttingDownException;
 import dev.ltms.fleet.peer.MemberRole;
 import dev.ltms.fleet.session.MemberSession;
 import dev.ltms.fleet.session.WorktreeRequest;
@@ -49,22 +47,6 @@ import java.util.stream.Collectors;
  */
 public final class FleetApp {
 
-    /** The authorization action the matching route handler hands to {@link #allow}. */
-    static Authz.Action routeAction(String route) {
-        return switch (route) {
-            case "GET /metrics" -> Authz.Action.METRICS;
-            case "POST /members" -> Authz.Action.SPAWN;
-            case "DELETE /members/{paneId}" -> Authz.Action.STOP;
-            case "POST /sessions/{id}/message" -> Authz.Action.SEND;
-            case "POST /sessions/{id}/reply" -> Authz.Action.REPLY;
-            case "GET /sessions/{id}/replies" -> Authz.Action.DRAIN;
-            case "POST /sessions/{id}/ask" -> Authz.Action.ASK;
-            case "GET /sessions", "GET /agents", "GET /members", "GET /profiles",
-                    "GET /member-credentials", "GET /sessions/{id}/status", "GET /tasks/{ticket}" -> Authz.Action.READ;
-            default -> throw new IllegalArgumentException("route has no authorization gate: " + route);
-        };
-    }
-
     /** Default blocking window for a message; kept under typical HTTP idle timeouts. */
     private static final long DEFAULT_MESSAGE_TIMEOUT_MS = 25_000;
     private static final long MAX_MESSAGE_TIMEOUT_MS = 120_000;
@@ -88,12 +70,6 @@ public final class FleetApp {
     // absent() (the honest "no policy configured" view) for every constructor that does not wire
     // a real one, so existing legacy call sites keep building without knowing this field exists.
     private final Supplier<MemberCredentialPolicyView> memberCredentials;
-    // fleetd #297: the SAME shared sources FleetMcp.profiles/fleet_profiles reads (BackendQuarantine
-    // and BackendOutagePolicy are each one instance for the whole daemon — see Fleetd wiring) so
-    // GET /profiles cannot drift from fleet_profiles about which profile is quarantined/cooling off.
-    // .none() (the honest "feature not wired" view) for every constructor that does not pass one.
-    private final FleetMcp.QuarantineSource quarantine;
-    private final FleetMcp.OutageSource outage;
     private final ObjectMapper mapper = new ObjectMapper();
 
     /**
@@ -154,23 +130,6 @@ public final class FleetApp {
                        MessageService messages, MemberPresence presence,
                        HttpServlet mcpServlet, CallerResolver auth, Metrics metrics,
                        Predicate<String> deliverable, Supplier<MemberCredentialPolicyView> memberCredentials) {
-        this(herdr, memberHerdr, workers, sessions, messages, presence, mcpServlet, auth, metrics,
-                deliverable, memberCredentials, FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none());
-    }
-
-    /**
-     * @param quarantine the SAME {@link FleetMcp.QuarantineSource} instance passed to {@code
-     *                   FleetMcp} (fleetd #297), so {@code GET /profiles} reports the identical
-     *                   exhaustion-quarantine facts as {@code fleet_profiles} rather than a second,
-     *                   independently-computed copy
-     * @param outage     the SAME {@link FleetMcp.OutageSource} instance passed to {@code FleetMcp} —
-     *                   see {@code quarantine}; a SEPARATE check from it, never merged in
-     */
-    public FleetApp(HerdrClient herdr, HerdrClient memberHerdr, PeerLauncher workers, SessionManager sessions,
-                       MessageService messages, MemberPresence presence,
-                       HttpServlet mcpServlet, CallerResolver auth, Metrics metrics,
-                       Predicate<String> deliverable, Supplier<MemberCredentialPolicyView> memberCredentials,
-                       FleetMcp.QuarantineSource quarantine, FleetMcp.OutageSource outage) {
         this.herdr = herdr;
         this.memberHerdr = memberHerdr != null ? memberHerdr : herdr;
         this.workers = workers;
@@ -181,8 +140,6 @@ public final class FleetApp {
         this.auth = auth;
         this.metrics = metrics;
         this.memberCredentials = memberCredentials != null ? memberCredentials : MemberCredentialPolicyView::absent;
-        this.quarantine = quarantine != null ? quarantine : FleetMcp.QuarantineSource.none();
-        this.outage = outage != null ? outage : FleetMcp.OutageSource.none();
     }
 
     /** Wire routes onto a fresh, unstarted Javalin instance. Caller starts it. */
@@ -265,7 +222,7 @@ public final class FleetApp {
 
     /** Prometheus scrape endpoint (CB-502). */
     private void metrics(Context ctx) {
-        if (!allow(ctx, routeAction("GET /metrics"), null)) {
+        if (!allow(ctx, Authz.Action.METRICS, null)) {
             return;
         }
         ctx.status(200).contentType("text/plain; version=0.0.4; charset=utf-8").result(metrics.render());
@@ -337,7 +294,7 @@ public final class FleetApp {
      * member workspace (they live on the member daemon only).
      */
     private void sessions(Context ctx) {
-        if (!allow(ctx, routeAction("GET /sessions"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
         List<Map<String, Object>> out = new ArrayList<>();
@@ -362,76 +319,52 @@ public final class FleetApp {
 
     /** Discovery: every agent herdr tracks, keyed by its Claude session UUID. */
     private void agents(Context ctx) {
-        if (!allow(ctx, routeAction("GET /agents"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
-        try {
-            ctx.status(200).json(Map.of("agents",
-                    workers.list().stream().map(Agent.class::cast).map(FleetApp::view).toList()));
-        } catch (HerdrException e) {
-            // fleetd #297: workers.list() reaches herdr — a transport failure must land in the same
-            // {error, detail} envelope every other failure path here uses, not escape as a bare
-            // exception and leave Javalin's default handling to respond outside the JSON contract.
-            herdrError(ctx, e);
-        }
+        ctx.status(200).json(Map.of("agents",
+                workers.list().stream().map(Agent.class::cast).map(FleetApp::view).toList()));
     }
 
     /** CB-304: bridge-owned roster merged with live herdr status by paneId. */
     private void listMembers(Context ctx) {
-        if (!allow(ctx, routeAction("GET /members"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
-        try {
-            // CB-519: the registry key is a host-unique id, not the pane coordinate — join on terminal.
-            Map<String, Agent> live = workers.list().stream()
-                    .map(Agent.class::cast)
-                    .filter(a -> a.terminalId() != null)
-                    .collect(Collectors.toMap(Agent::terminalId, Function.identity(), (_, b) -> b));
-            // fleetd #209: this REST roster reports agentSessionId via SessionManager.rosterView, so it
-            // uses the resolving roster read (caller-driven, not a timer) rather than the plain one.
-            List<Map<String, Object>> out = sessions.rosterResolved().stream()
-                    .map(s -> SessionManager.rosterView(s, live.get(s.terminalId())))
-                    .toList();
-            Map<String, Object> body = new LinkedHashMap<>();
-            // fleetd #199: the endpoint became /members in the CB-634 rename but the body key stayed
-            // "workers", so a caller that read "members" saw an empty fleet and reported no members at
-            // all. "members" is the canonical key; "workers" stays as a deprecated alias so an existing
-            // REST consumer keeps working — the out-of-band path a lead falls back to when its MCP mount
-            // drops reads this endpoint. Drop the alias once nothing reads it.
-            body.put("members", out);
-            body.put("workers", out);
-            // CB-586: operator visibility for the refs/wip snapshot store without shelling into the
-            // repo — how many snapshot refs exist and roughly what they cost. Present only once a
-            // worktree session has established the repo, so a never-snapshotted fleet reports nothing.
-            sessions.wipRefs().ifPresent(st -> body.put("wipRefs",
-                    Map.of("count", st.count(), "costBytes", st.costBytes())));
-            ctx.status(200).json(body);
-        } catch (HerdrException e) {
-            // fleetd #297: same reasoning as agents() above — this is the out-of-band roster a lead
-            // falls back to when its MCP mount drops, so it must stay inside the JSON error contract
-            // exactly when herdr is briefly unreachable, not escape as a bare exception.
-            herdrError(ctx, e);
-        }
+        // CB-519: the registry key is a host-unique id, not the pane coordinate — join on terminal.
+        Map<String, Agent> live = workers.list().stream()
+                .map(Agent.class::cast)
+                .filter(a -> a.terminalId() != null)
+                .collect(Collectors.toMap(Agent::terminalId, Function.identity(), (_, b) -> b));
+        // fleetd #209: this REST roster reports agentSessionId via SessionManager.rosterView, so it
+        // uses the resolving roster read (caller-driven, not a timer) rather than the plain one.
+        List<Map<String, Object>> out = sessions.rosterResolved().stream()
+                .map(s -> SessionManager.rosterView(s, live.get(s.terminalId())))
+                .toList();
+        Map<String, Object> body = new LinkedHashMap<>();
+        // fleetd #199: the endpoint became /members in the CB-634 rename but the body key stayed
+        // "workers", so a caller that read "members" saw an empty fleet and reported no members at
+        // all. "members" is the canonical key; "workers" stays as a deprecated alias so an existing
+        // REST consumer keeps working — the out-of-band path a lead falls back to when its MCP mount
+        // drops reads this endpoint. Drop the alias once nothing reads it.
+        body.put("members", out);
+        body.put("workers", out);
+        // CB-586: operator visibility for the refs/wip snapshot store without shelling into the
+        // repo — how many snapshot refs exist and roughly what they cost. Present only once a
+        // worktree session has established the repo, so a never-snapshotted fleet reports nothing.
+        sessions.wipRefs().ifPresent(st -> body.put("wipRefs",
+                Map.of("count", st.count(), "costBytes", st.costBytes())));
+        ctx.status(200).json(body);
     }
 
-    /**
-     * The configured worker profiles, which one a no-argument spawn uses, and (fleetd #297) the two
-     * outage states {@code fleet_profiles} already reports: {@code quarantined} (CB-578 stage B —
-     * the backend reported it out of capacity) and {@code coolingOff} (fleetd #201 Unit 5 — the
-     * credential threw repeated non-exhaustion backend errors). Both are read from the SAME shared
-     * {@link FleetMcp.QuarantineSource}/{@link FleetMcp.OutageSource} instances {@code FleetMcp}
-     * reads, never recomputed, so the two doors cannot disagree about which profile is down and why.
-     * Independent checks, so a profile can appear in both maps at once; each map is present only
-     * when at least one profile is in that state.
-     */
+    /** The configured worker profiles and which one a no-argument spawn uses. */
     private void profiles(Context ctx) {
-        if (!allow(ctx, routeAction("GET /profiles"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
-        // fleetd #297: ONE body builder, shared with fleet_profiles. Handing both doors the same
-        // QuarantineSource/OutageSource instances stops them reading different facts; rendering
-        // through the same method stops them reporting those facts differently. Both are needed.
-        ctx.status(200).json(FleetMcp.profilesView(workers, quarantine, outage));
+        ctx.status(200).json(Map.of(
+                "profiles", workers.profiles(),
+                "default", workers.defaultProfile() == null ? "" : workers.defaultProfile()));
     }
 
     /**
@@ -443,7 +376,7 @@ public final class FleetApp {
      * name list, which is exactly what let the list drift silently behind the real policy.
      */
     private void memberCredentials(Context ctx) {
-        if (!allow(ctx, routeAction("GET /member-credentials"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
         MemberCredentialPolicyView view = memberCredentials.get();
@@ -463,7 +396,7 @@ public final class FleetApp {
      * the subscription boundary, 400 for an unknown profile.
      */
     private void spawnMember(Context ctx) {
-        if (!allow(ctx, routeAction("POST /members"), null)) {
+        if (!allow(ctx, Authz.Action.SPAWN, null)) {
             return;
         }
         String role = ctx.queryParam("role");
@@ -502,11 +435,6 @@ public final class FleetApp {
             ctx.status(201).json(view(member));
         } catch (GuardException e) {
             ctx.status(403).json(Map.of("error", "subscription_boundary", "detail", e.getMessage()));
-        } catch (ShuttingDownException e) {
-            // fleetd #308: the daemon's shutdown drain has already started — 503, not a bare 500,
-            // so this reads the same as PlacementException below: valid request, refused because
-            // of a transient daemon state rather than a bad argument.
-            ctx.status(503).json(Map.of("error", "shutting_down", "detail", e.getMessage()));
         } catch (PlacementException e) {
             // CB-599: no candidate had capacity (maxLoad, quarantine, or all-exhausted) — a benign,
             // likely-transient refusal, distinct from "profile does not exist" below. 503: the
@@ -516,12 +444,6 @@ public final class FleetApp {
             ctx.status(400).json(Map.of("error", "unknown_profile", "detail", e.getMessage()));
         } catch (PeerUnreachableException e) {
             ctx.status(502).json(Map.of("error", "spawn_timeout", "detail", e.getMessage()));
-        } catch (HerdrException e) {
-            // fleetd #304: not every herdr failure on the spawn path is a readiness timeout, so
-            // PeerUnreachableException above does not cover this. Without this catch the exception
-            // escapes to Javalin's default 500, while fleet_spawn reports the same failure as a
-            // clean named error (FleetMcp.spawn) — the #297 one-door-guarded shape.
-            herdrError(ctx, e);
         }
     }
 
@@ -542,29 +464,13 @@ public final class FleetApp {
         return (s == null || s.isBlank()) ? null : s;
     }
 
-    /**
-     * Tear a worker down by pane id.
-     *
-     * <p>fleetd #304: the {@code HerdrException} catch is not cosmetic. {@code release} deregisters
-     * the session, notifies the release listener and preserves a dirty worktree <em>before</em> it
-     * calls {@code launcher.stop}, so a throw from that stop arrives after the teardown the caller
-     * asked for has already happened. Letting it escape gave Javalin's default 500, which tells the
-     * caller to retry — and the retry finds nothing in the registry, reaches the same stop, and
-     * throws again, so it can never succeed. {@code herdrError} instead answers 404 ("the pane is
-     * gone, stop retrying") or 502 ("herdr is upstream and broken, a retry may help"), matching what
-     * {@code fleet_stop} reports for the same failure.
-     */
+    /** Tear a worker down by pane id. */
     private void stopMember(Context ctx) {
         String paneId = ctx.pathParam("paneId");
-        if (!allow(ctx, routeAction("DELETE /members/{paneId}"), paneId)) {
-            return;
-        }
-        try {
-            sessions.release(paneId);
-        } catch (HerdrException e) {
-            herdrError(ctx, e);
+        if (!allow(ctx, Authz.Action.STOP, paneId)) {
             return;
         }
+        sessions.release(paneId);
         ctx.status(204);
     }
 
@@ -576,7 +482,7 @@ public final class FleetApp {
      */
     private void sendMessage(Context ctx) {
         String id = ctx.pathParam("id");
-        if (!allow(ctx, routeAction("POST /sessions/{id}/message"), id)) {
+        if (!allow(ctx, Authz.Action.SEND, id)) {
             return;
         }
         String content;
@@ -663,7 +569,7 @@ public final class FleetApp {
      */
     private void askMessage(Context ctx) {
         String id = ctx.pathParam("id");
-        if (!allow(ctx, routeAction("POST /sessions/{id}/ask"), id)) {
+        if (!allow(ctx, Authz.Action.ASK, id)) {
             return;
         }
         String question;
@@ -696,17 +602,13 @@ public final class FleetApp {
     /**
      * The worker's structured reply ({@code fleet_reply}) — resolves the blocking send awaiting
      * on this session, or queues the reply in the inbox when no send is open (CB-307).
-     *
-     * <p>fleetd #365: the response body's {@code delivered} field used to be unconditionally
-     * {@code true} for either case; it now reports whether a send/ticket was actually resolved,
-     * with {@code outcome} naming which (see {@link MessageService.ReplyOutcome}).
      */
     private void replyMessage(Context ctx) {
         String id = ctx.pathParam("id");
         // The rule that matters: a worker may reply only as itself. Over MCP this was already true
         // structurally (identity comes from the connection, never an argument); over REST the path
         // id was simply trusted, so this is where the invariant actually gets enforced.
-        if (!allow(ctx, routeAction("POST /sessions/{id}/reply"), id)) {
+        if (!allow(ctx, Authz.Action.REPLY, id)) {
             return;
         }
         String content;
@@ -716,26 +618,8 @@ public final class FleetApp {
             ctx.status(400).json(Map.of("error", "bad_request", "detail", "body must be JSON"));
             return;
         }
-        // fleetd #302: content is required. `.path("content").asText("")` above turns a missing key
-        // into "" rather than throwing, so without this check an empty/blank reply used to reach
-        // messages.reply(...) and silently resolve the lead's waiter — the same class of bug as the
-        // sibling "content is required" guards on sendMessage/askMessage below, except this one wrote
-        // a WRONG value instead of failing loudly. The check lives in MessageService.reply so both
-        // this door and FleetMcp.reply inherit the same rule; this catch only translates it into the
-        // {error, detail} envelope this file uses everywhere else.
-        MessageService.ReplyOutcome outcome;
-        try {
-            outcome = messages.reply(id, content);
-        } catch (IllegalArgumentException e) {
-            ctx.status(400).json(Map.of("error", "bad_request", "detail", e.getMessage()));
-            return;
-        }
-        // fleetd #365: "delivered": true used to be unconditional here, whether the reply resolved
-        // a waiting send or was merely queued in the inbox for a later drain — the same gap
-        // FleetMcp.reply had over MCP. `delivered` now reflects which actually happened, and
-        // `outcome` names the specific case (see MessageService.ReplyOutcome).
-        ctx.status(200).json(Map.of("sessionId", id, "delivered", outcome.delivered(),
-                "outcome", outcome.wireName()));
+        messages.reply(id, content);
+        ctx.status(200).json(Map.of("sessionId", id, "delivered", true));
     }
 
     /**
@@ -745,7 +629,7 @@ public final class FleetApp {
      */
     private void drainReplies(Context ctx) {
         String id = ctx.pathParam("id");
-        if (!allow(ctx, routeAction("GET /sessions/{id}/replies"), id)) {
+        if (!allow(ctx, Authz.Action.DRAIN, id)) {
             return;
         }
         var replies = messages.drainReplies(id);
@@ -763,7 +647,7 @@ public final class FleetApp {
      */
     private void sessionStatus(Context ctx) {
         String id = ctx.pathParam("id");
-        if (!allow(ctx, routeAction("GET /sessions/{id}/status"), id)) {
+        if (!allow(ctx, Authz.Action.READ, id)) {
             return;
         }
         try {
@@ -788,7 +672,7 @@ public final class FleetApp {
 
     /** Poll an async (wait:false) delegation by ticket. 404 for an unknown/expired ticket. */
     private void taskStatus(Context ctx) {
-        if (!allow(ctx, routeAction("GET /tasks/{ticket}"), null)) {
+        if (!allow(ctx, Authz.Action.READ, null)) {
             return;
         }
         MessageService.TaskView v = messages.poll(ctx.pathParam("ticket"));

fleetd/src/main/java/dev/ltms/fleet/session/GitWorktrees.java

@@ -92,19 +92,7 @@ public final class GitWorktrees implements Worktrees {
     private final String configuredRoot;
     /** OS group name for {@link #shareWithGroup} (fleetd #185 stage 3); {@code null} ⇒ feature off. */
     private final String group;
-    /** Source directory of skill folders for {@link #seedSkills} (fleetd #362, {@code memberSkills:}
-     *  in config); {@code null} ⇒ feature off, no worktree is touched beyond today's behaviour. */
-    private final String memberSkillsSource;
-    /** Extra environment merged into every {@code git} subprocess this instance runs. Always {@code
-     *  Map.of()} from every production constructor. Test seam only (fleetd #362 review fix): lets
-     *  {@code GitWorktreesTest} point {@code GIT_CONFIG_GLOBAL} at an isolated temp file so it can
-     *  drive the real {@link #add} path against a controlled "operator's global git config" and
-     *  prove the excludesFile composition below without ever touching the real machine's config. */
-    private final Map<String, String> gitEnv;
     private final Consumer<String> afterWorktreeAdded;
-    /** How the initial {@code git worktree add} command runs. Package-private test seam for an
-     *  interrupted command after Git has made worktree state. */
-    private final Function<String[], String> worktreeAddRunner;
     /** How {@link #shareWithGroup}'s processes (git config / chgrp / chmod / find) actually run.
      *  Defaults to the real {@link #exec(String...)}. Package-private test seam so a unit test can
      *  prove "no group configured ⇒ zero processes spawned" and inspect exactly what a configured
@@ -134,20 +122,7 @@ public final class GitWorktrees implements Worktrees {
      *                       config); null/blank ⇒ {@link #shareWithGroup} is a no-op.
      */
     public GitWorktrees(String configuredRoot, String group) {
-        this(configuredRoot, group, (String) null);
-    }
-
-    /**
-     * @param configuredRoot     nullable absolute or relative path; null/blank derives a sibling of
-     *                           the repo root.
-     * @param group              optional OS group name (fleetd #185 stage 3, {@code worktreeGroup:}
-     *                           in config); null/blank ⇒ {@link #shareWithGroup} is a no-op.
-     * @param memberSkillsSource fleetd #362: optional directory of skill folders ({@code
-     *                           memberSkills:} in config) copied into every provisioned worktree's
-     *                           {@code .claude/skills/}; null/blank ⇒ {@link #seedSkills} is a no-op.
-     */
-    public GitWorktrees(String configuredRoot, String group, String memberSkillsSource) {
-        this(configuredRoot, group, _ -> {}, null, null, memberSkillsSource);
+        this(configuredRoot, group, _ -> {});
     }
 
     /** Test seam for changing a real worktree between its creation and its security check. */
@@ -157,20 +132,7 @@ public final class GitWorktrees implements Worktrees {
 
     /** Test seam combining a configurable {@code group} with {@link #afterWorktreeAdded}. */
     GitWorktrees(String configuredRoot, String group, Consumer<String> afterWorktreeAdded) {
-        this(configuredRoot, group, afterWorktreeAdded, null, null, null);
-    }
-
-    /** Test seam for changing how {@link #shareWithGroup}'s processes run. */
-    GitWorktrees(String configuredRoot, String group, Consumer<String> afterWorktreeAdded,
-                  Function<String[], String> shareGroupRunner) {
-        this(configuredRoot, group, afterWorktreeAdded, shareGroupRunner, null, null);
-    }
-
-    /** Test seam for changing how the initial {@code git worktree add} command runs, with no
-     *  {@code memberSkillsSource} configured. */
-    GitWorktrees(String configuredRoot, String group, Consumer<String> afterWorktreeAdded,
-                  Function<String[], String> shareGroupRunner, Function<String[], String> worktreeAddRunner) {
-        this(configuredRoot, group, afterWorktreeAdded, shareGroupRunner, worktreeAddRunner, null);
+        this(configuredRoot, group, afterWorktreeAdded, null);
     }
 
     /**
@@ -179,34 +141,13 @@ public final class GitWorktrees implements Worktrees {
      * exactly what commands a configured group runs, without a real second OS user/group.
      *
      * @param shareGroupRunner {@code null} ⇒ the real {@link #exec(String...)}.
-     * @param worktreeAddRunner {@code null} ⇒ the real {@link #exec(String...)}.
-     * @param memberSkillsSource {@code null}/blank ⇒ {@link #seedSkills} is a no-op.
      */
     GitWorktrees(String configuredRoot, String group, Consumer<String> afterWorktreeAdded,
-                  Function<String[], String> shareGroupRunner, Function<String[], String> worktreeAddRunner,
-                  String memberSkillsSource) {
-        this(configuredRoot, group, afterWorktreeAdded, shareGroupRunner, worktreeAddRunner,
-                memberSkillsSource, Map.of());
-    }
-
-    /**
-     * Full test seam, plus {@code gitEnv} (fleetd #362 review fix, verification only): extra
-     * environment merged into every {@code git} subprocess this instance runs, so a test can isolate
-     * something like {@code GIT_CONFIG_GLOBAL} from the real machine while still driving the real
-     * {@link #add} path end to end. Every production constructor above delegates here with {@code
-     * Map.of()}.
-     */
-    GitWorktrees(String configuredRoot, String group, Consumer<String> afterWorktreeAdded,
-                  Function<String[], String> shareGroupRunner, Function<String[], String> worktreeAddRunner,
-                  String memberSkillsSource, Map<String, String> gitEnv) {
+                 Function<String[], String> shareGroupRunner) {
         this.configuredRoot = configuredRoot;
         this.group = (group == null || group.isBlank()) ? null : group;
-        this.memberSkillsSource = (memberSkillsSource == null || memberSkillsSource.isBlank())
-                ? null : memberSkillsSource;
-        this.gitEnv = gitEnv == null ? Map.of() : gitEnv;
         this.afterWorktreeAdded = afterWorktreeAdded == null ? _ -> {} : afterWorktreeAdded;
         this.shareGroupRunner = shareGroupRunner != null ? shareGroupRunner : this::exec;
-        this.worktreeAddRunner = worktreeAddRunner != null ? worktreeAddRunner : this::exec;
     }
 
     @Override
@@ -225,14 +166,13 @@ public final class GitWorktrees implements Worktrees {
         String wt = path.toAbsolutePath().toString();
         log.info("adding worktree branch={} path={} base={}", branch, wt, base);
         removeUserInfoFromHttpsOrigin(repoRoot);
+        exec("git", "-C", repoRoot, "worktree", "add", wt, "-b", branch, base);
         try {
-            worktreeAddRunner.apply(new String[] {"git", "-C", repoRoot, "worktree", "add", wt, "-b", branch, base});
             afterWorktreeAdded.accept(wt);
             requireCredentialFreeHttpsOrigin(wt);
             configureEnvironmentCredentialHelper(repoRoot, wt);
             configureHttpsUrlRewriteForSshOrigin(repoRoot, wt);
             isolateToolSurface(wt);
-            seedSkills(wt);
         } catch (RuntimeException e) {
             cleanupAfterAddFailure(repoRoot, wt, branch, e);
             throw e;
@@ -241,11 +181,10 @@ public final class GitWorktrees implements Worktrees {
     }
 
     /**
-     * {@code git worktree add} may have created the worktree and its branch by the time it, or any
-     * later step through {@link #isolateToolSurface}, throws. This includes
+     * {@code add()} has already created the worktree and its branch by the time any step from
+     * {@link #afterWorktreeAdded} through {@link #isolateToolSurface} can throw — including
      * {@link #requireCredentialFreeHttpsOrigin}, an intended security refusal, not only an IO
-     * accident. A Git-reported {@code worktree add} failure usually creates nothing, but an
-     * interrupted command can leave partial state. Without cleanup, {@code add()} never returns, so its caller
+     * accident. Without this, {@code add()} never returns, so its caller
      * ({@code SessionManager#acquireWithWorktree}) never receives a path to register or clean up:
      * its local {@code path} stays null, the {@code if (path != null)} guard in its own catch block
      * never runs, and the worktree directory and branch leak on disk forever with nothing tracking
@@ -265,10 +204,6 @@ public final class GitWorktrees implements Worktrees {
      * used in {@code SessionManager#acquireWithWorktree}'s own catch block.
      */
     private void cleanupAfterAddFailure(String repoRoot, String worktreePath, String branch, RuntimeException original) {
-        if (!Files.exists(Path.of(worktreePath))) {
-            log.debug("provisioning failed before worktree {} existed; nothing to clean up", worktreePath);
-            return;
-        }
         log.warn("provisioning failed for branch={} path={}: {} — cleaning up before rethrowing",
                 branch, worktreePath, original.getMessage());
         try {
@@ -278,18 +213,13 @@ public final class GitWorktrees implements Worktrees {
                     worktreePath, cleanup.getMessage());
         }
         try {
-            deleteBranch(repoRoot, branch);
+            exec("git", "-C", repoRoot, "branch", "-D", branch);
         } catch (RuntimeException cleanup) {
             log.warn("failed to remove leaked branch {} after provisioning error: {}",
                     branch, cleanup.getMessage());
         }
     }
 
-    @Override
-    public void deleteBranch(String repoRoot, String branch) {
-        exec("git", "-C", repoRoot, "branch", "-D", branch);
-    }
-
     /**
      * A linked worktree shares its primary checkout's git config. Remove HTTPS user info before
      * adding one, so a credential accidentally embedded in that config cannot reach the member.
@@ -623,310 +553,6 @@ public final class GitWorktrees implements Worktrees {
         return true;
     }
 
-    /**
-     * fleetd #362: copy each skill folder from the configured {@link #memberSkillsSource} directory
-     * into {@code <worktreePath>/.claude/skills/}, so a member spawned against ANY repo — not only
-     * one that already ships its own {@code .claude/skills/} — can load a bridge skill such as
-     * {@code implementer}. Every brief this fleet sends starts with {@code "Load the <name>
-     * skill."}; outside a repo carrying its own copy that line was previously a no-op.
-     *
-     * <p><b>No-op — nothing read, nothing written, nothing logged</b> — when {@link
-     * #memberSkillsSource} is null/blank (today's default), the same off-switch shape as
-     * {@link #shareWithGroup}.
-     *
-     * <p><b>Invariant 1 — a repo's own skill wins.</b> A skill folder already present at
-     * {@code <worktreePath>/.claude/skills/<name>} — because the just-checked-out branch commits its
-     * own copy — is left completely untouched: never overwritten, and never even opened.
-     *
-     * <p><b>Invariant 2 — a seeded skill can never end up in a worker's commit.</b> Every path this
-     * writes is untracked in the target repo (that is the whole reason it is being seeded), so
-     * {@code git status} would otherwise show each one as a new, addable, committable path. The
-     * repo-wide {@code .git/info/exclude} is NOT used for this: measured against a real linked
-     * worktree, that file resolves to the repository's COMMON git dir even from a worktree (the
-     * same file {@link dev.ltms.fleet.member.ClaudeCodeLauncher#writeIdeOverlay writeIdeOverlay}
-     * appends {@code CLAUDE.local.md} to), so an entry written there would hide the seeded skill
-     * from {@code git status} in the PRIMARY's own checkout and every sibling worktree too — not
-     * only this one. Instead, {@link #excludeSeededSkillsFromGitStatus} points {@code
-     * core.excludesFile} at a file scoped {@code --worktree} (the same {@code
-     * extensions.worktreeConfig} mechanism {@link #configureEnvironmentCredentialHelper} already
-     * relies on) that itself lives under this worktree's own private git dir ({@code
-     * .git/worktrees/<nonce>/}, OUTSIDE the working tree) — invisible to this worktree's {@code git
-     * status} and structurally impossible for this worktree to commit, with no effect on any other
-     * worktree or the primary checkout. Proven with a real {@code git status --porcelain} in
-     * {@code GitWorktreesTest}, not by reasoning.
-     *
-     * <p><b>Compose, don't replace.</b> {@code core.excludesFile} is single-valued: the first cut of
-     * this method pointed it at fleetd's own file with {@code --replace-all}, which SHADOWS whatever
-     * the operator's own (global, or repo-local) {@code core.excludesFile} was already resolving to
-     * inside this worktree, rather than adding to it. Measured concretely: this repo's own {@code
-     * .gitignore} does not ignore {@code target/} — only an operator's global excludesFile does — so
-     * every worker's {@code mvn clean install} would otherwise make {@code target/} appear as
-     * untracked, and {@link #hasUncommitted}'s deliberately-untracked-inclusive {@code git status
-     * --porcelain} (CB-576) would then read every such worktree as dirty forever, so it is never
-     * cleaned up. {@link #excludeSeededSkillsFromGitStatus} now reads whatever {@code
-     * core.excludesFile} resolves to BEFORE writing anything (falling back to git's own documented
-     * default, {@code $XDG_CONFIG_HOME/git/ignore} or {@code $HOME/.config/git/ignore}, when the key
-     * is unset entirely — see {@code gitignore(5)}), and writes that content into its OWN exclude
-     * file ahead of the seeded skill patterns, so every operator-configured pattern keeps applying
-     * inside the seeded worktree exactly as it did before seeding ran.
-     *
-     * <p>Instead of using worktree-scoped-config as an add-then-append (a second key does not exist
-     * for {@code core.excludesFile} — it takes exactly one value), an actual second exclude source
-     * was ruled out because git resolves only ONE {@code core.excludesFile}; concatenating the prior
-     * content into fleetd's own file is what "compose" reduces to for a single-valued key.
-     *
-     * <p>Proven the same way as invariant 2's own leak check: {@code
-     * GitWorktreesTest#seedSkillsComposesWithAnAlreadyEffectiveGlobalExcludesFile} isolates a
-     * synthetic "operator's global config" via {@code GIT_CONFIG_GLOBAL} (never the real machine's),
-     * seeds a skill, and asserts {@code git status --porcelain} is still empty for a file matching
-     * that global config's own ignore pattern.
-     *
-     * <p><b>Invariant 3 — best-effort.</b> A missing/unreadable {@link #memberSkillsSource}, or a
-     * copy/exclude failure, is logged and skipped — it must never fail the spawn, the same contract
-     * {@link #overlayParity} and {@link #isolateToolSurface} already hold.
-     *
-     * <p>Recorded for the worker itself the same way fleetd #134 records {@code
-     * fleet.neutralizedConfig}: {@code fleet.seededSkills} (one value per seeded skill folder) and
-     * {@code fleet.seededSkillsNote}, readable with {@code git config --worktree --get-all
-     * fleet.seededSkills}.
-     *
-     * <p><b>Claude Code specific by construction, not by a backend check here.</b> Only {@code
-     * .claude/skills/<name>/SKILL.md} is a path any launcher reads today (opencode's equivalent is a
-     * different shape under {@code .opencode/agent}, out of scope — see issue #362). This method
-     * only copies files; like {@link #isolateToolSurface} — which neutralizes BOTH {@code .mcp.json}
-     * and {@code opencode.json} unconditionally — it runs the same for every worktree regardless of
-     * which backend ultimately spawns into it, because the backend is not yet chosen at {@link #add}
-     * time. A seeded {@code .claude/skills/} directory in an opencode member's worktree is simply
-     * never read by that launcher.
-     */
-    private void seedSkills(String worktreePath) {
-        if (memberSkillsSource == null) {
-            return;
-        }
-        Path source = Path.of(memberSkillsSource).toAbsolutePath().normalize();
-        if (!Files.isDirectory(source)) {
-            log.warn("memberSkills source '{}' is not a directory — skipping skill seeding for worktree {}",
-                    source, worktreePath);
-            return;
-        }
-        Path skillsRoot = Path.of(worktreePath).resolve(".claude").resolve("skills");
-        List<String> seeded = new ArrayList<>();
-        List<String> kept = new ArrayList<>();
-        try (var candidates = Files.list(source)) {
-            for (Path candidate : candidates
-                    .filter(Files::isDirectory)
-                    .filter(p -> !p.getFileName().toString().startsWith("."))
-                    .sorted()
-                    .toList()) {
-                String name = candidate.getFileName().toString();
-                Path dst = skillsRoot.resolve(name);
-                if (Files.exists(dst)) {
-                    kept.add(name);
-                    continue;
-                }
-                copySkillDirectory(candidate, dst);
-                seeded.add(name);
-            }
-        } catch (IOException | RuntimeException e) {
-            log.warn("failed to seed skills into worktree {} from memberSkills source '{}': {}",
-                    worktreePath, source, e.getMessage());
-            return;
-        }
-        String detail = seeded.isEmpty() ? "" : "seeded: " + String.join(", ", seeded);
-        if (!kept.isEmpty()) {
-            detail += (detail.isEmpty() ? "" : "; ") + "kept the repo's own copy of: " + String.join(", ", kept);
-        }
-        if (detail.isEmpty()) {
-            detail = "no skill folders found under " + source;
-        }
-        log.info("skill seeding: {} of {} candidate(s) from {} into {}/.claude/skills — {}",
-                seeded.size(), seeded.size() + kept.size(), source, worktreePath, detail);
-        if (seeded.isEmpty()) {
-            return;
-        }
-        try {
-            excludeSeededSkillsFromGitStatus(worktreePath, seeded);
-            recordSeededSkillsForWorker(worktreePath, seeded);
-        } catch (RuntimeException e) {
-            log.warn("seeded skill(s) {} into {} but could not hide them from git status: {} — "
-                    + "they may show as untracked; never commit them", seeded, worktreePath, e.getMessage());
-        }
-    }
-
-    /** Recursively copy a skill folder ({@code src}) into a fresh destination ({@code dst}) that
-     *  {@link #seedSkills} has already confirmed does not exist, preserving the directory structure
-     *  (e.g. {@code implementer/SKILL.md}, {@code implementer/references/...}). */
-    private static void copySkillDirectory(Path src, Path dst) {
-        try (var walk = Files.walk(src)) {
-            for (Path path : walk.sorted().toList()) {
-                Path target = dst.resolve(src.relativize(path).toString());
-                if (Files.isDirectory(path)) {
-                    Files.createDirectories(target);
-                } else {
-                    Files.createDirectories(target.getParent());
-                    Files.copy(path, target, StandardCopyOption.COPY_ATTRIBUTES);
-                }
-            }
-        } catch (IOException e) {
-            throw new WorktreeException("cannot copy skill directory " + src + " -> " + dst + ": "
-                    + e.getMessage(), e);
-        }
-    }
-
-    /**
-     * Make every path in {@code seededSkillNames} (each a name under {@code .claude/skills/})
-     * invisible to {@code git status} in THIS worktree only — see the invariant-2 discussion on
-     * {@link #seedSkills}. Sets {@code core.excludesFile} scoped {@code --worktree} to a file
-     * written under this worktree's own private git dir ({@code git rev-parse
-     * --absolute-git-dir}), which lives outside the working tree, so the exclude file itself can
-     * never be committed either.
-     *
-     * <p><b>Compose, don't replace.</b> {@code core.excludesFile} is single-valued, so pointing it at
-     * fleetd's own file would otherwise SHADOW whatever excludesFile this worktree was already
-     * resolving (an operator's global config, most commonly) rather than add to it — see the
-     * "Compose, don't replace" discussion on {@link #seedSkills}. {@link
-     * #previouslyEffectiveExcludesFileContent} is read BEFORE this method's own {@code --worktree}
-     * write below, so it still sees whatever was effective beforehand; that content is written into
-     * fleetd's own exclude file ahead of the seeded skill patterns, and the worktree-scoped override
-     * then points at that combined file — so every pattern the operator's own configuration already
-     * applied keeps applying, plus the seeded skill paths.
-     *
-     * <p><b>Assumes a fresh worktree — not idempotent.</b> {@link #seedSkills} only ever calls this
-     * from {@link #add}, which always creates a brand-new worktree, so {@code core.excludesFile} is
-     * never already worktree-scoped-set to fleetd's own file when this runs. A hypothetical second
-     * call on the SAME worktree would read fleetd's own already-composed file back as "previously
-     * effective" (worktree scope now wins) and append the seeded patterns a second time — harmless
-     * to {@code git status} (duplicate exclude lines are a no-op), but not something to rely on. No
-     * guard is added for this because the path does not exist today; if a future caller ever seeds
-     * the same worktree twice, it will need one.
-     */
-    private void excludeSeededSkillsFromGitStatus(String worktreePath, List<String> seededSkillNames) {
-        exec("git", "-C", worktreePath, "config", "extensions.worktreeConfig", "true");
-        String previouslyEffective = previouslyEffectiveExcludesFileContent(worktreePath);
-        String gitDir = exec("git", "-C", worktreePath, "rev-parse", "--absolute-git-dir").trim();
-        Path excludeFile = Path.of(gitDir, "fleet-seeded-skills-exclude");
-        StringBuilder patterns = new StringBuilder();
-        if (!previouslyEffective.isEmpty()) {
-            patterns.append(previouslyEffective);
-        }
-        for (String name : seededSkillNames) {
-            patterns.append("/.claude/skills/").append(name).append('/').append(System.lineSeparator());
-        }
-        try {
-            Files.writeString(excludeFile, patterns.toString());
-        } catch (IOException e) {
-            throw new WorktreeException("cannot write skills exclude file " + excludeFile + ": "
-                    + e.getMessage(), e);
-        }
-        exec("git", "-C", worktreePath, "config", "--worktree", "--replace-all", "core.excludesFile",
-                excludeFile.toString());
-    }
-
-    /**
-     * The content of whatever {@code core.excludesFile} resolves to for {@code worktreePath} right
-     * now — BEFORE {@link #excludeSeededSkillsFromGitStatus} points that key at fleetd's own file —
-     * so it can be carried forward instead of shadowed. {@code --type=path} makes git itself perform
-     * {@code ~}/{@code ~user} expansion the same way it would when actually reading the key to build
-     * exclude rules, rather than handing back a raw, unexpanded config string.
-     *
-     * <p>When the key is unset entirely (exit code non-zero), falls back to git's own documented
-     * default excludes file — {@code $XDG_CONFIG_HOME/git/ignore}, or {@code
-     * $HOME/.config/git/ignore} when that variable is unset — per {@code gitignore(5)}: git applies
-     * that file even with no {@code core.excludesFile} configured at all, so skipping it here would
-     * silently drop patterns an operator never had to configure to get.
-     *
-     * <p>Never throws: a missing, unreadable, or unresolvable file is treated as "nothing to carry
-     * forward" (empty string) — this is a best-effort read in service of {@link #seedSkills}'s own
-     * invariant 3, not a new way for skill seeding to fail a spawn.
-     *
-     * <p><b>Review fix, finding 2.</b> The XDG-fallback branch below does not go through {@code git}
-     * at all, so a first cut of it read {@code XDG_CONFIG_HOME}/{@code HOME} straight from the JVM's
-     * own environment ({@link System#getenv} / {@code user.home}) — unlike every other value this
-     * class resolves, which goes through a {@code git} subprocess and therefore already honours
-     * {@link #gitEnv}. That meant no test could make this branch hermetic, and on any machine
-     * carrying a real {@code ~/.config/git/ignore} (this repo's own dev machine does), every
-     * skill-seeding test silently composed with that real file — correct in production, but
-     * machine-dependent in the test suite, and a future broader pattern in that real file could
-     * silently change what a seeded worktree's {@code git status} reports depending on whose home
-     * directory ran the test. {@link #resolveEnv} now checks {@link #gitEnv} first for both
-     * variables, falling back to the JVM's real environment only when the seam does not supply
-     * them — production behaviour (empty {@link #gitEnv}) is unchanged, and a test can now isolate
-     * this branch exactly as it already isolates every {@code git} subprocess call.
-     *
-     * <p><b>Snapshot, not a reference.</b> The content below is read once, at seeding time, and
-     * copied into fleetd's own exclude file. If the operator edits their global excludesFile
-     * afterward, an already-seeded worktree keeps the old copy — acceptable for a worktree's
-     * expected lifetime, but worth knowing before reading a stale pattern as a bug.
-     *
-     * @return the file's content, trailing-newline-normalized, or {@code ""} when there is nothing
-     *         to compose with.
-     */
-    private String previouslyEffectiveExcludesFileContent(String worktreePath) {
-        String resolvedPath;
-        if (exitCode("git", "-C", worktreePath, "config", "--get", "--type=path", "core.excludesFile") == 0) {
-            resolvedPath = exec("git", "-C", worktreePath, "config", "--get", "--type=path",
-                    "core.excludesFile").trim();
-        } else {
-            String xdgConfigHome = resolveEnv("XDG_CONFIG_HOME");
-            Path fallback = (xdgConfigHome != null && !xdgConfigHome.isBlank())
-                    ? Path.of(xdgConfigHome, "git", "ignore")
-                    : Path.of(resolveHome(), ".config", "git", "ignore");
-            resolvedPath = fallback.toString();
-        }
-        if (resolvedPath.isBlank()) {
-            return "";
-        }
-        Path file = Path.of(resolvedPath);
-        if (!Files.isRegularFile(file) || !Files.isReadable(file)) {
-            return "";
-        }
-        try {
-            String content = Files.readString(file);
-            return content.isBlank() ? "" : content.stripTrailing() + System.lineSeparator();
-        } catch (IOException e) {
-            log.warn("could not read previously-effective excludesFile {} while seeding skills into "
-                    + "{}: {} — its patterns will not carry forward into the seeded worktree",
-                    file, worktreePath, e.getMessage());
-            return "";
-        }
-    }
-
-    /**
-     * Resolve environment variable {@code name} for {@link #previouslyEffectiveExcludesFileContent}'s
-     * XDG fallback, checking {@link #gitEnv} FIRST so a test can isolate this the same way it
-     * already isolates every {@code git} subprocess this class runs, and falling back to the JVM's
-     * real environment only when the seam does not supply it (always the case in production, where
-     * {@link #gitEnv} is {@code Map.of()}).
-     */
-    private String resolveEnv(String name) {
-        String fromSeam = gitEnv.get(name);
-        return fromSeam != null ? fromSeam : System.getenv(name);
-    }
-
-    /** Same as {@link #resolveEnv(String)}, for {@code HOME} — falls back to {@code user.home}
-     *  (rather than {@code System.getenv("HOME")}) when the seam does not supply it, matching this
-     *  class's pre-existing behaviour for every other home-directory resolution. */
-    private String resolveHome() {
-        String fromSeam = gitEnv.get("HOME");
-        return fromSeam != null ? fromSeam : System.getProperty("user.home");
-    }
-
-    /**
-     * The worker-readable half of fleetd #362, mirroring {@link #recordNeutralizedConfigForWorker}:
-     * record which skill folders were seeded where the worker itself can read it, without a
-     * working-tree file that would show up in {@code git status}.
-     */
-    private void recordSeededSkillsForWorker(String worktreePath, List<String> seeded) {
-        exec("git", "-C", worktreePath, "config", "extensions.worktreeConfig", "true");
-        for (String name : seeded) {
-            exec("git", "-C", worktreePath, "config", "--worktree", "--add", "fleet.seededSkills", name);
-        }
-        exec("git", "-C", worktreePath, "config", "--worktree", "fleet.seededSkillsNote",
-                "each fleet.seededSkills value names a skill folder fleetd copied into "
-                        + ".claude/skills/ because this repo did not already ship it; it is excluded "
-                        + "from git status (core.excludesFile, worktree-scoped) and must never be committed");
-    }
-
     @Override
     public void remove(String repoRoot, String worktreePath) {
         Path p = Path.of(worktreePath);
@@ -1437,9 +1063,6 @@ public final class GitWorktrees implements Worktrees {
         Process p;
         try {
             ProcessBuilder pb = new ProcessBuilder(command).redirectErrorStream(true);
-            if (!gitEnv.isEmpty()) {
-                pb.environment().putAll(gitEnv);
-            }
             if (extraEnv != null && !extraEnv.isEmpty()) {
                 pb.environment().putAll(extraEnv);
             }
@@ -1475,11 +1098,7 @@ public final class GitWorktrees implements Worktrees {
     private int exitCode(String... command) {
         Process p;
         try {
-            ProcessBuilder pb = new ProcessBuilder(command).redirectErrorStream(true);
-            if (!gitEnv.isEmpty()) {
-                pb.environment().putAll(gitEnv);
-            }
-            p = pb.start();
+            p = new ProcessBuilder(command).redirectErrorStream(true).start();
         } catch (IOException e) {
             throw new WorktreeException("failed to start " + command[0] + ": " + e.getMessage(), e);
         }

fleetd/src/main/java/dev/ltms/fleet/session/SessionManager.java

@@ -10,7 +10,6 @@ import dev.ltms.fleet.peer.MemberRole;
 import dev.ltms.fleet.peer.PeerHandle;
 import dev.ltms.fleet.peer.PeerLauncher;
 import dev.ltms.fleet.peer.SpawnRequest;
-import dev.ltms.fleet.placement.PlacementDecision;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -22,7 +21,6 @@ import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Consumer;
 import java.util.function.LongSupplier;
@@ -63,8 +61,6 @@ public final class SessionManager implements TurnListener {
     private final LongSupplier nowNanos;
     private final int contextCap;
     private final boolean clearAfterTurn;
-    /** Null in production; test seam for the interval before an idle session's conditional release. */
-    private final Consumer<MemberSession> beforeIdleRelease;
     private volatile MemberLifecycle memberLifecycle = MemberLifecycle.NONE;
     /**
      * CB-586: the repo root the fleet actually works in, remembered the first time a worktree
@@ -75,16 +71,6 @@ public final class SessionManager implements TurnListener {
      */
     private volatile String fleetRepoRoot;
 
-    /**
-     * fleetd #308: flips true the instant {@link #drainAll} starts, before its registry snapshot
-     * is even taken — so a spawn already in flight sees the refusal as early as a plain flag can
-     * make it. This alone cannot close the race completely: a caller that read {@code false} just
-     * before the flip can still land in the registry after the snapshot. {@link #drainAll}'s
-     * post-loop sweep is what catches that straggler; the two mechanisms are deliberately paired,
-     * see {@link #drainAll}'s javadoc.
-     */
-    private final AtomicBoolean draining = new AtomicBoolean(false);
-
     /** CB-520: notified with a terminalId on every acquire; no-op until wired. */
     private final List<Consumer<String>> acquireListeners = new java.util.concurrent.CopyOnWriteArrayList<>();
     /** CB-516: notified with a {@link ReleaseDetail} on every release; no-op until wired. */
@@ -116,23 +102,13 @@ public final class SessionManager implements TurnListener {
     }
 
     public SessionManager(PeerLauncher launcher, Worktrees worktrees, LongSupplier nowNanos,
-                           int contextCap, boolean clearAfterTurn) {
-        this(launcher, worktrees, nowNanos, contextCap, clearAfterTurn, null);
-    }
-
-    /**
-     * Package-private constructor for a deterministic reap/delivery race test. Production callers
-     * use the constructor above, whose null hook adds no callback or lock to an ordinary reap.
-     */
-    SessionManager(PeerLauncher launcher, Worktrees worktrees, LongSupplier nowNanos,
-                   int contextCap, boolean clearAfterTurn, Consumer<MemberSession> beforeIdleRelease) {
+                          int contextCap, boolean clearAfterTurn) {
         this.launcher = launcher;
         this.worktrees = worktrees;
         this.presence = new PresenceFleet(this);
         this.nowNanos = nowNanos;
         this.contextCap = contextCap;
         this.clearAfterTurn = clearAfterTurn;
-        this.beforeIdleRelease = beforeIdleRelease;
     }
 
     /**
@@ -205,14 +181,6 @@ public final class SessionManager implements TurnListener {
     public MemberSession acquire(String profile, MemberRole role, String requestedCwd, String callerCwd,
                                  String ownerTerminal, WorktreeRequest wt,
                                  String sessionName, String resumeSessionId) {
-        // fleetd #308: refuse before anything else runs — no slot reservation, no launcher spawn —
-        // so a caller learns the daemon is going down instead of getting a session drainAll will
-        // never see again. Checked here because every other acquire(...) overload delegates to
-        // this one, so this is the single point every spawn path passes through.
-        if (draining.get()) {
-            throw new ShuttingDownException("fleetd is shutting down; refusing to spawn a session "
-                    + "the shutdown drain would never see");
-        }
         MemberRole memberRole = (role == null) ? MemberRole.DEV : role;
         requireResumeCapability(profile, resumeSessionId);
         // CB-619 / fleetd #123: an explicit profile bypasses placement (CompositePeerLauncher only
@@ -304,32 +272,10 @@ public final class SessionManager implements TurnListener {
      */
     private void release(String paneId, ReleaseCause cause) {
         MemberSession removed = registry.remove(paneId);
-        releaseRemoved(paneId, removed, handles.remove(paneId), cause);
-    }
-
-    /**
-     * Tear a session down only while {@code expected} is still its registry value. A lifecycle
-     * transition replaces the immutable record, so this prevents a reap based on an old READY or
-     * DONE record from stopping a worker that delivery has made BUSY.
-     */
-    private boolean releaseIfCurrent(MemberSession expected, ReleaseCause cause) {
-        if (!registry.remove(expected.paneId(), expected)) {
-            // A lifecycle transition replaced the record between the caller's check and this remove.
-            // Log it: this race is by definition unobservable otherwise, and a reaper that silently
-            // declines to reap is the hardest kind of behaviour to diagnose after the fact.
-            log.debug("skipping reap of pane={}: its registry record changed after the idle check "
-                    + "(most likely a delivery made it BUSY)", expected.paneId());
-            return false;
-        }
-        releaseRemoved(expected.paneId(), expected, handles.remove(expected.paneId()), cause);
-        return true;
-    }
-
-    private void releaseRemoved(String paneId, MemberSession removed, PeerHandle removedHandle,
-                                ReleaseCause cause) {
         // fleetd #209: remove right alongside the registry entry so a released session's handle is
         // never leaked — but keep the local reference below, so the id can still be resolved for
         // the ReleaseDetail this teardown notifies with.
+        PeerHandle removedHandle = handles.remove(paneId);
         boolean preserveWorktree = cause == ReleaseCause.SHUTDOWN;
         String snapshotRef = null;
         if (removed != null) {
@@ -388,63 +334,7 @@ public final class SessionManager implements TurnListener {
         // slot that no longer appears in the roster and can never be reclaimed.
         launcher.stop(paneId);
         if (removed != null && !preserveWorktree && removed.worktree() != null) {
-            // fleetd #316: the `dirty` read above ran while the worker could still write to this
-            // worktree, so a stale `false` must not be trusted to authorise the --force removal
-            // below. Re-read the worktree's state one more time, right here — immediately before
-            // the one step that would destroy it, and only on the path that is actually about to
-            // do that (invariant 4: no second unconditional `git status` on a release that already
-            // decided to preserve). By now `launcher.stop` has returned, so this read reflects
-            // whatever the worker managed to write up to and including its teardown, not whatever
-            // it had written at release-start time.
-            if (dirtyImmediatelyBeforeRemoval(removed)) {
-                preserveWorktree = true;
-                // The pre-stop snapshot above never ran for this session (the pre-stop read said
-                // clean), so this is the only chance to get the newly-discovered work into
-                // refs/wip/* rather than leaving the on-disk preserve as the sole copy. Best-effort,
-                // like every other snapshot attempt — trySnapshot logs and swallows its own failure.
-                String lateSnapshotRef = trySnapshot(removed, cause);
-                log.warn("release {} preserves worktree {} for pane={} terminal={}: it reported "
-                        + "clean before the pane stopped but dirty immediately before removal — the "
-                        + "worker wrote to it during teardown, and --force removing it now would "
-                        + "have destroyed that work{}",
-                        cause, removed.worktree(), paneId, removed.terminalId(),
-                        lateSnapshotRef == null ? "" : " (snapshotted to refs/wip/" + removed.branch()
-                                + " commit=" + lateSnapshotRef + ")");
-            }
-        }
-        if (removed != null && !preserveWorktree && removed.worktree() != null) {
-            // fleetd #283: this is the one cleanup step in this method that used to be bare. By the
-            // time it runs, the registry entry, the retained handle, and the pane are all already
-            // gone — so a throw here (a stale index lock, a slow filesystem, `remove`'s own 30s exec
-            // timeout) must not escape release(): there is no retry path (a second stop on this
-            // paneId is a no-op), and the caller would otherwise see a "failed stop" for a session
-            // that is in fact fully torn down. Log and swallow, matching every sibling step above.
-            try {
-                worktrees.remove(worktrees.repoRoot(removed.cwd()), removed.worktree());
-            } catch (RuntimeException e) {
-                log.warn("failed to remove worktree {} for pane={} terminal={} after release: the "
-                        + "pane is already stopped and the session already deregistered, so this is "
-                        + "not retryable — the directory must be reclaimed manually: {}",
-                        removed.worktree(), paneId, removed.terminalId(), e.toString());
-            }
-        }
-    }
-
-    /**
-     * fleetd #316: the read that actually authorises {@code worktrees.remove}, taken with the
-     * worker's pane already stopped. Fails toward preserving (returns {@code true}) on any
-     * exception — the same rule the pre-stop check applies (CB-581): once we can no longer tell
-     * whether the worktree is dirty, preserving costs disk while deleting on a guess can destroy
-     * work that has no other copy.
-     */
-    private boolean dirtyImmediatelyBeforeRemoval(MemberSession removed) {
-        try {
-            return worktrees.hasUncommitted(removed.worktree());
-        } catch (RuntimeException e) {
-            log.warn("release could not re-check worktree {} for pane={} terminal={} immediately "
-                    + "before removal; preserving it rather than risk destroying unsaved work: {}",
-                    removed.worktree(), removed.paneId(), removed.terminalId(), e.toString());
-            return true;
+            worktrees.remove(worktrees.repoRoot(removed.cwd()), removed.worktree());
         }
     }
 
@@ -585,65 +475,8 @@ public final class SessionManager implements TurnListener {
                                               String ownerTerminal, WorktreeRequest wt,
                                                String sessionName, String resumeSessionId,
                                                MemberLifecycle.SlotReservation reservation) {
-        // fleetd #425 rework (round 2): resolved through launcher.place(memberRole) — the same
-        // candidate list, quarantine/cool-off/model-off filtering, and PlacementPolicy an unqualified
-        // spawn of this role is actually judged against right now — never launcher.defaultProfile()
-        // (MemberRole.DEV only, wrong for any other role) and never launcher.defaultProfileFor()
-        // (the role's pool FIRST entry, blind to quarantine/cool-off/model-off: a first-round fix
-        // used exactly this and regressed fleetd #429's "the fleet keeps working when a model is
-        // turned off" guarantee — a quarantined or model-off pool-first profile made this throw
-        // instead of routing around it, which an unqualified spawn is supposed to do). This same
-        // resolved decision is reused below for repoRoot, parityOverlay, AND the spawn itself so the
-        // worktree is always provisioned for the profile the member actually runs on — the two could
-        // disagree before fleetd #425: this name picked repoRoot/overlay, but the spawn below passed
-        // the ORIGINAL (blank) profile through to placement, which re-resolves live and can pick a
-        // different profile if the pool changed between the two reads, or a genuinely different one
-        // under weighted/round-robin placement.
-        //
-        // Round 1 of this rework fed the resolved name back into launcher.spawn(SpawnRequest) as an
-        // EXPLICIT profile. That was a mistake this round corrects, and the mistake is not that the
-        // two branches apply different checks — they are SUPPOSED to disagree: the routing branch a
-        // blank spawn takes treats a quarantined/cooling-off/at-cap/model-off/unreachable/weight-0
-        // profile as a reason to fall through to the next candidate, while CompositePeerLauncher's
-        // THROWING branch (enforceNotQuarantined/enforceNotCoolingOff/enforceMaxLoad/
-        // enforceModelEnabled) treats naming that same profile explicitly as a reason to refuse
-        // outright. That is correct: an operator who names a profile should get a refusal, not a
-        // silent substitution onto a different backend. The mistake was turning a fall-through into
-        // a refusal by accident — resolving a name via the routing side and then re-entering the
-        // refusing side with it, for a placement the routing side had already approved by walking
-        // past everything else.
-        //
-        // Before fleetd #435, this accident was reachable through maxLoad specifically: the default
-        // `fixed` placement policy did not evaluate maxLoad at all for automatic selection, so an
-        // at-cap pool-first profile that placement itself would have picked for a plain unqualified
-        // spawn could die at enforceMaxLoad one call later, purely because this method's route to
-        // the spawn passed through an explicit profile name — a failure a worktree-less unqualified
-        // spawn never hit. fleetd #435 closed that gap (`fixed` now evaluates maxLoad exactly like
-        // every other placement policy), so that specific failure can no longer happen — a
-        // PlacementDecision this method resolves can no longer be at-cap in the first place. What
-        // this round's fix still buys, now that maxLoad can no longer cause the accident: it keeps
-        // the PlacementDecision from place() and hands it to launcher.spawn(SpawnRequest,
-        // PlacementDecision) for an unqualified request, which spawns through the SAME routing
-        // branch a blank spawn uses — no enforce* check is newly applied, and the window between the
-        // placement decision and the spawn (in which the pool, a config reload, or another spawn
-        // landing on the same profile could otherwise move the state) never reopens. An
-        // explicitly-named profile still goes through launcher.spawn(SpawnRequest) and its throwing
-        // branch, unchanged — that caller asked for one profile by name and still gets everything
-        // enforceNotQuarantined/enforceNotCoolingOff/enforceMaxLoad/enforceModelEnabled decide about
-        // it, refusal included.
-        //
-        // The one cost that remains, unchanged from round 1: an unqualified worktree-provisioned
-        // spawn does not get CompositePeerLauncher's cross-candidate retry on a live
-        // PeerUnreachableException raised by the backend itself at spawn time (a transport-level
-        // failure placement cannot see in advance) — spawn(req, decision) commits to the one profile
-        // place() already chose, the same way an explicit-profile spawn commits to its one name. That
-        // trade is deliberate: a worktree provisioned for the wrong backend (the #425 hazard) is worse
-        // than a spawn that fails cleanly and can be retried by the caller. Nothing else is lost:
-        // maxLoad, quarantine, cool-off and model-off all behave identically whether or not a
-        // worktree was requested — that agreement is the invariant this rework exists to hold.
-        boolean unqualifiedProfile = profile == null || profile.isBlank();
-        PlacementDecision decision = unqualifiedProfile ? launcher.place(memberRole) : new PlacementDecision(profile);
-        String preResolvedProfile = decision.profile();
+        String preResolvedProfile = (profile == null || profile.isBlank())
+                ? launcher.defaultProfile() : profile;
         // CB-507: resolve through the launcher's CB-112 chain (requested → profile cwd → caller →
         // daemon cwd → "."), never the raw args. A plain REST spawn supplies neither a requested
         // nor a caller cwd, so taking the first non-blank of those two yielded null and put
@@ -666,43 +499,20 @@ public final class SessionManager implements TurnListener {
             // copies more files into the worktree after add() returns, so sharing the group any earlier
             // leaves those overlay files operator-owned and read-only for a different-uid member.
             worktrees.shareWithGroup(repoRoot, path);
-            // fleetd #425: preResolvedProfile, not the original (possibly blank) profile — see the
-            // comment above where it is resolved. The overlay/repoRoot above and the spawn here must
-            // name the same profile. An unqualified request stays unqualified here and is honored via
-            // the PlacementDecision already captured above (spawn(req, decision) — the routing branch,
-            // no enforce* re-check); an explicitly-named profile still goes through the single-arg
-            // spawn(req) and its throwing branch, exactly as before this rework.
-            SpawnRequest spawnReq = new SpawnRequest(unqualifiedProfile ? null : preResolvedProfile,
-                    path, callerCwd, sessionName, resumeSessionId, memberRole);
-            handle = unqualifiedProfile ? launcher.spawn(spawnReq, decision) : launcher.spawn(spawnReq);
+            handle = launcher.spawn(new SpawnRequest(profile, path, callerCwd, sessionName, resumeSessionId, memberRole));
         } catch (RuntimeException e) {
             log.warn("spawn failed for profile={} role={} branch={} path={}: {}",
                     preResolvedProfile, memberRole, branch, path, e.getMessage());
             if (path != null) {
-                // fleetd #283: this catch covers every failure AFTER worktrees.add() returned —
-                // overlayParity, shareWithGroup, launcher.spawn itself — so by this point `branch`
-                // was actually created in git. #274 fixed the sibling failure INSIDE add() by having
-                // GitWorktrees.cleanupAfterAddFailure delete both the worktree and the branch it
-                // provisioned; this path removed only the worktree and left the branch orphaned. A
-                // spawn failure here is routine (a quarantined credential, a backend refusal), so
-                // every occurrence leaked a `worker/<slug>-<nonce>` branch nothing ever pointed at
-                // again. Reuse the same Worktrees.deleteBranch GitWorktrees already has, rather than
-                // a second copy of the git command. Best-effort and log-only, like the worktree
-                // removal right above it — neither cleanup step may mask the original exception.
                 try {
                     worktrees.remove(repoRoot, path);
                 } catch (RuntimeException cleanup) {
                     log.warn("failed to clean up worktree {} after spawn error: {}", path, cleanup.getMessage());
                 }
-                try {
-                    worktrees.deleteBranch(repoRoot, branch);
-                } catch (RuntimeException cleanup) {
-                    log.warn("failed to clean up branch {} after spawn error: {}", branch, cleanup.getMessage());
-                }
             }
             throw e;
         }
-        String resolvedProfile = resolveProfile(handle, preResolvedProfile);
+        String resolvedProfile = resolveProfile(handle, profile);
         String cwd = launcher.effectiveCwd(new SpawnRequest(resolvedProfile, path, callerCwd));
         long now = nowNanos.getAsLong();
         // CB-619: see the no-worktree path above — bind before recording, and store the returned
@@ -1008,18 +818,14 @@ public final class SessionManager implements TurnListener {
             }
             long idleNanos = now - s.lastActivityAtNanos();
             if (idleNanos > idleTtlNanos) {
+                log.debug("reaping idle session terminal={} pane={}: idle {}s exceeds the {}s ttl",
+                        s.terminalId(), s.paneId(), TimeUnit.NANOSECONDS.toSeconds(idleNanos),
+                        TimeUnit.NANOSECONDS.toSeconds(idleTtlNanos));
                 // CB-581: one session that fails to release must not abort the whole reaping pass —
                 // match drainAll's per-session try/catch so the rest of the roster still gets reaped.
                 try {
-                    if (beforeIdleRelease != null) {
-                        beforeIdleRelease.accept(s);
-                    }
-                    if (releaseIfCurrent(s, ReleaseCause.COMPLETED)) {
-                        log.debug("reaping idle session terminal={} pane={}: idle {}s exceeds the {}s ttl",
-                                s.terminalId(), s.paneId(), TimeUnit.NANOSECONDS.toSeconds(idleNanos),
-                                TimeUnit.NANOSECONDS.toSeconds(idleTtlNanos));
-                        reaped++;
-                    }
+                    release(s.paneId());
+                    reaped++;
                 } catch (RuntimeException e) {
                     log.warn("reap failed for pane={} terminal={} worktree={}; continuing with "
                             + "remaining sessions", s.paneId(), s.terminalId(), s.worktree(), e);
@@ -1030,60 +836,20 @@ public final class SessionManager implements TurnListener {
     }
 
     /**
-     * Gracefully drain all registered sessions on daemon shutdown. Non-busy sessions are released
-     * immediately; a {@code BUSY} one is polled until it leaves {@code BUSY}, then released
-     * regardless. A failure releasing one session is logged and does not abort the rest.
-     *
-     * <p>{@code timeoutNanos} is a budget for the WHOLE drain, not a grace period per session: the
-     * deadline is taken once, before the loop. So the first BUSY session can spend all of it, and a
-     * later BUSY one is then released with no wait at all. That is deliberate. This drain is only
-     * one phase of shutdown — {@code Fleetd} closes the message service, the push loop, the
-     * heartbeat, MCP and the router after it — and the whole sequence has to finish inside
-     * launchd's exit window. A per-session grace would let N busy members drain for N * the
-     * timeout, overrun that window, and get the daemon SIGKILLed part-way through; the members not
-     * yet reached would then get no clean release, no preserved-worktree log, and no snapshot.
-     * Cutting one turn short is the cheaper failure, and it is not silent: an abandoned BUSY
-     * session is preserved, snapshotted, and logged at WARN by {@code logPreservedForShutdown}.
+     * Gracefully drain all registered sessions on daemon shutdown. For each session that is
+     * {@code BUSY}, poll up to {@code timeoutNanos} for it to leave {@code BUSY}, then release it
+     * regardless. Non-busy sessions are released immediately. A failure releasing one session is
+     * logged and does not abort the rest.
      *
      * <p>CB-544: this is a {@link ReleaseCause#SHUTDOWN} release — the worker's pane is stopped
      * (the process must end) but its worktree is preserved and its path logged. Shutdown is never
      * a reason to delete a worker's only copy of its uncommitted work. A session still {@code BUSY}
      * when the timeout expired is abandoned mid-turn and logged loudly so an operator can find its
      * kept worktree.
-     *
-     * <p>fleetd #308: {@code roster()} is a one-shot snapshot (see its javadoc), and nothing used
-     * to stop a new session from registering after it was taken — {@link #acquire} stayed open for
-     * as long as this drain waited on a {@code BUSY} session, up to the whole {@code timeoutNanos}
-     * budget. Two things close that window, deliberately paired because neither alone is complete:
-     * {@link #draining} is flipped true before the snapshot is even taken, so {@link #acquire}
-     * refuses (invariant 3: loudly, via {@link ShuttingDownException}) as much of the window as a
-     * plain flag can close; and the sweep below re-reads the registry once the initial snapshot has
-     * fully drained and drains whatever a straggler — a caller that read the flag as {@code false}
-     * a moment before it flipped — still managed to register. The sweep shares the same
-     * {@code deadline} rather than getting its own: {@code timeoutNanos} is a budget for the WHOLE
-     * drain (see above), and a straggler must not buy the drain more time than the flag it lost the
-     * race against would have. In the ordinary case the sweep finds nothing and costs one empty
-     * {@link #roster()} call.
      */
     void drainAll(long timeoutNanos) {
         long deadline = System.nanoTime() + timeoutNanos;
-        draining.set(true);
-        drainSnapshot(roster(), deadline);
-        List<MemberSession> stragglers = roster();
-        if (!stragglers.isEmpty()) {
-            log.warn("drain sweep found {} session(s) registered after the drain snapshot was "
-                    + "taken (raced past the shutdown guard); draining them too", stragglers.size());
-            drainSnapshot(stragglers, deadline);
-        }
-    }
-
-    /**
-     * Drain exactly the sessions in {@code snapshot}, waiting out a {@code BUSY} one against the
-     * shared whole-drain {@code deadline} before releasing it. Shared by {@link #drainAll}'s main
-     * pass and its post-loop straggler sweep (fleetd #308) so both honor the same one budget.
-     */
-    private void drainSnapshot(List<MemberSession> snapshot, long deadline) {
-        for (MemberSession s : snapshot) {
+        for (MemberSession s : roster()) {
             try {
                 if (s.state() == MemberSession.State.BUSY) {
                     while (System.nanoTime() < deadline) {

fleetd/src/main/java/dev/ltms/fleet/session/ShuttingDownException.java

@@ -1,18 +0,0 @@
-package dev.ltms.fleet.session;
-
-/**
- * Thrown by {@link SessionManager#acquire} when a spawn is requested after the daemon's shutdown
- * drain has already begun (fleetd #308).
- *
- * <p>{@link SessionManager#drainAll} snapshots the registry once and tears down exactly what is
- * in that snapshot. A session registered after the snapshot is invisible to the drain loop: its
- * pane is left running and its worktree is never preserved, and nothing else ever reclaims
- * either — the daemon's in-memory registry dies with the process. Refusing the spawn here,
- * loudly, is what stops that session from ever being created in the first place, rather than
- * silently handing the caller a session the daemon can no longer manage.
- */
-public final class ShuttingDownException extends RuntimeException {
-    public ShuttingDownException(String message) {
-        super(message);
-    }
-}

fleetd/src/main/java/dev/ltms/fleet/session/Worktrees.java

@@ -11,15 +11,6 @@ public interface Worktrees {
     /** git -C <repoRoot> worktree remove --force <path>. Idempotent (already-gone tolerated). */
     void remove(String repoRoot, String worktreePath);
 
-    /**
-     * git -C {@code repoRoot} branch -D {@code branch}. Force-deletes a branch that has no other
-     * owner — used only on the failed-provisioning path (fleetd #274, #283), never on a normal
-     * release: {@link SessionManager#release} deliberately leaves a released session's branch
-     * behind so a lead can still recover the work, and this method must never be called from
-     * that path.
-     */
-    void deleteBranch(String repoRoot, String branch);
-
     /**
      * True when the worktree holds uncommitted changes the bridge cannot see: tracked
      * modifications, staged files, or untracked files. {@code git status --porcelain} is the

fleetd/src/test/java/dev/ltms/fleet/ExhaustedPatternGapReportTest.java

@@ -1,150 +0,0 @@
-package dev.ltms.fleet;
-
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.Logger;
-import ch.qos.logback.classic.spi.ILoggingEvent;
-import ch.qos.logback.core.read.ListAppender;
-import dev.ltms.fleet.config.FleetConfig;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import org.slf4j.LoggerFactory;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #395: {@code exhaustedPattern} (see {@link FleetConfig.Profile#exhaustedPattern}) is
- * deliberately opt-in — an unset one leaves usage-limit detection silently OFF for that profile,
- * and nothing quarantines its credential. {@link Fleetd#reportExhaustedPatternGap} must say so at
- * startup, naming every unarmed profile, and must never fire when every profile is armed. Mirrors
- * {@link MemberCredentialsGapReportTest}'s pattern, capturing the real log via a
- * {@link ListAppender}.
- *
- * <p>The 8-profile shape in {@link #theLiveEightProfileShapeWarnsExactlyTheSixUnarmedProfiles} is
- * the live {@code fleetd.yaml} shape measured 2026-09-10 (fleetd #395's own ticket): 6 of 8
- * profiles unarmed, 2 of those 6 ({@code opus}, {@code sonnet}) running on the operator's Claude
- * subscription. {@code fleetd.yaml} itself is gitignored and unavailable to this test, so the
- * shape is reproduced as a throwaway config in a {@code @TempDir} rather than read off disk.
- */
-class ExhaustedPatternGapReportTest {
-
-    private static FleetConfig load(Path dir, String yaml) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml);
-        return FleetConfig.load(f);
-    }
-
-    private static ListAppender<ILoggingEvent> attach() {
-        Logger logger = (Logger) LoggerFactory.getLogger(Fleetd.class);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        return appender;
-    }
-
-    private static void detach(ListAppender<ILoggingEvent> appender) {
-        ((Logger) LoggerFactory.getLogger(Fleetd.class)).detachAppender(appender);
-    }
-
-    /** Every profile name mentioned by a WARN-level log line, across every WARN this call produced. */
-    private static List<String> warnMessages(ListAppender<ILoggingEvent> appender) {
-        return appender.list.stream()
-                .filter(e -> e.getLevel() == Level.WARN)
-                .map(ILoggingEvent::getFormattedMessage)
-                .toList();
-    }
-
-    @Test
-    void theLiveEightProfileShapeWarnsExactlyTheSixUnarmedProfiles(@TempDir Path dir) throws Exception {
-        // Reproduces the live shape measured 2026-09-10: 8 profiles, 2 armed (sol, terra), 6
-        // unarmed (local, local-direct, gx, opus, sonnet, xf) — 2 of the unarmed 6 (opus, sonnet)
-        // are subscription: true.
-        FleetConfig cfg = load(dir, """
-                profiles:
-                  local:
-                    baseUrl: http://gx00.gw:8000
-                  local-direct:
-                    baseUrl: http://gx01.gw:8000
-                  gx:
-                    kind: opencode
-                    baseUrl: https://llm.ltms.dev/v1
-                  opus:
-                    subscription: true
-                    model: claude-opus-5
-                  sonnet:
-                    subscription: true
-                    model: claude-sonnet-5
-                  sol:
-                    baseUrl: https://llm.ltms.dev/v1
-                    exhaustedPattern: "The usage limit has been reached"
-                  terra:
-                    baseUrl: https://llm.ltms.dev/v1
-                    exhaustedPattern: "The usage limit has been reached"
-                  xf:
-                    baseUrl: https://llm.ltms.dev/v1
-                """);
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportExhaustedPatternGap(cfg);
-        } finally {
-            detach(appender);
-        }
-
-        List<String> warns = warnMessages(appender);
-        assertFalse(warns.isEmpty(), "6 of 8 profiles are unarmed — at least one WARN must fire");
-
-        // Exactly one WARN aggregates every unarmed profile, naming all 6 and none of the 2 armed.
-        String aggregate = warns.stream()
-                .filter(m -> m.contains("no exhaustedPattern configured"))
-                .findFirst()
-                .orElseThrow(() -> new AssertionError("expected an aggregate unarmed-profiles WARN: " + warns));
-        for (String unarmed : List.of("local", "local-direct", "gx", "opus", "sonnet", "xf")) {
-            assertTrue(aggregate.contains(unarmed), "aggregate WARN must name '" + unarmed + "': " + aggregate);
-        }
-        for (String armed : List.of("sol", "terra")) {
-            assertFalse(aggregate.contains(armed), "aggregate WARN must NOT name armed profile '" + armed + "': " + aggregate);
-        }
-
-        // A second, louder WARN calls out the subscription profiles specifically.
-        String subscriptionWarn = warns.stream()
-                .filter(m -> m.contains("metered Claude plan"))
-                .findFirst()
-                .orElseThrow(() -> new AssertionError("expected a subscription-specific WARN: " + warns));
-        assertTrue(subscriptionWarn.contains("opus"), subscriptionWarn);
-        assertTrue(subscriptionWarn.contains("sonnet"), subscriptionWarn);
-        assertFalse(subscriptionWarn.contains("local-direct"),
-                "the subscription WARN must not name a non-subscription profile: " + subscriptionWarn);
-    }
-
-    @Test
-    void everyProfileArmedProducesNoWarningAtAll(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, """
-                profiles:
-                  sol:
-                    baseUrl: https://llm.ltms.dev/v1
-                    exhaustedPattern: "The usage limit has been reached"
-                  terra:
-                    baseUrl: https://llm.ltms.dev/v1
-                    exhaustedPattern: "The usage limit has been reached"
-                  opus:
-                    subscription: true
-                    model: claude-opus-5
-                    exhaustedPattern: "5-hour limit reached"
-                """);
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportExhaustedPatternGap(cfg);
-        } finally {
-            detach(appender);
-        }
-
-        assertTrue(warnMessages(appender).isEmpty(),
-                "every profile is armed — a checker that warns anyway always fires: " + warnMessages(appender));
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdBackendErrorSinkTest.java

@@ -20,7 +20,6 @@ import dev.ltms.fleet.peer.PeerLauncher;
 import dev.ltms.fleet.peer.SpawnRequest;
 import dev.ltms.fleet.placement.BackendOutagePolicy;
 import dev.ltms.fleet.placement.BackendQuarantine;
-import dev.ltms.fleet.placement.PlacementDecision;
 import dev.ltms.fleet.placement.PlacementPolicies;
 import dev.ltms.fleet.session.MemberSession;
 import dev.ltms.fleet.session.SessionManager;
@@ -124,11 +123,6 @@ class FleetdBackendErrorSinkTest {
             throw new UnsupportedOperationException("not reachable — this test never acquires a session");
         }
 
-        @Override
-        public PeerHandle spawn(SpawnRequest req, PlacementDecision decision) {
-            throw new UnsupportedOperationException("not reachable — this test never acquires a session");
-        }
-
         @Override
         public Set<String> profiles() {
             return Set.of();
@@ -232,44 +226,4 @@ class FleetdBackendErrorSinkTest {
         assertTrue(remaining.isPresent(), "two distinct targets must start a cool-off");
         assertEquals(1, leadClient.sendCount());
     }
-
-    @Test
-    @DisplayName("a backend-error session no longer blocks the real maxLoad spawn gate")
-    void backendErrorSessionDoesNotBlockFreshSpawnAtMaxLoad() {
-        SessionManager sessions = capacityLimitedSessions();
-        MemberSession failed = sessions.acquire("terra", null, null, null);
-
-        assertTrue(sessions.onBackendError(failed.terminalId(), "backend exited"));
-
-        MemberSession fresh = sessions.acquire("terra", null, null, null);
-        assertEquals("terra", fresh.profile(), "the real maxLoad gate grants a fresh spawn after a backend error");
-    }
-
-    @Test
-    @DisplayName("a failed session no longer blocks the real maxLoad spawn gate")
-    void failedSessionDoesNotBlockFreshSpawnAtMaxLoad() {
-        SessionManager sessions = capacityLimitedSessions();
-        MemberSession failed = sessions.acquire("terra", null, null, null);
-
-        sessions.onTurnFailed(failed.terminalId());
-
-        MemberSession fresh = sessions.acquire("terra", null, null, null);
-        assertEquals("terra", fresh.profile(), "the real maxLoad gate grants a fresh spawn after a failed turn");
-    }
-
-    private static SessionManager capacityLimitedSessions() {
-        FakeHerdr herdr = new FakeHerdr();
-        FleetConfig.Profile profile = new FleetConfig.Profile("terra", "http://gx00.gw:8000", "coder",
-                null, "FLEETD_WORKER_TOKEN", List.of("claude"), "tab", "fleetd-workers",
-                "w #{n}", null, null, null, null, null, null, null, 1.0f, 1);
-        Map<String, FleetConfig.Profile> profiles = Map.of("terra", profile);
-        ClaudeCodeLauncher adapter = new ClaudeCodeLauncher(new AgentControl(herdr), new WorkspaceControl(herdr),
-                new SubscriptionGuard(Set.of("gx00.gw")), profiles, "terra", _ -> "tok");
-        AtomicReference<SessionManager> sessionsRef = new AtomicReference<>();
-        CompositePeerLauncher workers = new CompositePeerLauncher(List.of(adapter), "terra", profiles,
-                PlacementPolicies.fixed(), name -> Fleetd.liveSessionCount(sessionsRef.get().roster(), name));
-        SessionManager sessions = new SessionManager(workers);
-        sessionsRef.set(sessions);
-        return sessions;
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/FleetdCapacitySourceWiringTest.java

@@ -1,155 +0,0 @@
-package dev.ltms.fleet;
-
-import dev.ltms.fleet.config.ConfigRef;
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.mcp.FleetMcp;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * fleetd #416: {@code fleet_list}'s {@code CapacitySource.configuredProfiles} must enumerate the
- * <em>startup</em> profile set, not the live, hot-reloaded one.
- *
- * <p>{@code profiles} as a whole is a {@code DEFERRED} key ({@link ConfigRef#DEFERRED_KEYS}):
- * {@code HerdrPeerLauncher} takes {@code Map.copyOf(profiles)} once at construction, so a profile
- * only added to the hot-reloaded map can never actually be spawned. Before this fix, {@code
- * Fleetd.main} built {@code CapacitySource} with {@code () -> config.get().profiles().keySet()} —
- * the live map — so {@code fleet_list} would report a freshly hot-reloaded profile as available
- * ({@code free > 0}) while {@code fleet_spawn} on that same profile failed with
- * {@code unknown worker profile}. Measured on another host: adding a throwaway profile and letting
- * it hot-reload gave {@code fleet_list} -> {@code free: 3} and {@code fleet_spawn} ->
- * {@code error: unknown worker profile}.
- *
- * <p>This test needs a reload, the same reason {@link FleetdExhaustionDetectionArmedWiringTest}
- * does: at startup the two snapshots agree, so a test of only a newly started daemon would not
- * detect a live {@code config.get()} lookup for the set.
- *
- * <p><b>maxLoad must stay hot.</b> It is read off {@code config.get()} exactly like
- * {@code credentialId} ({@link ConfigRef} documents both as hot, "read live off the config
- * supplier ... exactly like weight/maxLoad"), so a reload that only changes an existing profile's
- * {@code maxLoad} — no add/remove — must still change what {@code fleet_list} reports without a
- * restart. A fix that freezes the whole {@code CapacitySource} against {@code cfg} (rather than
- * only its {@code configuredProfiles} set) would trade this bug for its mirror image and is pinned
- * wrong by {@link #reloadedMaxLoadStillChangesWhatFleetListReports}.
- */
-class FleetdCapacitySourceWiringTest {
-
-    private static final String STARTUP = """
-            bind:
-              host: 127.0.0.1
-              port: 8765
-            herdrSocket: ~/.config/herdr/herdr.sock
-            profiles:
-              terra:
-                baseUrl: http://gx00.gw:8000
-                model: terra
-                maxLoad: 3
-            guard:
-              offSubscriptionHosts:
-                - gx00.gw
-            """;
-
-    private static final String WITH_NEW_PROFILE = """
-            bind:
-              host: 127.0.0.1
-              port: 8765
-            herdrSocket: ~/.config/herdr/herdr.sock
-            profiles:
-              terra:
-                baseUrl: http://gx00.gw:8000
-                model: terra
-                maxLoad: 3
-              ghost404:
-                baseUrl: http://gx00.gw:8001
-                model: ghost404
-                maxLoad: 3
-            guard:
-              offSubscriptionHosts:
-                - gx00.gw
-            """;
-
-    private static final String WITH_CHANGED_MAX_LOAD = """
-            bind:
-              host: 127.0.0.1
-              port: 8765
-            herdrSocket: ~/.config/herdr/herdr.sock
-            profiles:
-              terra:
-                baseUrl: http://gx00.gw:8000
-                model: terra
-                maxLoad: 9
-            guard:
-              offSubscriptionHosts:
-                - gx00.gw
-            """;
-
-    @Test
-    @DisplayName("a profile present only in the live (hot-reloaded) config is NOT listed")
-    void liveOnlyProfileIsNotListed(@TempDir Path dir) throws Exception {
-        Path file = dir.resolve("fleetd.yaml");
-        Files.writeString(file, STARTUP);
-        FleetConfig cfg = FleetConfig.load(file);
-        ConfigRef config = new ConfigRef(file, cfg);
-
-        Files.writeString(file, WITH_NEW_PROFILE);
-        assertTrue(config.reload().applied());
-        // The live snapshot now has the new profile — proves the reload really happened and this
-        // test is not accidentally passing because nothing changed.
-        assertTrue(config.get().profiles().containsKey("ghost404"));
-
-        FleetMcp.CapacitySource source = Fleetd.capacitySource(config, cfg, _ -> 0);
-
-        assertFalse(source.configuredProfiles().get().contains("ghost404"),
-                "a profile added only to the hot-reloaded config must not be listed by fleet_list — "
-                        + "HerdrPeerLauncher never learns about it until a restart, so fleet_spawn on it "
-                        + "would fail with 'unknown worker profile' while fleet_list claimed it free");
-    }
-
-    @Test
-    @DisplayName("a profile present in the startup set IS listed")
-    void startupProfileIsListed(@TempDir Path dir) throws Exception {
-        Path file = dir.resolve("fleetd.yaml");
-        Files.writeString(file, STARTUP);
-        FleetConfig cfg = FleetConfig.load(file);
-        ConfigRef config = new ConfigRef(file, cfg);
-
-        FleetMcp.CapacitySource source = Fleetd.capacitySource(config, cfg, _ -> 0);
-
-        // fleetd #416, both-directions requirement: a test that only ever passes an empty/absent
-        // startup set (the case above) cannot tell a correct lookup from one that is permanently
-        // empty (e.g. a mutation replacing the supplier with Set::of). This is the direction that
-        // fails if the fix regresses to reporting nothing at all.
-        assertTrue(source.configuredProfiles().get().contains("terra"),
-                "a profile present in the startup snapshot must still be listed by fleet_list");
-    }
-
-    @Test
-    @DisplayName("a hot maxLoad edit still changes what fleet_list reports")
-    void reloadedMaxLoadStillChangesWhatFleetListReports(@TempDir Path dir) throws Exception {
-        Path file = dir.resolve("fleetd.yaml");
-        Files.writeString(file, STARTUP);
-        FleetConfig cfg = FleetConfig.load(file);
-        ConfigRef config = new ConfigRef(file, cfg);
-
-        FleetMcp.CapacitySource source = Fleetd.capacitySource(config, cfg, _ -> 0);
-        assertEquals(3, source.maxLoad().apply("terra"),
-                "sanity: maxLoad reads 3 from the startup config before any reload");
-
-        Files.writeString(file, WITH_CHANGED_MAX_LOAD);
-        assertTrue(config.reload().applied());
-
-        assertEquals(9, source.maxLoad().apply("terra"),
-                "maxLoad must stay hot — the SAME CapacitySource instance must reflect a reloaded "
-                        + "maxLoad without a restart, exactly like credentialId. Freezing the whole "
-                        + "CapacitySource against the startup snapshot (rather than only its "
-                        + "configuredProfiles set) would trade fleetd #416 for its mirror image.");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdExhaustionDetectionArmedWiringTest.java

@@ -1,94 +0,0 @@
-package dev.ltms.fleet;
-
-import dev.ltms.fleet.config.ConfigRef;
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.mcp.FleetMcp;
-import dev.ltms.fleet.placement.BackendQuarantine;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Map;
-import java.util.regex.Pattern;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #404: {@code exhaustionDetectionArmed} must describe the startup pattern map, not the
- * reloaded config snapshot.
- *
- * <p>This test needs a reload. At startup the two snapshots agree, so a test of only a newly
- * started daemon would not detect a live {@code config.get()} lookup in the report field.
- */
-class FleetdExhaustionDetectionArmedWiringTest {
-
-    private static final String NO_PATTERN = """
-            bind:
-              host: 127.0.0.1
-              port: 8765
-            herdrSocket: ~/.config/herdr/herdr.sock
-            profiles:
-              terra:
-                baseUrl: http://gx00.gw:8000
-                model: terra
-            guard:
-              offSubscriptionHosts:
-                - gx00.gw
-            """;
-
-    private static final String WITH_PATTERN = """
-            bind:
-              host: 127.0.0.1
-              port: 8765
-            herdrSocket: ~/.config/herdr/herdr.sock
-            profiles:
-              terra:
-                baseUrl: http://gx00.gw:8000
-                model: terra
-                exhaustedPattern: "usage limit"
-            guard:
-              offSubscriptionHosts:
-                - gx00.gw
-            """;
-
-    @Test
-    @DisplayName("reloading an exhaustedPattern does not arm the startup detection source")
-    void reloadedPatternDoesNotChangeTheArmedFieldUntilRestart(@TempDir Path dir) throws Exception {
-        Path file = dir.resolve("fleetd.yaml");
-        Files.writeString(file, NO_PATTERN);
-        ConfigRef config = new ConfigRef(file, FleetConfig.load(file));
-
-        Files.writeString(file, WITH_PATTERN);
-        assertTrue(config.reload().applied());
-        assertTrue(config.get().profiles().get("terra").hasExhaustedPattern());
-
-        FleetMcp.QuarantineSource source = Fleetd.quarantineSource(config, BackendQuarantine.none(),
-                Map.of());
-        assertFalse(source.exhaustedPatternArmed().apply("terra"),
-                "exhaustionDetectionArmed must use the startup pattern map, not config.get()");
-    }
-
-    @Test
-    @DisplayName("a profile in the startup pattern map is reported as armed")
-    void aProfileInTheStartupMapIsArmed(@TempDir Path dir) throws Exception {
-        // fleetd #404, second direction. The test above only ever passes an EMPTY startup map, so
-        // it cannot tell a correct lookup from one that is permanently off. Measured: replacing the
-        // armed lambda with `profile -> false` left the whole suite green at 1475 tests. That
-        // mutation would make #395's visibility feature dead — an operator fixing a detection gap
-        // would be told the gap is still open after fixing it, forever. Both directions are needed:
-        // this test is the only thing that fails when the field stops reporting armed at all.
-        Path file = dir.resolve("fleetd.yaml");
-        Files.writeString(file, WITH_PATTERN);
-        ConfigRef config = new ConfigRef(file, FleetConfig.load(file));
-
-        FleetMcp.QuarantineSource source = Fleetd.quarantineSource(config, BackendQuarantine.none(),
-                Map.of("terra", Pattern.compile("usage limit")));
-
-        assertTrue(source.exhaustedPatternArmed().apply("terra"),
-                "a profile whose pattern was compiled at startup must report armed");
-        assertFalse(source.exhaustedPatternArmed().apply("sonnet"),
-                "a profile absent from the startup map must not report armed");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdLeadMailboxSelectionTest.java

@@ -80,7 +80,7 @@ class FleetdLeadMailboxSelectionTest {
     @Test
     void opensTheMailboxWhenAUriAndSelfIdAreConfigured() {
         var opener = new RecordingOpener();
-        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, "mac-opus", null, null);
+        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, "mac-opus", null);
 
         Fleetd.openLeadMailbox(coordinator, Map.of(), opener);
 
@@ -94,7 +94,7 @@ class FleetdLeadMailboxSelectionTest {
     void honoursUriEnvOverALiteralUri() {
         var opener = new RecordingOpener();
         var coordinator = new FleetConfig.Coordinator("amqp://stale:stale@old:5672/x", "COORD_URI",
-                "mac-opus", 8, null);
+                "mac-opus", 8);
 
         Fleetd.openLeadMailbox(coordinator, Map.of("COORD_URI", RESOLVED_URI), opener);
 
@@ -105,7 +105,7 @@ class FleetdLeadMailboxSelectionTest {
     @Test
     void turnsOffWhenUriEnvDoesNotResolve() {
         var opener = new RecordingOpener();
-        var coordinator = new FleetConfig.Coordinator(null, "COORD_URI", "mac-opus", null, null);
+        var coordinator = new FleetConfig.Coordinator(null, "COORD_URI", "mac-opus", null);
 
         assertNull(Fleetd.openLeadMailbox(coordinator, Map.of(), opener));
 
@@ -116,7 +116,7 @@ class FleetdLeadMailboxSelectionTest {
     void warnsAndStaysOffWhenSelfIdIsMissing() {
         var appender = captureFleetdLogs();
         var opener = new RecordingOpener();
-        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, null, null, null);
+        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, null, null);
 
         assertNull(Fleetd.openLeadMailbox(coordinator, Map.of(), opener));
 
@@ -131,7 +131,7 @@ class FleetdLeadMailboxSelectionTest {
         var appender = captureFleetdLogs();
         var opener = new RecordingOpener();
         opener.unreachable = true;
-        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, "mac-opus", null, null);
+        var coordinator = new FleetConfig.Coordinator(RESOLVED_URI, null, "mac-opus", null);
 
         assertNull(Fleetd.openLeadMailbox(coordinator, Map.of(), opener),
                 "a down coordination broker turns the feature off; it must never take the daemon down");

fleetd/src/test/java/dev/ltms/fleet/FleetdModelGateCoverageLineTest.java

@@ -1,62 +0,0 @@
-package dev.ltms.fleet;
-
-import dev.ltms.fleet.peer.PeerLauncher;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-
-/**
- * fleetd #422 follow-up: {@code Fleetd.modelGateCoverageLine} is the startup-log counterpart of
- * {@code exhaustedPatternCoverageLine}/{@code errorPatternCoverageLine} — see {@code
- * FleetdPatternCoverageLineTest} for the identical shape this follows — except here there is no
- * {@code UnsetMeaning} choice for a caller to get backwards: {@link
- * PeerLauncher.ModelGateState#configured()} already states, unambiguously, whether an empty
- * {@link PeerLauncher.ModelGateState#off()} means "no {@code models:} block to gate with at all"
- * or "a block armed and currently reporting zero off". This class proves {@code
- * modelGateCoverageLine} words those two states — plus the third, N off — distinctly, so a
- * mutation that made it ignore {@code configured()} either way is caught here.
- */
-class FleetdModelGateCoverageLineTest {
-
-    @Test
-    @DisplayName("no models: block reports not configured, distinct from armed-with-zero")
-    void noModelsBlockReportsNotConfigured() {
-        String line = Fleetd.modelGateCoverageLine(PeerLauncher.ModelGateState.notConfigured());
-        assertEquals("not configured (no models: block — nothing is gated, and nothing can be)", line);
-    }
-
-    @Test
-    @DisplayName("a models: block armed with nothing off reports armed, distinct from not configured")
-    void armedWithNothingOffReportsArmed() {
-        String line = Fleetd.modelGateCoverageLine(PeerLauncher.ModelGateState.armed(Set.of()));
-        assertEquals("armed (models: block present; 0 models currently turned off)", line);
-    }
-
-    @Test
-    @DisplayName("a models: block with N off names the off models")
-    void armedWithModelsOffNamesThem() {
-        String line = Fleetd.modelGateCoverageLine(
-                PeerLauncher.ModelGateState.armed(Set.of("deepseek-v4-flash", "claude-opus-9000")));
-        assertEquals("armed (2 model(s) turned off: [claude-opus-9000, deepseek-v4-flash])", line);
-    }
-
-    @Test
-    @DisplayName("the three states produce pairwise-distinct wording for the same empty-looking input")
-    void theThreeStatesProduceDistinctWording() {
-        String notConfigured = Fleetd.modelGateCoverageLine(PeerLauncher.ModelGateState.notConfigured());
-        String armedZero = Fleetd.modelGateCoverageLine(PeerLauncher.ModelGateState.armed(Set.of()));
-        String armedOne = Fleetd.modelGateCoverageLine(PeerLauncher.ModelGateState.armed(Set.of("x")));
-
-        // Pinned individually above; restated here so this test alone still catches a regression
-        // even if one of the three tests above were ever deleted — the exact FleetdPatternCoverageLineTest
-        // pattern, adapted from "two keys" to "three states of one gate".
-        assertNotEquals(notConfigured, armedZero,
-                "collapsing 'no models: block' into 'armed, zero off' is fleetd #422 follow-up's exact defect");
-        assertNotEquals(armedZero, armedOne);
-        assertNotEquals(notConfigured, armedOne);
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdPatternCoverageLineTest.java

@@ -1,67 +0,0 @@
-package dev.ltms.fleet;
-
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-
-/**
- * fleetd #415 (review follow-up): {@code CompletionResolverTest} proves {@code coverage()} words
- * {@code UnsetMeaning.OFF} and {@code UnsetMeaning.BUILT_IN_DEFAULT} correctly — but every one of
- * those tests supplies the meaning itself. That proves the enum's wording, never that {@code
- * Fleetd} pairs the right meaning with the right pattern key. That pairing is #415's actual
- * defect: {@code coverage()} had no way to know what unset meant for its key, so the fix moved
- * the fact to the caller — and nothing yet proved the caller states it correctly.
- *
- * <p><b>Measured or it didn't happen:</b> swapping the two {@code UnsetMeaning} arguments at
- * {@code Fleetd}'s two coverage call sites — giving {@code exhaustedPattern} the built-in-default
- * wording and {@code errorPattern} the off wording, #415's exact defect with the keys exchanged —
- * compiled with 0 errors and left all 1506 existing tests green. This class exists to turn that
- * swap red.
- *
- * <p>It calls {@link Fleetd#exhaustedPatternCoverageLine} and {@link Fleetd#errorPatternCoverageLine}
- * directly rather than reading {@code Fleetd.java} as source text (the shape {@code
- * FleetdCompletionResolverWiringTest} uses for a different wiring gap): those two methods are the
- * extracted call sites {@code main} actually invokes, following the same {@code static} factory +
- * dedicated-test pattern as {@link Fleetd#capacitySource} and {@link Fleetd#worktreeBranchLookup}.
- */
-class FleetdPatternCoverageLineTest {
-
-    private static final Set<String> PROFILES = Set.of("terra", "gx10");
-
-    @Test
-    @DisplayName("exhaustedPatternCoverageLine says off when no profile configures exhaustedPattern")
-    void exhaustedPatternCoverageLineSaysOffWhenNoProfileConfiguresIt() {
-        assertEquals("off (no profile has an exhaustedPattern configured; profiles: [gx10, terra])",
-                Fleetd.exhaustedPatternCoverageLine(PROFILES, Set.of()));
-    }
-
-    @Test
-    @DisplayName("errorPatternCoverageLine says built-in default when no profile configures errorPattern")
-    void errorPatternCoverageLineSaysBuiltInDefaultWhenNoProfileConfiguresIt() {
-        assertEquals("built-in default for all profiles (no profile customises errorPattern; "
-                        + "profiles: [gx10, terra])",
-                Fleetd.errorPatternCoverageLine(PROFILES, Set.of()));
-    }
-
-    @Test
-    @DisplayName("the two keys produce different wording for the identical empty-coverage input")
-    void theTwoKeysProduceDifferentWordingForTheSameEmptyInput() {
-        String exhaustedLine = Fleetd.exhaustedPatternCoverageLine(PROFILES, Set.of());
-        String errorLine = Fleetd.errorPatternCoverageLine(PROFILES, Set.of());
-
-        // Pinned individually above; restated here so this test alone still catches a swap even
-        // if one of the two tests above were ever deleted.
-        assertEquals("off (no profile has an exhaustedPattern configured; profiles: [gx10, terra])",
-                exhaustedLine);
-        assertEquals("built-in default for all profiles (no profile customises errorPattern; "
-                        + "profiles: [gx10, terra])", errorLine);
-        assertNotEquals(exhaustedLine, errorLine,
-                "swapping which UnsetMeaning pairs with which pattern key at Fleetd's call sites "
-                        + "must be caught here — that pairing, not coverage()'s own wording in isolation, "
-                        + "is fleetd #415's actual defect");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdStartupReportTest.java

@@ -1,79 +0,0 @@
-package dev.ltms.fleet;
-
-import ch.qos.logback.classic.Logger;
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.spi.ILoggingEvent;
-import ch.qos.logback.core.read.ListAppender;
-import dev.ltms.fleet.config.FleetConfig;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import org.slf4j.LoggerFactory;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * Proves {@link Fleetd#main(String[])} calls every startup report before validation aborts startup.
- * The invalid non-loopback bind makes {@link FleetConfig#validateAll()} throw before {@code main}
- * can open the herdr socket or bind a port. The fixture also triggers every report, so removing any
- * one call from {@code main} leaves its expected log line absent.
- */
-class FleetdStartupReportTest {
-
-    private static Level originalLevel;
-
-    private static ListAppender<ILoggingEvent> attach() {
-        Logger logger = (Logger) LoggerFactory.getLogger(Fleetd.class);
-        originalLevel = logger.getLevel();
-        logger.setLevel(Level.INFO);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        return appender;
-    }
-
-    private static void detach(ListAppender<ILoggingEvent> appender) {
-        Logger logger = (Logger) LoggerFactory.getLogger(Fleetd.class);
-        logger.detachAppender(appender);
-        logger.setLevel(originalLevel);
-    }
-
-    private static boolean contains(ListAppender<ILoggingEvent> appender, String fragment) {
-        return appender.list.stream()
-                .map(ILoggingEvent::getFormattedMessage)
-                .anyMatch(message -> message.contains(fragment));
-    }
-
-    @Test
-    void mainReportsEveryStartupGapBeforeValidationAborts(@TempDir Path dir) throws Exception {
-        Path config = dir.resolve("fleetd.yaml");
-        Files.writeString(config, """
-                bind:
-                  host: 0.0.0.0
-                  port: 8765
-                profiles:
-                  worker:
-                    baseUrl: https://llm.ltms.dev/v1
-                    gitTokenEnv: GITEA_TOKEN
-                """);
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            assertThrows(IllegalStateException.class, () -> Fleetd.main(new String[]{config.toString()}));
-        } finally {
-            detach(appender);
-        }
-
-        assertTrue(contains(appender, "startup git host GITEA_HOST:"),
-                "Fleetd.main must report the git host shape");
-        assertTrue(contains(appender, "member trust model: members run as the same OS user"),
-                "Fleetd.main must report the member trust model");
-        assertTrue(contains(appender, "memberCredentials: absent or empty"),
-                "Fleetd.main must report an absent memberCredentials policy");
-        assertTrue(contains(appender, "exhaustedPattern: profile(s) [worker] have no exhaustedPattern configured"),
-                "Fleetd.main must report profiles without exhaustedPattern");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/FleetdStartupValidationTest.java

@@ -1,132 +0,0 @@
-package dev.ltms.fleet;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * Proves the one thing no test proved before this ticket's follow-up: that {@code Fleetd.main}
- * ITSELF — not a copy of its logic, not the validator called directly — still refuses to start on
- * a bad config. Mutation testing found that deleting {@code cfg.validateAll();} (née six
- * individual {@code cfg.validateXxx();} calls) from {@code Fleetd.main} left the full 1478-test
- * suite green; every existing test called a validator directly and none exercised {@code
- * Fleetd.main} as the caller. See {@code FleetConfigValidateAllTest} for why the fix collapses
- * those six calls into one reflective {@link FleetConfig#validateAll()}, and {@code
- * ConfigRefTest} for the equivalent proof on the {@link
- * dev.ltms.fleet.config.ConfigRef#reload()} path.
- *
- * <p>This is deliberately the real {@code static void main(String[] args)} — package-private, so
- * only a test in this package can call it, which is exactly what makes this proof strong: it is
- * not a helper extracted for testability, it is the literal method {@code java -jar fleetd.jar}
- * invokes. Every fixture below is otherwise-valid and fails exactly one validator, and — because
- * {@link FleetConfig#validateAll()} runs immediately after {@code SubscriptionGuard.
- * assertPrimaryClean}, before {@code main} opens the herdr socket, binds Javalin, or touches
- * anything else with a real side effect — calling {@code Fleetd.main} with one of these configs is
- * safe: it is guaranteed to throw before reaching any of that, precisely because the config is
- * deliberately invalid.
- */
-class FleetdStartupValidationTest {
-
-    private static void assertMainRefuses(Path dir, String fileName, String yaml,
-                                           String mustContain) throws Exception {
-        Path f = dir.resolve(fileName);
-        Files.writeString(f, yaml);
-        IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> Fleetd.main(new String[]{f.toString()}),
-                fileName + ": Fleetd.main must refuse this config before doing anything else");
-        assertTrue(e.getMessage().contains(mustContain),
-                fileName + ": expected message to contain \"" + mustContain + "\" but was: "
-                        + e.getMessage());
-    }
-
-    @Test
-    void mainRefusesANonLoopbackBindWithoutTokenMode(@TempDir Path dir) throws Exception {
-        assertMainRefuses(dir, "auth-exposure.yaml", """
-                bind:
-                  host: 0.0.0.0
-                  port: 8765
-                """, "auth.mode: token");
-    }
-
-    @Test
-    void mainRefusesALeadTabPrefixCollision(@TempDir Path dir) throws Exception {
-        assertMainRefuses(dir, "lead-tab-prefixes.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                fleet:
-                  tabLabel: "lead: {role} {profile}"
-                  leaders:
-                    opus:
-                      tab: "lead: opus"
-                """, "fleet.tabLabel");
-    }
-
-    @Test
-    void mainRefusesASubscriptionProfileThatReseatsAnthropicBaseUrl(@TempDir Path dir)
-            throws Exception {
-        assertMainRefuses(dir, "subscription-profiles.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  sonnet:
-                    subscription: true
-                    argv: ["ccs", "sonnet"]
-                    env:
-                      ANTHROPIC_BASE_URL: http://anything-not-on-the-allowlist
-                """, "ANTHROPIC_BASE_URL");
-    }
-
-    @Test
-    void mainRefusesAnUnknownCharterKey(@TempDir Path dir) throws Exception {
-        assertMainRefuses(dir, "charters.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                fleet:
-                  charters:
-                    architetc: text
-                """, "architetc");
-    }
-
-    @Test
-    void mainRefusesAnArchitectSlotNamingAnUnconfiguredProfile(@TempDir Path dir) throws Exception {
-        assertMainRefuses(dir, "members.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  gx10:
-                    baseUrl: http://gx10.gw:8000
-                fleet:
-                  architects:
-                    lead-designer:
-                      profile: sonnet
-                """, "lead-designer");
-    }
-
-    @Test
-    void mainRefusesAProfileNamingAModelOutsideTheAllowList(@TempDir Path dir) throws Exception {
-        assertMainRefuses(dir, "models.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  rogue:
-                    baseUrl: http://gx11.gw:8000
-                    model: claude-opus-9000
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """, "rogue");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/GitHostShapeReportTest.java

@@ -1,241 +0,0 @@
-package dev.ltms.fleet;
-
-import ch.qos.logback.classic.Level;
-import ch.qos.logback.classic.Logger;
-import ch.qos.logback.classic.spi.ILoggingEvent;
-import ch.qos.logback.core.read.ListAppender;
-import dev.ltms.fleet.config.FleetConfig;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import org.slf4j.LoggerFactory;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.Map;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #377: the startup git host line must report the <em>shape</em> of the value a
- * member receives as GITEA_HOST — set or unset, length, scheme, trailing slash — and the
- * value itself must never reach the log.
- */
-class GitHostShapeReportTest {
-
-    /** A profile that opts in to the git-forge token, so GITEA_HOST is the var that matters. */
-    private static final String GIT_TOKEN_CONFIG = """
-            profiles:
-              local:
-                baseUrl: http://gx00.gw:8000
-                gitTokenEnv: WORKER_GITEA_TOKEN
-            """;
-
-    private static FleetConfig load(Path dir, String yaml) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml);
-        return FleetConfig.load(f);
-    }
-
-    /**
-     * The level this logger had before {@link #attach()} raised it, so {@link #detach} can put it
-     * back. {@code null} is a real value here — it means "inherit from the parent" — and that is
-     * exactly the state this logger starts in, so it must be restored as {@code null} rather than
-     * as some concrete level.
-     */
-    private static Level originalLevel;
-
-    /**
-     * fleetd #377: the shape lines are logged at INFO, and {@code logback-test.xml} sets
-     * {@code dev.ltms.fleet} to WARN — so INFO events are dropped by the level check BEFORE any
-     * appender sees them. Attaching an appender is therefore not enough: without raising the level
-     * the list stays empty and every assertion below fails against correct production code. The
-     * sibling report tests do the same thing at each call site (see
-     * {@code MemberTrustModelReportTest}); doing it here keeps it in one place.
-     */
-    private static ListAppender<ILoggingEvent> attach() {
-        Logger logger = (Logger) LoggerFactory.getLogger(Fleetd.class);
-        originalLevel = logger.getLevel();
-        logger.setLevel(Level.INFO);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        return appender;
-    }
-
-    private static void detach(ListAppender<ILoggingEvent> appender) {
-        Logger logger = (Logger) LoggerFactory.getLogger(Fleetd.class);
-        logger.detachAppender(appender);
-        logger.setLevel(originalLevel);
-    }
-
-    private static List<String> messages(ListAppender<ILoggingEvent> appender) {
-        return appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
-    }
-
-    @Test
-    void setLineReportsLengthSchemeAndTrailingSlash(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-        String value = "https://git.example.test/";
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of("GITEA_HOST", value));
-        } finally {
-            detach(appender);
-        }
-
-        String expected = "startup git host GITEA_HOST: set (profile 'local' gitHostEnv) — "
-                + "length=" + value.length() + ", startsWithScheme=true, trailingSlash=true";
-        assertTrue(messages(appender).contains(expected),
-                "a value with a scheme and a trailing slash must be reported by shape only: "
-                        + "its length, startsWithScheme=true, trailingSlash=true");
-    }
-
-    @Test
-    void bareHostLineReportsNoSchemeNoTrailingSlash(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-        String value = "git.example.test";
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of("GITEA_HOST", value));
-        } finally {
-            detach(appender);
-        }
-
-        String expected = "startup git host GITEA_HOST: set (profile 'local' gitHostEnv) — "
-                + "length=" + value.length() + ", startsWithScheme=false, trailingSlash=false";
-        assertTrue(messages(appender).contains(expected),
-                "a bare host name must report startsWithScheme=false, trailingSlash=false");
-    }
-
-    @Test
-    void unsetVariableIsLoggedAtInfoAndDoesNotThrow(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            // GITEA_HOST absent from the map entirely — the unset case must not throw.
-            Fleetd.reportGitHostShape(cfg, Map.of());
-        } finally {
-            detach(appender);
-        }
-
-        assertTrue(appender.list.stream().anyMatch(e ->
-                        e.getLevel() == Level.INFO
-                                && e.getFormattedMessage()
-                                    .startsWith("startup git host GITEA_HOST: unset (profile 'local' gitHostEnv)")),
-                "an unset git host is useful information, not an error — say it at INFO level");
-    }
-
-    /**
-     * The important test: the value must NEVER appear in the log output. This test fails if the
-     * line is ever changed to include the value, because it drives the real logging path with a
-     * value that carries a marker no shape field could contain.
-     */
-    @Test
-    void theValueNeverAppearsInLogOutput(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-        String marker = "never-logged-host-shape-377";
-        String value = "https://" + marker + "/";
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of("GITEA_HOST", value));
-        } finally {
-            detach(appender);
-        }
-
-        List<String> msgs = messages(appender);
-        assertFalse(msgs.stream().anyMatch(m -> m.contains(value)),
-                "the full GITEA_HOST value must never reach the log");
-        assertFalse(msgs.stream().anyMatch(m -> m.contains(marker)),
-                "no fragment of the value may reach the log — a line that embeds the value"
-                        + " would leak at least this marker");
-        assertTrue(msgs.stream().anyMatch(m -> m.contains("startsWithScheme=true")
-                        && m.contains("trailingSlash=true")),
-                "the shape must still be reported although the value is not");
-    }
-
-    @Test
-    void unsetReportAlsoCarriesNoValue(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-        // A blank value is not injected either (putIfPresent skips it), so it must report unset
-        // without echoing anything of it.
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of("GITEA_HOST", "  "));
-        } finally {
-            detach(appender);
-        }
-
-        assertTrue(messages(appender).stream().anyMatch(m ->
-                        m.startsWith("startup git host GITEA_HOST: unset")),
-                "a blank value is skipped by the launcher, so the line reports unset");
-    }
-
-    @Test
-    void defaultGitHostEnvIsGITEA_HOST(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, GIT_TOKEN_CONFIG);
-
-        assertEquals(Map.of("GITEA_HOST", List.of("profile 'local' gitHostEnv")),
-                Fleetd.gitHostEnvVars(cfg));
-    }
-
-    @Test
-    void explicitGitHostEnvReportsUnderItsOwnName(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, """
-                profiles:
-                  local:
-                    baseUrl: http://gx00.gw:8000
-                    gitTokenEnv: WORKER_GITEA_TOKEN
-                    gitHostEnv: MY_FORGE_HOST
-                """);
-        String value = "https://forge.example.test/";
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of("MY_FORGE_HOST", value));
-        } finally {
-            detach(appender);
-        }
-
-        assertTrue(messages(appender).contains(
-                        "startup git host MY_FORGE_HOST: set (profile 'local' gitHostEnv) — "
-                                + "length=" + value.length()
-                                + ", startsWithScheme=true, trailingSlash=true"),
-                "an explicitly named gitHostEnv is reported under that name");
-    }
-
-    @Test
-    void noGitTokenMeansNoHostLineIsNeeded(@TempDir Path dir) throws Exception {
-        FleetConfig cfg = load(dir, """
-                profiles:
-                  local:
-                    baseUrl: http://gx00.gw:8000
-                """);
-
-        ListAppender<ILoggingEvent> appender = attach();
-        try {
-            Fleetd.reportGitHostShape(cfg, Map.of());
-        } finally {
-            detach(appender);
-        }
-
-        assertEquals(List.of("startup git host: no profile sets a gitTokenEnv — nothing to check"),
-                messages(appender));
-    }
-
-    @Test
-    void aHostWithAPortIsNotTreatedAsAScheme() {
-        assertFalse(Fleetd.startsWithScheme("git.example.test"));
-        assertFalse(Fleetd.startsWithScheme("git.example.test:3000"));
-        assertFalse(Fleetd.startsWithScheme("git.example.test:3000/"));
-        assertTrue(Fleetd.startsWithScheme("https://git.example.test"));
-        assertTrue(Fleetd.startsWithScheme("https://git.example.test:3000/"));
-        assertTrue(Fleetd.startsWithScheme("ssh://git.example.test"));
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/auth/AuthzTest.java

@@ -113,20 +113,6 @@ class AuthzTest {
         assertTrue(Authz.permits(WORKER_A, METRICS, null));
     }
 
-    /**
-     * fleetd #421 — unlike READ (the case above), COORD_READ (a lead's own held peer mail) is the
-     * primary's alone. A worker or an architect reading it would disclose lead-to-lead
-     * coordination bodies, not the secret-free roster READ is open about.
-     */
-    @Test
-    void coordReadIsThePrimarysAloneNotAWidenedRead() {
-        assertTrue(Authz.permits(PRIMARY, COORD_READ, null));
-        assertFalse(Authz.permits(WORKER_A, COORD_READ, null),
-                "a worker must not read held lead-to-lead mail");
-        assertFalse(Authz.permits(ARCH_DESIGN, COORD_READ, null),
-                "an architect holds READ today, but not-primary must mean not-architect here too");
-    }
-
     @Test
     void unauthenticatedIsDistinguishedFromMerelyForbidden() {
         // Drives the 401-vs-403 split: a missing credential is fixable by the caller, a wrong role

fleetd/src/test/java/dev/ltms/fleet/auth/CallerResolverTest.java

@@ -103,54 +103,6 @@ class CallerResolverTest {
         assertEquals(Role.PRIMARY, p.role(), "the historical behaviour, now an explicit choice");
     }
 
-    // ── fleetd #317: an unresolvable caller must never be promoted to the primary ──────────────────
-    // #305 closed the trigger where a resolved pid matched no pane *and* had no ancestry walk to
-    // save it. This is the other trigger PaneLocator's javadoc names: the pid never resolves at
-    // all — LsofPeerPidLookup returns -1 on any failure, including (silently) "lsof found no
-    // match" — so there is no candidate pid for an ancestry walk to even attempt.
-
-    /**
-     * The failing-without-the-fix case. Before #317's fix, {@code c.terminal() == null} was the
-     * only test in the loopback-trust fallback, and an unresolved pid produces exactly that same
-     * {@code null} terminal as a genuine primary — so this caller was handed
-     * {@code Principal.primary(...)}, a real worker's failed lookup becoming indistinguishable from
-     * the lead.
-     */
-    @Test
-    void aFailedPeerPidLookupIsRefusedNotPromotedToPrimary() {
-        ConnectionIdentity unresolved = new ConnectionIdentity(new PaneLocator(herdr), _ -> -1);
-        Principal p = new CallerResolver(unresolved).resolve("127.0.0.1", 55555, null);
-
-        assertEquals(Role.ANONYMOUS, p.role(),
-                "an unresolvable caller must never be silently promoted to the primary");
-    }
-
-    /**
-     * The companion invariant #317 must not break: a caller whose lookup genuinely succeeded, and
-     * who simply owns no herdr pane — the real primary's own connection — is still the primary.
-     * This is {@link #loopbackTrustTreatsANonWorkerLoopbackCallerAsThePrimary} pinned again here,
-     * named for #317 and placed next to the test it must be distinguished from: same {@code null}
-     * terminal, opposite verdict, because {@code Caller.resolved()} tells them apart.
-     */
-    @Test
-    void aRealPidThatOwnsNoPaneIsStillThePrimaryNotRefused() {
-        Principal p = new CallerResolver(nonWorkerIdentity()).resolve("127.0.0.1", 55555, null);
-
-        assertEquals(Role.PRIMARY, p.role());
-    }
-
-    /** #317 point 4: token mode never consults {@code c.pid()}, so a failed lookup must not change it. */
-    @Test
-    void tokenModeIsUndisturbedByAnUnresolvedLookup() {
-        ConnectionIdentity unresolved = new ConnectionIdentity(new PaneLocator(herdr), _ -> -1);
-        CallerResolver r = new CallerResolver(unresolved, true, "s3cret");
-
-        assertEquals(Role.ANONYMOUS, r.resolve("127.0.0.1", 55555, null).role(),
-                "no credential is still just ANONYMOUS, as before #317 — unchanged by the lookup failing");
-        assertEquals(Role.PRIMARY, r.resolve("127.0.0.1", 55555, "Bearer s3cret").role(),
-                "a valid token still authenticates the primary even though the peer-pid lookup failed");
-    }
-
     @Test
     void tokenModeRefusesANonWorkerCallerThatPresentsNoToken() {
         Principal p = new CallerResolver(nonWorkerIdentity(), true, "s3cret")
@@ -461,29 +413,4 @@ class CallerResolverTest {
         assertThrows(IllegalArgumentException.class, () -> new CallerResolver(id, true, null));
         assertThrows(IllegalArgumentException.class, () -> new CallerResolver(id, true, "  "));
     }
-    @Test
-    void aWorkerOnAnyLoopbackSourceAddressIsStillAWorkerNotThePrimary() {
-        // fleetd #305: the escalation. ConnectionIdentity used to accept only 127.0.0.1, so a
-        // worker connecting from 127.0.0.2 resolved to no terminal, and this resolver's own
-        // (wider) loopback check then made it the PRIMARY — granting spawn, stop, send and drain.
-        // Measured on the Linux fleet host: binding a source of 127.0.0.2 succeeds there, so the
-        // path is real and not theoretical.
-        CallerResolver r = new CallerResolver(workerIdentity(), false, null);
-        for (String src : new String[]{"127.0.0.1", "127.0.0.2", "127.1.2.3", "::ffff:127.0.0.2"}) {
-            Principal p = r.resolve(src, 55555, null);
-            assertEquals(Role.WORKER, p.role(), "a worker must stay a worker from source " + src);
-            assertEquals("term_a", p.terminal(), "worker terminal from source " + src);
-        }
-    }
-
-    @Test
-    void aNonWorkerOnAnyLoopbackSourceAddressIsStillThePrimary() {
-        // The other direction of the same fix: widening the identity check must not demote a
-        // legitimate same-host primary that happens to connect from another 127.* address.
-        CallerResolver r = new CallerResolver(nonWorkerIdentity(), false, null);
-        for (String src : new String[]{"127.0.0.1", "127.0.0.2", "::ffff:127.0.0.1"}) {
-            assertEquals(Role.PRIMARY, r.resolve(src, 55555, null).role(), "source " + src);
-        }
-    }
-
 }

fleetd/src/test/java/dev/ltms/fleet/auth/MemberRegistryLiveTest.java

@@ -1,360 +0,0 @@
-package dev.ltms.fleet.auth;
-
-import dev.ltms.fleet.config.ConfigRef;
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.herdr.FakeHerdr;
-import dev.ltms.fleet.herdr.PaneLocator;
-import dev.ltms.fleet.mcp.ConnectionIdentity;
-import dev.ltms.fleet.peer.MemberRole;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Map;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * fleetd #424 — revoking (or granting) an architect slot must take effect on the next spawn with
- * no restart. A session already bound to a slot keeps its <em>binding</em> (the {@code
- * terminalToSlot} occupancy) even after that slot drops out of config, but NOT the ARCHITECT
- * <em>privilege</em> the slot used to grant — that is revoked on the bound session's very next
- * request. See {@link MemberRegistry}'s class doc for the exact rule: "config governs what a
- * bound slot still grants, as well as what may be bound next."
- *
- * <p>Every test here drives a REAL {@link ConfigRef#reload()} against a {@code @TempDir} file and
- * asserts {@link ConfigRef.Outcome#applied()}, rather than comparing two frozen
- * {@code MemberRegistry} instances in memory — the defect this ticket fixes is specifically that
- * {@link MemberRegistry} used to ignore a live reload, so a test that never reloads cannot tell the
- * fixed registry from the broken one. {@code requireSlotFor} and {@code reserve} are pinned in
- * separate tests, in both directions (removed and added), so a registry that simply refuses (or
- * simply allows) everything cannot pass by accident — see {@link MemberRegistryTest} for the
- * registry's other invariants (bind/unbind cardinality, thread-safety), which are unaffected by
- * this ticket and still exercised against the frozen constructor.
- */
-class MemberRegistryLiveTest {
-
-    private static String yaml(String fleetBlock) {
-        return """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                herdrSocket: ~/.config/herdr/herdr.sock
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet
-                  opus:
-                    baseUrl: http://gx00.gw:8001
-                    model: opus
-                guard:
-                  offSubscriptionHosts:
-                    - gx00.gw
-                """ + fleetBlock;
-    }
-
-    private static final String WITH_SONNET_SLOT = """
-            fleet:
-              architects:
-                designer:
-                  profile: sonnet
-            """;
-
-    /** No architect pool at all — developers is unrelated dead data for this registry (#424 out of scope). */
-    private static final String WITHOUT_ARCHITECT_SLOTS = """
-            fleet:
-              developers:
-                dev1:
-                  profile: sonnet
-            """;
-
-    /** Same slot name ({@code designer}) as {@link #WITH_SONNET_SLOT}, repointed to a different profile. */
-    private static final String WITH_OPUS_SLOT = """
-            fleet:
-              architects:
-                designer:
-                  profile: opus
-            """;
-
-    /** Same profile ({@code sonnet}) as {@link #WITH_SONNET_SLOT}, but the pool key is renamed. */
-    private static final String WITH_RENAMED_SLOT = """
-            fleet:
-              architects:
-                architect-lead:
-                  profile: sonnet
-            """;
-
-    private static ConfigRef refFor(Path f) {
-        return new ConfigRef(f, FleetConfig.load(f));
-    }
-
-    // ── requireSlotFor is live (criteria 1, 2, 4) ──────────────────────────────────────────────
-
-    @Test
-    void requireSlotForRefusesAProfileWhoseSlotWasRemovedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertDoesNotThrow(() -> registry.requireSlotFor(MemberRole.ARCHITECT, "sonnet"),
-                "the slot is configured before the reload");
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertThrows(IllegalArgumentException.class,
-                () -> registry.requireSlotFor(MemberRole.ARCHITECT, "sonnet"),
-                "revoking the slot must refuse the NEXT spawn that names it");
-    }
-
-    @Test
-    void requireSlotForAllowsAProfileWhoseSlotWasAddedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertThrows(IllegalArgumentException.class,
-                () -> registry.requireSlotFor(MemberRole.ARCHITECT, "sonnet"),
-                "no architect slot is configured yet");
-
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertDoesNotThrow(() -> registry.requireSlotFor(MemberRole.ARCHITECT, "sonnet"),
-                "a slot added by reload must be usable with no restart");
-    }
-
-    // ── reserve is live too — tested separately from requireSlotFor (criteria 1, 2, 4) ────────
-
-    @Test
-    void reserveRefusesAProfileWhoseSlotWasRemovedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        MemberLifecycle.SlotReservation before = registry.reserve(MemberRole.ARCHITECT, "sonnet");
-        assertEquals("architect:designer", before.slot());
-        registry.release(before); // free it back up so the reload-side reserve below starts clean
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertThrows(IllegalArgumentException.class,
-                () -> registry.reserve(MemberRole.ARCHITECT, "sonnet"),
-                "revoking the slot must refuse the NEXT reservation for it");
-    }
-
-    @Test
-    void reserveAllowsAProfileWhoseSlotWasAddedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertThrows(IllegalArgumentException.class,
-                () -> registry.reserve(MemberRole.ARCHITECT, "sonnet"),
-                "no architect slot is configured yet");
-
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        MemberLifecycle.SlotReservation after = registry.reserve(MemberRole.ARCHITECT, "sonnet");
-        assertEquals("architect:designer", after.slot(),
-                "a slot added by reload must be reservable with no restart");
-    }
-
-    // ── profileForSlot, isSlot and nameForSlot are live too (fleetd #431) ─────────────────────────
-    // #424 pinned roleForSlot against a live reload but left these three untested — proved by
-    // mutating each to read a snapshot flattened once at construction: the full suite stayed green
-    // for all three.
-    //
-    // The three differ in how much production behaviour depends on them, and the ticket first got
-    // this ranking wrong. nameForSlot is wired: CallerResolver passes members::nameForSlot, next to
-    // members::roleForSlot. isSlot is reached through bind, which calls it to refuse an unknown
-    // slot. profileForSlot has NO caller in src/main at all — grepped both the ".profileForSlot("
-    // and the "::profileForSlot" form — so there is no seam to drive its test through beyond the
-    // accessor itself, and its own javadoc ("what the spawn lifecycle reads") describes a caller
-    // that does not exist. These tests pin the accessors as they are; whether profileForSlot should
-    // be wired or deleted is a separate question.
-
-    @Test
-    void profileForSlotReflectsAProfileChangedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertEquals("sonnet", registry.profileForSlot("architect:designer"),
-                "the slot's profile before the reload");
-
-        Files.writeString(f, yaml(WITH_OPUS_SLOT));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertEquals("opus", registry.profileForSlot("architect:designer"),
-                "repointing the slot to a different profile must take effect with no restart");
-    }
-
-    @Test
-    void isSlotStopsReportingASlotRemovedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertTrue(registry.isSlot("architect:designer"), "the slot is configured before the reload");
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertFalse(registry.isSlot("architect:designer"),
-                "removing the slot from config must make isSlot say so on the very next call, "
-                        + "with no restart");
-    }
-
-    @Test
-    void isSlotStartsReportingASlotAddedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertFalse(registry.isSlot("architect:designer"), "no architect slot is configured yet");
-
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertTrue(registry.isSlot("architect:designer"),
-                "a slot added by reload must be visible to isSlot with no restart");
-    }
-
-    @Test
-    void nameForSlotReflectsANameChangedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        assertEquals("designer", registry.nameForSlot("architect:designer"),
-                "the configured name before the reload");
-
-        Files.writeString(f, yaml(WITH_RENAMED_SLOT));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertNull(registry.nameForSlot("architect:designer"),
-                "the old key no longer names a configured slot — it was renamed away by the reload");
-        assertEquals("architect-lead", registry.nameForSlot("architect:architect-lead"),
-                "the new name must be visible under its new qualified key with no restart");
-    }
-
-    // ── a bound architect is demoted, but the binding itself is not touched (fleetd #424) ───────
-    // The lead's corrected ruling: the PRIVILEGE a slot grants is revoked on the bound session's
-    // very next request, but the terminalToSlot BINDING itself is untouched by a reload — dropping
-    // it would double-book the slot key and break unbind's compare-safe contract. See the class
-    // doc's binding rule.
-
-    /** A caller identity resolving the one canned pane (terminal {@code term_a}) in {@link FakeHerdr}. */
-    private static ConnectionIdentity boundPaneIdentity() {
-        return new ConnectionIdentity(new PaneLocator(new FakeHerdr()), _ -> FakeHerdr.WORKER_PID);
-    }
-
-    @Test
-    void anArchitectAlreadyBoundToASlotIsDemotedByReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        MemberLifecycle.SlotReservation reservation = registry.reserve(MemberRole.ARCHITECT, "sonnet");
-        assertTrue(registry.bind(reservation, "term_a"));
-        assertEquals("architect:designer", registry.slotForTerminal("term_a"));
-
-        // Drive the real caller path, not the roleForSlot seam directly: CallerResolver.resolve is
-        // what a live request actually goes through (CallerResolver.java:220), and a resolver that
-        // ignored roleForSlot entirely would still pass a test that only checked the seam.
-        CallerResolver resolver = CallerResolver.withLeadsAndMembers(
-                boundPaneIdentity(), false, null, Map::of, registry);
-
-        Principal before = resolver.resolve("127.0.0.1", 42, null);
-        assertEquals(Role.ARCHITECT, before.role(), "sanity check: the harness binds term_a as an architect");
-        assertEquals("designer", before.name());
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        Principal after = resolver.resolve("127.0.0.1", 42, null);
-        assertEquals(Role.WORKER, after.role(),
-                "removing the slot from config must demote the bound session to worker on its "
-                        + "NEXT request — this is the ticket's whole point");
-        assertEquals("term_a", after.terminal(), "same pane, same terminal — only the role changed");
-    }
-
-    @Test
-    void theOriginalBindingStillOccupiesTheRemovedSlotSoASecondTerminalCannotClaimIt(@TempDir Path dir)
-            throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        MemberLifecycle.SlotReservation reservation = registry.reserve(MemberRole.ARCHITECT, "sonnet");
-        assertTrue(registry.bind(reservation, "term_a"));
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome removed = ref.reload();
-        assertTrue(removed.applied(), "the reload must actually take effect: " + removed.summary());
-
-        // The binding survives the removal untouched.
-        assertEquals("architect:designer", registry.slotForTerminal("term_a"),
-                "a live binding must never be retroactively unbound by a config edit");
-        assertEquals(Map.of("term_a", "architect:designer"), registry.snapshot());
-
-        // Bring the slot back into config. If the binding had been silently dropped by the removal
-        // (rather than merely losing the privilege it grants), a second terminal could now claim
-        // the "freed" key — the exact double-booking the class doc's binding rule rules out.
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef.Outcome restored = ref.reload();
-        assertTrue(restored.applied(), "the reload must actually take effect: " + restored.summary());
-
-        assertFalse(registry.bind("architect:designer", "term_b"),
-                "the slot is still occupied by term_a — a second terminal must not bind to it");
-        assertThrows(IllegalArgumentException.class,
-                () -> registry.reserve(MemberRole.ARCHITECT, "sonnet"),
-                "the slot is still occupied by term_a — a fresh reservation must not find it free");
-        assertEquals("architect:designer", registry.slotForTerminal("term_a"),
-                "the original binding is unchanged throughout");
-    }
-
-    @Test
-    void unbindStillSucceedsForTheOriginalTerminalAfterItsSlotIsRemoved(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml(WITH_SONNET_SLOT));
-        ConfigRef ref = refFor(f);
-        MemberRegistry registry = MemberRegistry.live(() -> ref.get().fleet());
-
-        MemberLifecycle.SlotReservation reservation = registry.reserve(MemberRole.ARCHITECT, "sonnet");
-        assertTrue(registry.bind(reservation, "term_a"));
-
-        Files.writeString(f, yaml(WITHOUT_ARCHITECT_SLOTS));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), "the reload must actually take effect: " + out.summary());
-
-        assertTrue(registry.unbind("architect:designer", "term_a"),
-                "unbind must still work for a slot that config has since removed, or a session "
-                        + "that outlives its slot's removal could never release it");
-        assertNull(registry.slotForTerminal("term_a"));
-        assertEquals(Map.of(), registry.snapshot());
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/ConfigRefProfileCoverageTest.java

@@ -1,202 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.RecordComponent;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #323: {@code ConfigRef.sameLaunchSettings} javadoc used to claim it "compares every
- * component the launcher reads at spawn". It did not — {@code ideProjectDir}, {@code
- * ideOpenCommand} and {@code autoCompactWindow} were all baked in at daemon startup (see
- * {@code ClaudeCodeLauncher}/{@code OpenCodeLauncher}) and missing from the comparison, so a reload
- * that changed only one of them reported "config reloaded" and the running daemon kept the old
- * value.
- *
- * <p>This class is the mechanism the issue asked for: it enumerates every record component of
- * {@link FleetConfig.Profile} by reflection and proves — by actually mutating a base profile one
- * field at a time and calling the real method — that each component is either compared by
- * {@link ConfigRef#sameLaunchSettings} or named in {@link ConfigRef#LAUNCH_SETTINGS_EXCLUDED} with
- * a reason. A new profile field that is neither fails this test by name, not a hand-maintained list
- * going stale.
- */
-class ConfigRefProfileCoverageTest {
-
-    private static final RecordComponent[] COMPONENTS = FleetConfig.Profile.class.getRecordComponents();
-
-    /**
-     * One valid, non-blank value per record component — "the a value". None of these trip any
-     * defaulting/normalization in {@code Profile}'s compact constructor (see {@code
-     * FleetConfig.java}), so what goes in is what {@code sameLaunchSettings} sees back out.
-     */
-    private static final Map<String, Object> BASE = baseValues();
-
-    /** The same shape, each value distinct from {@link #BASE} — "the b value". */
-    private static final Map<String, Object> ALT = altValues();
-
-    private static Map<String, Object> baseValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("profile", "sonnet");
-        v.put("baseUrl", "http://gx00.gw:8000");
-        v.put("model", "sonnet");
-        v.put("configDir", "/config/a");
-        v.put("tokenEnv", "TOKEN_A");
-        v.put("argv", List.of("claude", "--flag-a"));
-        v.put("placement", "tab");
-        v.put("workspace", "workspace-a");
-        v.put("tabLabel", "label-a");
-        v.put("mcpUrl", "http://mcp-a");
-        v.put("cwd", "/cwd/a");
-        v.put("parityOverlay", List.of(".env", ".env.a"));
-        v.put("gitTokenEnv", "GIT_TOKEN_A");
-        v.put("gitHostEnv", "GITEA_HOST_A");
-        v.put("kind", "claude-code");
-        v.put("env", Map.of("K", "A"));
-        v.put("weight", 1.0f);
-        v.put("maxLoad", 5);
-        v.put("subscription", Boolean.TRUE);
-        v.put("exhaustedPattern", "usage limit a");
-        v.put("credentialId", "cred-a");
-        v.put("ideMcpUrl", "http://ide-mcp-a");
-        v.put("ideProjectDir", "modules/a");
-        v.put("ideOpenCommand", "open-cmd-a {dir}");
-        v.put("autoCompactWindow", 150000);
-        v.put("errorPattern", "error a");
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    private static Map<String, Object> altValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("profile", "sonnet-b");
-        v.put("baseUrl", "http://gx01.gw:8000");
-        v.put("model", "haiku");
-        v.put("configDir", "/config/b");
-        v.put("tokenEnv", "TOKEN_B");
-        v.put("argv", List.of("claude", "--flag-b"));
-        v.put("placement", "weighted");
-        v.put("workspace", "workspace-b");
-        v.put("tabLabel", "label-b");
-        v.put("mcpUrl", "http://mcp-b");
-        v.put("cwd", "/cwd/b");
-        v.put("parityOverlay", List.of(".env", ".env.b"));
-        v.put("gitTokenEnv", "GIT_TOKEN_B");
-        v.put("gitHostEnv", "GITEA_HOST_B");
-        v.put("kind", "opencode");
-        v.put("env", Map.of("K", "B"));
-        v.put("weight", 2.0f);
-        v.put("maxLoad", 9);
-        v.put("subscription", Boolean.FALSE);
-        v.put("exhaustedPattern", "usage limit b");
-        v.put("credentialId", "cred-b");
-        v.put("ideMcpUrl", "http://ide-mcp-b");
-        v.put("ideProjectDir", "modules/b");
-        v.put("ideOpenCommand", "open-cmd-b {dir}");
-        v.put("autoCompactWindow", 250000);
-        v.put("errorPattern", "error b");
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    private static void assertNamesMatchComponents(Map<String, Object> values) {
-        Set<String> componentNames = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            componentNames.add(rc.getName());
-        }
-        assertEquals(componentNames, new TreeSet<>(values.keySet()),
-                "this test's value map has drifted from FleetConfig.Profile's actual components — "
-                        + "update BASE/ALT alongside the record");
-    }
-
-    private static FleetConfig.Profile profileOf(Map<String, Object> values) throws ReflectiveOperationException {
-        Class<?>[] types = Arrays.stream(COMPONENTS).map(RecordComponent::getType).toArray(Class<?>[]::new);
-        Object[] args = Arrays.stream(COMPONENTS)
-                .map(rc -> values.get(rc.getName()))
-                .toArray();
-        Constructor<FleetConfig.Profile> ctor = FleetConfig.Profile.class.getDeclaredConstructor(types);
-        return ctor.newInstance(args);
-    }
-
-    /** {@code BASE} with exactly one named component swapped for its {@code ALT} value. */
-    private static FleetConfig.Profile mutate(String componentName) throws ReflectiveOperationException {
-        Map<String, Object> values = new LinkedHashMap<>(BASE);
-        values.put(componentName, ALT.get(componentName));
-        return profileOf(values);
-    }
-
-    /**
-     * The mechanism fleetd #323 asked for: enumerate {@link FleetConfig.Profile}'s record
-     * components, mutate each non-excluded one, and prove {@code sameLaunchSettings} actually
-     * notices — not just that some hand-maintained list claims it does. Prints the denominator
-     * (total / compared / excluded) the issue required: a checker that cannot state its own
-     * denominator is the failure this repo keeps hitting.
-     */
-    @Test
-    void sameLaunchSettingsComparesEveryProfileComponentOrExcludesIt() throws ReflectiveOperationException {
-        int total = COMPONENTS.length;
-        Set<String> excluded = ConfigRef.LAUNCH_SETTINGS_EXCLUDED;
-
-        Set<String> allNames = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            allNames.add(rc.getName());
-        }
-        assertTrue(allNames.containsAll(excluded),
-                "ConfigRef.LAUNCH_SETTINGS_EXCLUDED names a component that does not exist on "
-                        + "FleetConfig.Profile — check for a typo: " + excluded);
-
-        // The exclusion set is this mechanism's own escape hatch, so it has to be pinned too.
-        // Found by mutation while verifying fleetd #323: moving autoCompactWindow and
-        // ideOpenCommand OUT of the comparison and INTO the exclusion set left the whole suite
-        // green — the loop below simply skips them, and the denominator assertion still balances.
-        // That is exactly the lazy move a failing coverage test invites, and it silently restores
-        // the #323 bug. Only ideProjectDir and worktreeGroup were saved by a behavioural test in
-        // ConfigRefTest; the other two had none. So: growing this set now requires editing this
-        // line as well, which is a visible, deliberate diff rather than a quiet one.
-        assertEquals(Set.of("weight", "maxLoad", "credentialId"), excluded,
-                "ConfigRef.LAUNCH_SETTINGS_EXCLUDED changed. A component belongs in it ONLY if it "
-                        + "is read live off the config supplier, not baked into a launcher at "
-                        + "startup. If you are adding one to silence this test, that is fleetd #323 "
-                        + "happening again: compare it in sameLaunchSettings instead. If it really "
-                        + "is read live, name where it is read and update this assertion.");
-
-        FleetConfig.Profile base = profileOf(BASE);
-        List<String> uncovered = new java.util.ArrayList<>();
-        int compared = 0;
-        for (RecordComponent rc : COMPONENTS) {
-            String name = rc.getName();
-            if (excluded.contains(name)) {
-                continue;
-            }
-            FleetConfig.Profile mutated = mutate(name);
-            if (ConfigRef.sameLaunchSettings(base, mutated)) {
-                uncovered.add(name);
-            } else {
-                compared++;
-            }
-        }
-
-        System.out.printf(
-                "ConfigRef.sameLaunchSettings coverage — %d Profile components total, %d compared, "
-                        + "%d excluded (%s)%n",
-                total, compared, excluded.size(), excluded);
-
-        assertEquals(List.of(), uncovered,
-                "these FleetConfig.Profile components changed but ConfigRef.sameLaunchSettings "
-                        + "reported no difference — add each one to the comparison (it is read at "
-                        + "spawn and baked in until a restart) or to ConfigRef.LAUNCH_SETTINGS_EXCLUDED "
-                        + "with a reason it is genuinely read live: " + uncovered);
-        assertEquals(total, compared + excluded.size(),
-                "every FleetConfig.Profile record component must be either compared or excluded — "
-                        + total + " components, " + compared + " compared, " + excluded.size()
-                        + " excluded");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/ConfigRefTest.java

@@ -434,364 +434,6 @@ class ConfigRefTest {
         assertEquals("provider 5xx", ref.get().profiles().get("sonnet").errorPattern());
     }
 
-    /**
-     * fleetd #323 instance 1: {@code ideProjectDir} is read at spawn off the frozen profile map
-     * (see {@code ClaudeCodeLauncher}/{@code OpenCodeLauncher}) exactly like {@code model}, but was
-     * missing from {@code sameLaunchSettings} — a reload changing only this field used to report a
-     * bare "config reloaded" and the running daemon kept launching with the old value.
-     */
-    @Test
-    void changingAProfilesIdeProjectDirIsReportedAsDeferred(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                herdrSocket: ~/.config/herdr/herdr.sock
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet
-                    ideProjectDir: fleetd
-                guard:
-                  offSubscriptionHosts:
-                    - gx00.gw
-                """);
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                herdrSocket: ~/.config/herdr/herdr.sock
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet
-                    ideProjectDir: fleetd-renamed
-                guard:
-                  offSubscriptionHosts:
-                    - gx00.gw
-                """);
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(1, out.deferred().size(), out.deferred().toString());
-        assertTrue(out.deferred().getFirst().contains("sonnet"), out.deferred().toString());
-        assertTrue(out.deferred().getFirst().contains("launch settings"), out.deferred().toString());
-        // The snapshot still carries the new value — a restart is what makes it take effect.
-        assertEquals("fleetd-renamed", ref.get().profiles().get("sonnet").ideProjectDir());
-    }
-
-    /**
-     * fleetd #323 instance 2: {@code worktreeGroup} is baked into the same {@code GitWorktrees}
-     * as {@code worktreeRoot} (Fleetd.java:251) and never rebuilt, but only {@code worktreeRoot}
-     * was on {@code changedDeferredKeys} — a reload changing only the group reported a bare
-     * "config reloaded" and newly provisioned worktrees kept the old sharing behaviour.
-     */
-    @Test
-    void changingWorktreeGroupIsReportedAsDeferred(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("worktreeGroup: devgroup\n"));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("worktreeGroup: devgroup2\n"));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(java.util.List.of("worktreeGroup"), out.deferred());
-        assertTrue(out.summary().contains("needs a restart") || out.summary().contains("need a restart"),
-                out.summary());
-        // The snapshot still carries the new value — a restart is what makes it take effect.
-        assertEquals("devgroup2", ref.get().worktreeGroup());
-    }
-
-    /**
-     * fleetd #326: {@code primary} is read only off the startup snapshot — {@code Fleetd.java:506,
-     * 519, 520} feed {@code PrimaryRegistry} and {@code ReplyPushLoop} at construction and neither is
-     * rebuilt on reload — but it was missing from {@link ConfigRef#changedDeferredKeys}, so a reload
-     * that only changed the pinned primary terminal reported a bare "config reloaded" while a lead
-     * whose tab no longer matched stayed demoted to worker.
-     */
-    @Test
-    void changingPrimaryIsReportedAsDeferred(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                primary:
-                  terminal: term-a
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                primary:
-                  terminal: term-b
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(java.util.List.of("primary"), out.deferred());
-        assertTrue(out.summary().contains("need") && out.summary().contains("restart"), out.summary());
-        // The snapshot still carries the new value — a restart is what makes it take effect.
-        assertEquals("term-b", ref.get().primary().terminal());
-    }
-
-    /**
-     * fleetd #326: {@code configReload} itself is read only at startup ({@code Fleetd.java:679-680})
-     * to decide whether to build a {@code ConfigWatcher} at all, and with what interval — the watcher
-     * that would apply a later change is itself built once, so it is deferred rather than cold (see
-     * {@link ConfigRef}'s class doc: cold means an already-open resource would go inconsistent with
-     * the new value, and there is no such resource here — a running watcher just keeps polling on its
-     * original enabled/interval until a restart, exactly like {@code lifecycle} or {@code guard}).
-     * Before this fix, turning reload off (or changing its interval) through a reload reported a bare
-     * "config reloaded" — the obvious joke the issue names.
-     */
-    @Test
-    void changingConfigReloadIsReportedAsDeferred(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                configReload:
-                  enabled: true
-                  intervalSeconds: 10
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                configReload:
-                  enabled: false
-                  intervalSeconds: 30
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(java.util.List.of("configReload"), out.deferred());
-        assertTrue(out.summary().contains("need") && out.summary().contains("restart"), out.summary());
-        // The snapshot still carries the new value — a restart is what makes it take effect.
-        assertFalse(ref.get().configReload().isEnabled());
-        assertEquals(30, ref.get().configReload().intervalSeconds());
-    }
-
-    /**
-     * fleetd #330: {@code health:} is read both ways — {@code Fleetd.java:556-563} builds the
-     * monitor off the startup snapshot and never rebuilds it, but {@code Fleetd.java:648-650} reads
-     * {@code config.get().health()} live on every {@code fleet_profiles} call. A changed value is
-     * neither purely hot nor purely deferred, so it gets its own {@code split} report naming both
-     * halves rather than a bare "config reloaded" (which would hide the frozen half) or a plain
-     * {@code deferred} entry (which would hide that the coverage string already applied).
-     */
-    @Test
-    void changingHealthIsReportedAsSplit(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                health:
-                  enabled: true
-                  intervalSeconds: 30
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                health:
-                  enabled: true
-                  intervalSeconds: 90
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertTrue(out.deferred().isEmpty(), out.deferred().toString());
-        assertEquals(1, out.split().size(), out.split().toString());
-        assertTrue(out.split().getFirst().startsWith("health:"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("restart"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("live"), out.split().toString());
-        assertTrue(out.summary().contains("partially live"), out.summary());
-        // The snapshot still carries the new value — the monitor itself is what waits for a restart.
-        assertEquals(90, ref.get().health().intervalSeconds());
-    }
-
-    /**
-     * fleetd #330: {@code coordinator:} is the other split key — {@code Fleetd.java:502} opens the
-     * {@code LeadMailbox} off the startup snapshot and never reopens it, but
-     * {@code HerdrPeerLauncher.java:1530} reads {@code config.get().coordinator()} live on every
-     * spawn to keep the broker URI env-var name out of a member's environment.
-     */
-    @Test
-    void changingCoordinatorIsReportedAsSplit(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                coordinator:
-                  selfId: mac-a
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                coordinator:
-                  selfId: mac-b
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertTrue(out.deferred().isEmpty(), out.deferred().toString());
-        assertEquals(1, out.split().size(), out.split().toString());
-        assertTrue(out.split().getFirst().startsWith("coordinator:"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("restart"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("live"), out.split().toString());
-        // The snapshot still carries the new value — the LeadMailbox connection is what waits for a
-        // restart; selfId names this daemon's own inbox queue and a peer cannot discover a rename.
-        assertEquals("mac-b", ref.get().coordinator().selfId());
-    }
-
-    /**
-     * fleetd #333: {@code fleet:} is split too — {@code fleet.leaders} is read only at
-     * {@code Fleetd.java:281} to build the {@code LeadTabScanner}'s identity map (fed into
-     * {@code CallerResolver}) and to auto-launch leads via {@code LeadLauncher.ensureLeads()}, and
-     * neither is rebuilt on reload, while the rest of {@code fleet:} (role pools, charters,
-     * tabLabel) is read live through the {@code CompositePeerLauncher} supplier. Before this fix
-     * {@code fleet} sat in the coverage checker's hot-excluded escape hatch, so a reload that
-     * changed only {@code fleet.leaders} reported a bare "config reloaded" — exactly the
-     * under-claim the split class exists to prevent for {@code health}/{@code coordinator}.
-     */
-    @Test
-    void changingFleetLeadersIsReportedAsSplit(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                fleet:
-                  leaders:
-                    opus:
-                      tab: "lead: opus-a"
-                      profile: sonnet
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                fleet:
-                  leaders:
-                    opus:
-                      tab: "lead: opus-b"
-                      profile: sonnet
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertTrue(out.deferred().isEmpty(), out.deferred().toString());
-        assertEquals(1, out.split().size(), out.split().toString());
-        assertTrue(out.split().getFirst().startsWith("fleet:"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("restart"), out.split().toString());
-        assertTrue(out.split().getFirst().contains("live"), out.split().toString());
-        assertTrue(out.summary().contains("partially live"), out.summary());
-        // The snapshot still carries the new value — the LeadTabScanner's identity map and
-        // LeadLauncher's auto-launch are what wait for a restart; a reload rebuilds neither.
-        assertEquals("lead: opus-b", ref.get().fleet().leaders().get("opus").tab());
-    }
-
-    /**
-     * fleetd #333: {@code fleet.leaders} is the ONLY frozen part of {@code fleet:}. A reload that
-     * changes {@code tabLabel} (or charters, or a role pool) without touching {@code fleet.leaders}
-     * must stay fully hot with nothing reported — proving {@link ConfigRef#changedSplitKeys}
-     * compares {@code fleet.leaders} specifically rather than the whole {@code Fleet} record, which
-     * would over-claim "needs a restart" for a change that is genuinely all live (the mirror
-     * mistake of the under-claim this class exists to prevent).
-     */
-    @Test
-    void changingFleetTabLabelWithoutLeadersStaysFullyHot(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                fleet:
-                  tabLabel: "{role}: {profile} #{n}"
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                fleet:
-                  tabLabel: "[{profile}] {role}"
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertTrue(out.deferred().isEmpty(), out.deferred().toString());
-        assertTrue(out.split().isEmpty(), out.split().toString());
-        assertEquals("config reloaded", out.summary());
-        assertEquals("[{profile}] {role}", ref.get().fleet().tabLabel());
-    }
-
-    /**
-     * A split change must not refuse the reload (invariant 2 of fleetd #330) and
-     * {@code Outcome.applied()} must stay {@code true} (invariant 3) — unlike a cold change, the
-     * live half of a split key genuinely took effect, so refusing would throw that away.
-     */
-    @Test
-    void aSplitChangeDoesNotRefuseTheReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("coordinator:\n  selfId: mac-a\n"));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("coordinator:\n  selfId: mac-b\n"));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertTrue(out.error() == null);
-        assertTrue(out.coldKeys().isEmpty());
-    }
-
-    /**
-     * Both split keys can change in one reload — the report names both, and a caller reading
-     * {@code split} does not have to guess which half of which key already applied.
-     */
-    @Test
-    void changingBothSplitKeysReportsBoth(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                health:
-                  enabled: true
-                coordinator:
-                  selfId: mac-a
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                health:
-                  enabled: false
-                coordinator:
-                  selfId: mac-b
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(2, out.split().size(), out.split().toString());
-        assertTrue(out.split().stream().anyMatch(s -> s.startsWith("health:")), out.split().toString());
-        assertTrue(out.split().stream().anyMatch(s -> s.startsWith("coordinator:")), out.split().toString());
-    }
-
-    /**
-     * A split key and a deferred key changing in the same reload must both show up, each in its own
-     * list — proving the two fields do not step on each other and {@link ConfigRef.Outcome#summary()}
-     * reports both halves of the message.
-     */
-    @Test
-    void aSplitChangeAndADeferredChangeCoexist(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yaml("""
-                coordinator:
-                  selfId: mac-a
-                lifecycle:
-                  drainTimeoutSeconds: 30
-                """));
-        ConfigRef ref = refFor(f);
-
-        Files.writeString(f, yaml("""
-                coordinator:
-                  selfId: mac-b
-                lifecycle:
-                  drainTimeoutSeconds: 60
-                """));
-        ConfigRef.Outcome out = ref.reload();
-
-        assertTrue(out.applied());
-        assertEquals(java.util.List.of("lifecycle"), out.deferred());
-        assertEquals(1, out.split().size(), out.split().toString());
-        assertTrue(out.split().getFirst().startsWith("coordinator:"), out.split().toString());
-        assertTrue(out.summary().contains("need a restart") || out.summary().contains("needs a restart"),
-                out.summary());
-        assertTrue(out.summary().contains("partially live"), out.summary());
-    }
-
     @Test
     void aFixedRefHasNoFileAndRefusesToReload() {
         FleetConfig cfg = new FleetConfig(null, null, null, null, null, null,

fleetd/src/test/java/dev/ltms/fleet/config/ConfigRefTopLevelCoverageTest.java

@@ -1,179 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-
-import java.lang.reflect.RecordComponent;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #330: a new top-level {@link FleetConfig} record component must be triaged into a reload
- * class before it ships, or it repeats fleetd #323 ({@code worktreeGroup} missing from {@code
- * ConfigRef.changedDeferredKeys}) and fleetd #326 ({@code primary}/{@code configReload} missing the
- * same way) — a key silently absent from {@link ConfigRef}'s reload machinery, so a reload changing
- * only that key reports a bare "config reloaded" for a change the running daemon never picked up.
- *
- * <p>This is the top-level counterpart of {@link ConfigRefProfileCoverageTest}: instead of
- * enumerating {@link FleetConfig.Profile}'s record components, it enumerates {@link FleetConfig}'s
- * own — {@code bind}, {@code health}, {@code memberCredentials}, and so on — and requires each to
- * fall into exactly one of four homes: {@link ConfigRef#COLD_KEYS}, {@link #DEFERRED_TOP_LEVEL_KEYS}
- * (compared in {@code ConfigRef.changedDeferredKeys}), {@link ConfigRef#SPLIT_KEYS}, or
- * {@link #HOT_EXCLUDED_TOP_LEVEL_KEYS} (the escape hatch: read live off the config supplier, so no
- * reload bookkeeping is needed for it at all).
- *
- * <h2>What this checker can and cannot prove</h2>
- * It proves the record's <em>shape</em> is fully triaged: every one of {@code FleetConfig}'s
- * components sits in exactly one of the four sets, none sits in two, and the escape hatch
- * ({@link #HOT_EXCLUDED_TOP_LEVEL_KEYS}) cannot silently grow without a visible diff to this file.
- * That is what "a new component cannot be added without someone triaging it" means in practice.
- *
- * <p>It CANNOT prove that any of the citations are <em>true</em>. "Compared in {@code
- * changedDeferredKeys}" and "read live off {@code config.get()}" are facts about {@code
- * ConfigRef.java}, {@code Fleetd.java} and {@code HerdrPeerLauncher.java} that a reflection-only
- * test over {@code FleetConfig}'s shape has no way to inspect — this test would pass identically
- * whether or not the cited line still does what the comment next to it says. Trust the citation
- * because a person read the source (the exact call sites are named next to each set below), not
- * because this test is green. {@link ConfigRefTest} is what behaviourally proves the deferred and
- * split keys it covers actually get reported; {@link ConfigRefProfileCoverageTest} does the same,
- * behaviourally, for {@code FleetConfig.Profile}'s own fields.
- */
-class ConfigRefTopLevelCoverageTest {
-
-    private static final RecordComponent[] COMPONENTS = FleetConfig.class.getRecordComponents();
-
-    /**
-     * Top-level components whose change {@code ConfigRef.changedDeferredKeys} reads and reports on.
-     * Fleetd #337 promoted this out of a hand-maintained copy here into {@link ConfigRef#DEFERRED_KEYS}
-     * itself, the same reason {@link ConfigRef#COLD_KEYS} and {@link ConfigRef#SPLIT_KEYS} are
-     * production constants rather than test-side copies: two lists that are supposed to describe the
-     * same method are exactly the shape that silently drifts apart. {@code spawnReadyTimeoutMs}/
-     * {@code spawnReadyPollMs} are compared together and reported under one combined label
-     * ({@code "spawnReady*"}); {@code profiles} is compared twice over — once for added/removed
-     * profile names, once for an existing profile's launch settings — and that second comparison
-     * excludes {@code weight}/{@code maxLoad}/{@code credentialId} as hot sub-fields, which is what
-     * {@link ConfigRefProfileCoverageTest} exists to keep honest at the sub-field level. {@code
-     * profiles} itself still belongs here, not in the hot-exclusion set below: most of a profile's
-     * fields are NOT read live, so citing "read live off the config supplier" for the whole
-     * top-level key would be false.
-     */
-    private static final Set<String> DEFERRED_TOP_LEVEL_KEYS = ConfigRef.DEFERRED_KEYS;
-
-    /**
-     * The escape hatch: top-level components with no reload bookkeeping at all, because every read
-     * of them goes live through {@link ConfigRef#get()} rather than off a startup snapshot. A
-     * component belongs here ONLY if that is true — never because adding it here makes this test
-     * pass. fleetd #323 is the cautionary tale for exactly this pattern: the identical hatch on
-     * {@code ConfigRef.LAUNCH_SETTINGS_EXCLUDED} let two profile fields be silently re-broken with
-     * the whole suite green, and it was only caught by mutating the checker itself (see this class's
-     * own mutation test below, and {@code ConfigRefProfileCoverageTest}'s equivalent).
-     *
-     * <ul>
-     *   <li>{@code placement} — read live by the placement policy on every spawn (class doc, Hot
-     *       bullet; {@code ConfigRefTest.aConsumerHoldingTheRefSeesTheNewValue} proves it
-     *       behaviourally).</li>
-     *   <li>{@code memberCredentials} — read live at {@code Fleetd.java:198, 205, 729}.</li>
-     *   <li>{@code memberLoginShell} — read live at
-     *       {@code HerdrPeerLauncher#configuredMemberLoginShell}.</li>
-     *   <li>{@code models} (fleetd #422) — membership is re-validated in full against the fresh
-     *       config on every {@code ConfigRef.reload()} (via {@code FleetConfig#validateAll()}), so
-     *       a bad edit is refused, never cached stale; the on/off half is read live by {@code
-     *       CompositePeerLauncher.enforceModelEnabled} and its candidate filter, and by {@code
-     *       fleet_profiles}/{@code GET /profiles} through {@code PeerLauncher.disabledModels()}.
-     *       Unlike {@code fleet} below, nothing about {@code models} is baked into a startup-built
-     *       object anywhere — there is no frozen half, so it belongs here whole rather than in
-     *       {@code SPLIT_KEYS}.</li>
-     * </ul>
-     *
-     * <p>{@code fleet} used to sit here too, on the strength of most of it (role pools, charters,
-     * tabLabel) being read the same live way — but {@code fleet.leaders} inside the same key is
-     * read only at startup and genuinely needs a restart, which is a real gap this escape hatch
-     * cannot represent: it excuses a whole top-level key from reload bookkeeping, and {@code fleet}
-     * needed exactly half of it excused. fleetd #333 moved it into {@link ConfigRef#SPLIT_KEYS}
-     * instead, where {@code changedSplitKeys} reports the frozen half by name. That is the
-     * cautionary tale this test's own javadoc already told: this checker proves the record's shape
-     * is triaged, never that a bucket a key sits in is the right one — a person has to read the
-     * source, which is exactly how fleetd #333 found {@code fleet} sitting in the wrong bucket
-     * while this test stayed green throughout.</p>
-     */
-    private static final Set<String> HOT_EXCLUDED_TOP_LEVEL_KEYS =
-            Set.of("placement", "memberCredentials", "memberLoginShell", "models");
-
-    @Test
-    void everyTopLevelComponentIsAccountedForInExactlyOneClass() {
-        Set<String> allNames = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            allNames.add(rc.getName());
-        }
-
-        Set<String> cold = ConfigRef.COLD_KEYS;
-        Set<String> split = ConfigRef.SPLIT_KEYS;
-        Set<String> deferred = DEFERRED_TOP_LEVEL_KEYS;
-        Set<String> hot = HOT_EXCLUDED_TOP_LEVEL_KEYS;
-
-        // Typo guard on each set — the same check ConfigRefProfileCoverageTest runs on
-        // LAUNCH_SETTINGS_EXCLUDED. A name that does not exist on FleetConfig is a silent no-op.
-        assertTrue(allNames.containsAll(cold),
-                "ConfigRef.COLD_KEYS names a component that does not exist on FleetConfig: " + cold);
-        assertTrue(allNames.containsAll(split),
-                "ConfigRef.SPLIT_KEYS names a component that does not exist on FleetConfig: " + split);
-        assertTrue(allNames.containsAll(deferred),
-                "DEFERRED_TOP_LEVEL_KEYS names a component that does not exist on FleetConfig: " + deferred);
-        assertTrue(allNames.containsAll(hot),
-                "HOT_EXCLUDED_TOP_LEVEL_KEYS names a component that does not exist on FleetConfig: " + hot);
-
-        // The escape hatch is pinned. Growing it requires editing this line — a visible, deliberate
-        // diff, not a quiet one. See the field javadoc above for what "belongs here" actually means.
-        assertEquals(Set.of("placement", "memberCredentials", "memberLoginShell", "models"), hot,
-                "HOT_EXCLUDED_TOP_LEVEL_KEYS changed. A component belongs here ONLY if it is read "
-                        + "live off the config supplier, never because adding it makes this test "
-                        + "pass. If you are adding one to silence this test, that is fleetd #323 "
-                        + "happening again: account for it in ConfigRef.changedDeferredKeys (or "
-                        + "COLD_KEYS/SPLIT_KEYS) instead. If it really is read live, name where and "
-                        + "update this assertion and the field javadoc together.");
-
-        // No component may sit in two buckets at once — the denominator check below could not catch
-        // that on its own (two buckets double-booking one key still sums to the right total if
-        // another key is simultaneously missing), so check every pair directly and name the culprit.
-        record Bucket(String name, Set<String> keys) {}
-        List<Bucket> buckets = List.of(
-                new Bucket("COLD_KEYS", cold), new Bucket("SPLIT_KEYS", split),
-                new Bucket("DEFERRED_TOP_LEVEL_KEYS", deferred), new Bucket("HOT_EXCLUDED_TOP_LEVEL_KEYS", hot));
-        for (int i = 0; i < buckets.size(); i++) {
-            for (int j = i + 1; j < buckets.size(); j++) {
-                Set<String> overlap = new LinkedHashSet<>(buckets.get(i).keys());
-                overlap.retainAll(buckets.get(j).keys());
-                assertEquals(Set.of(), overlap, "a component is in both " + buckets.get(i).name()
-                        + " and " + buckets.get(j).name() + ": " + overlap);
-            }
-        }
-
-        Set<String> union = new TreeSet<>();
-        union.addAll(cold);
-        union.addAll(split);
-        union.addAll(deferred);
-        union.addAll(hot);
-
-        System.out.printf(
-                "FleetConfig top-level coverage — %d components total: %d cold %s, %d deferred %s, "
-                        + "%d split %s, %d hot-excluded %s%n",
-                allNames.size(), cold.size(), cold, deferred.size(), deferred, split.size(), split,
-                hot.size(), hot);
-
-        Set<String> missing = new TreeSet<>(allNames);
-        missing.removeAll(union);
-        assertEquals(Set.of(), missing,
-                "these FleetConfig components are in none of COLD_KEYS, DEFERRED_TOP_LEVEL_KEYS, "
-                        + "SPLIT_KEYS or HOT_EXCLUDED_TOP_LEVEL_KEYS — triage each one into whichever "
-                        + "actually describes it: " + missing);
-        assertEquals(allNames.size(), cold.size() + deferred.size() + split.size() + hot.size(),
-                "counts don't sum to the component total even though every component was found in "
-                        + "the union — " + allNames.size() + " components, " + cold.size()
-                        + " cold + " + deferred.size() + " deferred + " + split.size() + " split + "
-                        + hot.size() + " hot-excluded");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/ConfigRefTopLevelReportingCoverageTest.java

@@ -1,292 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.RecordComponent;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * fleetd #333, finding F2: {@link ConfigRefTopLevelCoverageTest} proves every {@link FleetConfig}
- * top-level component sits in exactly one of {@link ConfigRef#COLD_KEYS}, {@link
- * ConfigRef#DEFERRED_KEYS}, {@link ConfigRef#SPLIT_KEYS} or the hot-excluded set. It does
- * <strong>not</strong> prove that a key's membership in one of the first three sets corresponds to
- * any actual comparison in {@link ConfigRef}: a key can sit in a set with no branch in {@code
- * changedColdKeys}/{@code changedSplitKeys}/{@code changedDeferredKeys} checking it, and both
- * {@link ConfigRefTopLevelCoverageTest} and the "kept in step" {@code assert} inside the first two
- * of those methods stay green, because neither one reads the method body — the coverage test only
- * reads set membership, and the assert only checks that reported entries are a SUBSET of the set,
- * never that every set member produced a reported entry. {@code changedDeferredKeys} does not even
- * have a "kept in step" assert of its own.
- *
- * <p>Measured directly, live, while fixing fleetd #333: dropping the {@code coordinator} branch out
- * of {@code ConfigRef.changedSplitKeys} while leaving {@code "coordinator"} in
- * {@link ConfigRef#SPLIT_KEYS} left {@link ConfigRefTopLevelCoverageTest} and the in-method assert
- * both green — only a hand-written behavioural case in {@link ConfigRefTest} caught it, because it
- * happened to name that exact key. This is the {@link ConfigRefProfileCoverageTest} mechanism one
- * level up, generalised over every {@code COLD_KEYS}/{@code SPLIT_KEYS}/{@code DEFERRED_KEYS}
- * member rather than one hand-picked field: enumerate {@link FleetConfig}'s own record components by
- * reflection, build "a config where only {@code <key>} differs" for each key, and call the real
- * {@link ConfigRef#changedColdKeys}/{@link ConfigRef#changedSplitKeys}/
- * {@link ConfigRef#changedDeferredKeys} methods (all package-private for exactly this, the same
- * reason {@link ConfigRef#sameLaunchSettings} already is) to prove each one is actually reported —
- * not assumed from a set literal.
- *
- * <h2>fleetd #337 — DEFERRED_KEYS was the gap left open here</h2>
- * This class originally covered {@code COLD_KEYS} and {@code SPLIT_KEYS} only — {@code
- * DEFERRED_TOP_LEVEL_KEYS} (now {@link ConfigRef#DEFERRED_KEYS}) carried the identical one-way risk
- * in principle, unexercised. fleetd #337 measured the real consequence rather than assuming it from
- * the shape of the gap: dropping {@code guard}'s comparison out of {@code changedDeferredKeys} while
- * {@code "guard"} stayed in the set left all 1355 tests green — the same failure mode {@code
- * coordinator} demonstrated for {@code SPLIT_KEYS} in fleetd #333, now confirmed for {@code
- * DEFERRED_KEYS} too. Re-deriving the full list by mutation (drop each key's branch in turn, run the
- * suite, restore) found six of the eleven {@code DEFERRED_KEYS} members with no behavioural test in
- * {@link ConfigRefTest} naming them: {@code guard}, {@code leadHeartbeat}, {@code worktreeRoot},
- * {@code spawnReadyTimeoutMs}, {@code spawnReadyPollMs} and {@code quarantineCooldownSeconds}. That
- * list corrects fleetd #333's own guess at it in two ways the mutation proved and a reading did not:
- * {@code lifecycle} is NOT on it — {@code ConfigRefTest.aDeferredChangeIsAppliedAndReported} already
- * names it, and dropping its branch fails that test — and {@code worktreeRoot} IS on it, which #333
- * never named at all. The other five {@code DEFERRED_KEYS} members ({@code lifecycle}, {@code
- * worktreeGroup}, {@code primary}, {@code configReload}, {@code profiles}) already had a hand-written
- * case each. {@link #everyDeferredKeyIsActuallyReportedByChangedDeferredKeys} below now covers all
- * eleven the reflective way, so the six with no hand-written test are no longer silently unpinned —
- * every {@code DEFERRED_KEYS} component turned out to be a scalar or a simple record, so, unlike
- * {@code fleet.leaders} in fleetd #333, none needed an exclusion set: {@link #BASE}/{@link #ALT} give
- * every top-level component (not only {@code COLD_KEYS}/{@code SPLIT_KEYS}) a real, distinct value.
- */
-class ConfigRefTopLevelReportingCoverageTest {
-
-    private static final RecordComponent[] COMPONENTS = FleetConfig.class.getRecordComponents();
-
-    /**
-     * One valid value per top-level {@link FleetConfig} component — "the a value". fleetd #337 gave
-     * every {@code DEFERRED_KEYS} component a real value here too (previously left {@code null} on
-     * both sides, which meant {@code mutate(key)} produced no actual difference for any of them);
-     * only {@code placement}, {@code memberCredentials} and {@code memberLoginShell} — the
-     * hot-excluded set, never compared by any {@code changed*Keys} method — stay {@code null}.
-     * {@link FleetConfig}'s compact constructor only normalizes {@code profiles}, so every other
-     * field accepts whatever is put here unmutated.
-     */
-    private static final Map<String, Object> BASE = baseValues();
-
-    /** The same shape, each value distinct from {@link #BASE} — "the b value". */
-    private static final Map<String, Object> ALT = altValues();
-
-    private static Map<String, Object> baseValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("bind", new FleetConfig.Bind("127.0.0.1", 8765));
-        v.put("herdrSocket", "~/.config/herdr/a.sock");
-        v.put("memberHerdrSocket", "~/.config/herdr/member-a.sock");
-        v.put("profiles", Map.of());
-        v.put("guard", new FleetConfig.Guard(List.of("host-a")));
-        v.put("worktreeRoot", "/wt/a");
-        v.put("lifecycle", new FleetConfig.Lifecycle(300, 5, 30, false));
-        v.put("spawnReadyTimeoutMs", 5000);
-        v.put("spawnReadyPollMs", 100);
-        v.put("broker", new FleetConfig.Broker("amqp://a", null, 1));
-        v.put("primary", new FleetConfig.Primary("term-a", 1, 1000));
-        v.put("fleet", new FleetConfig.Fleet(
-                Map.of("opus", new FleetConfig.Leader("sonnet", "lead: opus-a", 1, null, 10,
-                        "claude", null, null, null)),
-                Map.of(), Map.of(), Map.of(), Map.of(), "{role}: {profile} #{n}"));
-        v.put("leadHeartbeat", new FleetConfig.LeadHeartbeat(300, 60_000L, 3));
-        v.put("health", new FleetConfig.Health(true, 30, 600, null, null));
-        v.put("placement", null);
-        v.put("auth", new FleetConfig.Auth("loopback-trust", null));
-        v.put("configReload", new FleetConfig.ConfigReload(true, 10));
-        v.put("quarantineCooldownSeconds", 1800);
-        v.put("memberCredentials", null);
-        v.put("coordinator", new FleetConfig.Coordinator("amqp://coord-a", null, "self-a", 1, null));
-        v.put("worktreeGroup", "group-a");
-        v.put("memberLoginShell", null);
-        v.put("memberSkills", "/skills/a");
-        v.put("idleSleepGuard", new FleetConfig.IdleSleepGuard(true));
-        v.put("models", new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("model-a"))));
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    private static Map<String, Object> altValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("bind", new FleetConfig.Bind("127.0.0.2", 8766));
-        v.put("herdrSocket", "~/.config/herdr/b.sock");
-        v.put("memberHerdrSocket", "~/.config/herdr/member-b.sock");
-        // A single added profile — enough to trip the "added/removed" comparison in
-        // ConfigRef.changedDeferredKeys, which is all this mechanism needs to prove "profiles" has
-        // a branch behind it; the launch-settings comparison already has its own hand-written cases
-        // in ConfigRefTest (changingAProfilesLaunchSettingsIsReportedAsDeferred and siblings).
-        v.put("profiles", Map.of("sonnet", minimalProfile("sonnet")));
-        v.put("guard", new FleetConfig.Guard(List.of("host-b")));
-        v.put("worktreeRoot", "/wt/b");
-        v.put("lifecycle", new FleetConfig.Lifecycle(600, 10, 60, true));
-        v.put("spawnReadyTimeoutMs", 10_000);
-        v.put("spawnReadyPollMs", 200);
-        v.put("broker", new FleetConfig.Broker("amqp://b", null, 2));
-        v.put("primary", new FleetConfig.Primary("term-b", 2, 2000));
-        // Differs from BASE.fleet only in fleet.leaders (a different tab for "opus") — the frozen
-        // sub-field ConfigRef.changedSplitKeys actually compares. A Fleet that instead differed only
-        // in tabLabel would correctly NOT be reported (see
-        // ConfigRefTest.changingFleetTabLabelWithoutLeadersStaysFullyHot) and would wrongly fail this
-        // test — that is by design, not a gap: this map exists to prove fleet.leaders is covered.
-        v.put("fleet", new FleetConfig.Fleet(
-                Map.of("opus", new FleetConfig.Leader("sonnet", "lead: opus-b", 1, null, 10,
-                        "claude", null, null, null)),
-                Map.of(), Map.of(), Map.of(), Map.of(), "{role}: {profile} #{n}"));
-        v.put("leadHeartbeat", new FleetConfig.LeadHeartbeat(600, 120_000L, 5));
-        v.put("health", new FleetConfig.Health(false, 90, 900, null, null));
-        v.put("placement", null);
-        v.put("auth", new FleetConfig.Auth("token", "TOKEN_ENV"));
-        v.put("configReload", new FleetConfig.ConfigReload(false, 20));
-        v.put("quarantineCooldownSeconds", 3600);
-        v.put("memberCredentials", null);
-        v.put("coordinator", new FleetConfig.Coordinator("amqp://coord-b", null, "self-b", 2, null));
-        v.put("worktreeGroup", "group-b");
-        v.put("memberLoginShell", null);
-        v.put("memberSkills", "/skills/b");
-        v.put("idleSleepGuard", new FleetConfig.IdleSleepGuard(false));
-        v.put("models", new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("model-b"))));
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    /** A minimal, otherwise-null {@link FleetConfig.Profile} — just enough to name one in a map. */
-    private static FleetConfig.Profile minimalProfile(String name) {
-        return new FleetConfig.Profile(name, null, null, null, null, null, null, null, null, null,
-                null, null, null, null, null, null, null, null, null, null, null, null, null, null,
-                null, null);
-    }
-
-    private static void assertNamesMatchComponents(Map<String, Object> values) {
-        Set<String> names = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            names.add(rc.getName());
-        }
-        assertEquals(names, new TreeSet<>(values.keySet()),
-                "this test's value map has drifted from FleetConfig's actual top-level components — "
-                        + "update BASE/ALT alongside the record");
-    }
-
-    private static FleetConfig configOf(Map<String, Object> values) throws ReflectiveOperationException {
-        Class<?>[] types = Arrays.stream(COMPONENTS).map(RecordComponent::getType).toArray(Class<?>[]::new);
-        Object[] args = Arrays.stream(COMPONENTS).map(rc -> values.get(rc.getName())).toArray();
-        Constructor<FleetConfig> ctor = FleetConfig.class.getDeclaredConstructor(types);
-        return ctor.newInstance(args);
-    }
-
-    /** {@code BASE} with exactly one named top-level component swapped for its {@code ALT} value. */
-    private static FleetConfig mutate(String componentName) throws ReflectiveOperationException {
-        Map<String, Object> values = new LinkedHashMap<>(BASE);
-        values.put(componentName, ALT.get(componentName));
-        return configOf(values);
-    }
-
-    /**
-     * The mechanism fleetd #333 F2 asked for, applied to {@link ConfigRef#COLD_KEYS}: mutate each
-     * cold key in isolation and prove {@code changedColdKeys} actually names it, not just that
-     * {@code COLD_KEYS} claims it does.
-     */
-    @Test
-    void everyColdKeyIsActuallyReportedByChangedColdKeys() throws ReflectiveOperationException {
-        FleetConfig base = configOf(BASE);
-        List<String> uncovered = new ArrayList<>();
-        for (String key : new TreeSet<>(ConfigRef.COLD_KEYS)) {
-            FleetConfig mutated = mutate(key);
-            if (!ConfigRef.changedColdKeys(base, mutated).contains(key)) {
-                uncovered.add(key);
-            }
-        }
-        System.out.printf(
-                "ConfigRef.changedColdKeys reporting coverage — %d COLD_KEYS, %d verified%n",
-                ConfigRef.COLD_KEYS.size(), ConfigRef.COLD_KEYS.size() - uncovered.size());
-        assertEquals(List.of(), uncovered,
-                "these keys are in ConfigRef.COLD_KEYS but mutating them alone produces no matching "
-                        + "entry from changedColdKeys — a set entry with no comparison behind it: "
-                        + uncovered);
-    }
-
-    /**
-     * The same mechanism applied to {@link ConfigRef#SPLIT_KEYS}: mutate each split key in
-     * isolation and prove {@code changedSplitKeys} actually names it (message starting with
-     * {@code "<key>:"}), not just that {@code SPLIT_KEYS} claims it does. This is the exact check
-     * that would have failed fleetd #333's own reproduction — dropping the {@code coordinator}
-     * branch from {@code changedSplitKeys} while {@code "coordinator"} stayed in {@code SPLIT_KEYS}
-     * — see the mutation proof in the fleetd #333 PR description; the earlier checkers here (the
-     * shape test and the in-method assert) do not.
-     */
-    @Test
-    void everySplitKeyIsActuallyReportedByChangedSplitKeys() throws ReflectiveOperationException {
-        FleetConfig base = configOf(BASE);
-        List<String> uncovered = new ArrayList<>();
-        for (String key : new TreeSet<>(ConfigRef.SPLIT_KEYS)) {
-            FleetConfig mutated = mutate(key);
-            List<String> split = ConfigRef.changedSplitKeys(base, mutated);
-            if (split.stream().noneMatch(s -> s.startsWith(key + ":"))) {
-                uncovered.add(key);
-            }
-        }
-        System.out.printf(
-                "ConfigRef.changedSplitKeys reporting coverage — %d SPLIT_KEYS, %d verified%n",
-                ConfigRef.SPLIT_KEYS.size(), ConfigRef.SPLIT_KEYS.size() - uncovered.size());
-        assertEquals(List.of(), uncovered,
-                "these keys are in ConfigRef.SPLIT_KEYS but mutating them alone produces no matching "
-                        + "entry from changedSplitKeys — a set entry with no comparison behind it, "
-                        + "exactly the fleetd #333 F2 shape: " + uncovered);
-    }
-
-    /**
-     * For most {@link ConfigRef#DEFERRED_KEYS} members, {@code changedDeferredKeys} reports the key
-     * name verbatim — the default this map assumes. Two entries don't: {@code spawnReadyTimeoutMs}
-     * and {@code spawnReadyPollMs} are compared together in one branch and reported under the
-     * combined label {@code "spawnReady*"} (see {@link ConfigRef#changedDeferredKeys}). {@code
-     * profiles} keeps the default: mutating it here only exercises the added/removed comparison
-     * (see {@link #altValues}), which reports {@code "profiles (added/removed: …)"} — starts with
-     * {@code "profiles"}, same as the default would expect.
-     */
-    private static final Map<String, String> DEFERRED_REPORT_PREFIX = Map.of(
-            "spawnReadyTimeoutMs", "spawnReady*",
-            "spawnReadyPollMs", "spawnReady*");
-
-    /**
-     * fleetd #337: the same mechanism applied to {@link ConfigRef#DEFERRED_KEYS}, closing the gap
-     * this class's own javadoc left open since fleetd #333. Mutate each deferred key in isolation
-     * and prove {@code changedDeferredKeys} actually names it (message starting with the key's
-     * expected report prefix — see {@link #DEFERRED_REPORT_PREFIX}), not just that {@code
-     * DEFERRED_KEYS} claims it does. This is the exact check that fails for {@code guard} the way
-     * {@code coordinator} failed {@link #everySplitKeyIsActuallyReportedByChangedSplitKeys} in
-     * fleetd #333 — verified live: dropping {@code guard}'s branch from {@code changedDeferredKeys}
-     * while {@code "guard"} stayed in {@code DEFERRED_KEYS} left the whole 1355-test suite green,
-     * and this test is what now catches it (it fails naming {@code guard} with that mutation in
-     * place).
-     */
-    @Test
-    void everyDeferredKeyIsActuallyReportedByChangedDeferredKeys() throws ReflectiveOperationException {
-        FleetConfig base = configOf(BASE);
-        List<String> uncovered = new ArrayList<>();
-        for (String key : new TreeSet<>(ConfigRef.DEFERRED_KEYS)) {
-            FleetConfig mutated = mutate(key);
-            List<String> deferred = ConfigRef.changedDeferredKeys(base, mutated);
-            String prefix = DEFERRED_REPORT_PREFIX.getOrDefault(key, key);
-            if (deferred.stream().noneMatch(s -> s.startsWith(prefix))) {
-                uncovered.add(key);
-            }
-        }
-        System.out.printf(
-                "ConfigRef.changedDeferredKeys reporting coverage — %d DEFERRED_KEYS, %d verified%n",
-                ConfigRef.DEFERRED_KEYS.size(), ConfigRef.DEFERRED_KEYS.size() - uncovered.size());
-        assertEquals(List.of(), uncovered,
-                "these keys are in ConfigRef.DEFERRED_KEYS but mutating them alone produces no "
-                        + "matching entry from changedDeferredKeys — a set entry with no comparison "
-                        + "behind it, exactly the fleetd #333 F2 shape, confirmed here for "
-                        + "DEFERRED_KEYS by fleetd #337: " + uncovered);
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/FleetConfigProfileWithProfilePreservesEveryComponentTest.java

@@ -1,172 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.RecordComponent;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Fleetd #358, the same "defect factory" #357 guarded on {@code FleetConfig.withDefaults()}
- * (see {@code FleetConfigWithDefaultsPreservesEveryComponentTest}), reproduced here on
- * {@link FleetConfig.Profile}. {@code Profile} carries a long back-compat constructor ladder — 8
- * constructors, re-counted directly against the source rather than trusted from the ticket, at
- * arities 25, 24, 22, 20, 18, 15, 14 and 12, against a canonical arity of 26 — and exactly ONE
- * rebuild site, {@link FleetConfig.Profile#withProfile(String)}, whose own
- * {@code return new Profile(...)} call is written at a literal 26-arg count. Add a 27th component
- * and its established back-compat constructor at the old (26-arg) arity, and {@code withProfile}'s
- * own call becomes a legal match for that new overload — silently dropping the new component every
- * time a profile's name is defaulted from its {@code workers:} key.
- *
- * <p>Builds one {@link FleetConfig.Profile} through the TRUE canonical constructor — resolved by
- * the record's own component types via {@code getDeclaredConstructor}, never by argument count —
- * with a real, distinctive, non-null value in every component, calls {@link
- * FleetConfig.Profile#withProfile(String)}, and asserts every component except {@code profile}
- * itself survives unchanged, while {@code profile} comes back as the new name it was given.
- *
- * <p>Every value here is chosen so {@code Profile}'s own compact constructor (which normalizes
- * several components — defaults {@code argv}/{@code kind}/{@code placement}/{@code workspace}/
- * {@code gitHostEnv}, nulls a handful of blank-checked strings, clamps {@code weight}, coerces
- * {@code subscription}) leaves it unchanged: every String is non-blank and already in the shape the
- * compact constructor would otherwise coerce it to (e.g. {@code placement} is already lowercase),
- * and every collection is non-empty. That is what makes "must survive unchanged" a valid assertion
- * for every component below, the same reasoning {@code FleetConfigWithDefaultsPreservesEveryComponentTest}
- * documents for {@code withDefaults()}.
- *
- * <p>{@link #EXCLUDED_FROM_SURVIVAL_CHECK} is kept deliberately empty and size-pinned by
- * {@link #exclusionListSizeIsPinned()} — a checker whose escape hatch can grow to silence a failure
- * is not a checker. Every one of {@code Profile}'s 26 current components has a real, non-null,
- * non-blank value here and none is excluded.
- */
-class FleetConfigProfileWithProfilePreservesEveryComponentTest {
-
-    private static final RecordComponent[] COMPONENTS = FleetConfig.Profile.class.getRecordComponents();
-
-    /** Deliberately empty today; grow it only with a matching justification, and re-pin the size. */
-    private static final Set<String> EXCLUDED_FROM_SURVIVAL_CHECK = Set.of();
-
-    /** One real, distinctive, non-null value per component, chosen to survive the compact ctor. */
-    private static Map<String, Object> baseValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("profile", "profile-guard");
-        v.put("baseUrl", "https://guard.example/base");
-        v.put("model", "model-guard");
-        v.put("configDir", "/config/guard");
-        v.put("tokenEnv", "GUARD_TOKEN");
-        v.put("argv", List.of("guard-cmd"));
-        v.put("placement", "guard-placement");
-        v.put("workspace", "workspace-guard");
-        v.put("tabLabel", "tab-guard");
-        v.put("mcpUrl", "https://mcp.guard/");
-        v.put("cwd", "/cwd/guard");
-        v.put("parityOverlay", List.of(".guardrc"));
-        v.put("gitTokenEnv", "GUARD_GIT_TOKEN");
-        v.put("gitHostEnv", "GUARD_GIT_HOST");
-        v.put("kind", "claude-code");
-        v.put("env", Map.of("GUARD_ENV", "1"));
-        v.put("weight", 2.5f);
-        v.put("maxLoad", 4);
-        v.put("subscription", Boolean.TRUE);
-        v.put("exhaustedPattern", "pattern-guard");
-        v.put("credentialId", "cred-guard");
-        v.put("ideMcpUrl", "https://ide.guard/");
-        v.put("ideProjectDir", "ide-project-guard");
-        v.put("ideOpenCommand", "open-guard {dir}");
-        v.put("autoCompactWindow", 150_000);
-        v.put("errorPattern", "error-pattern-guard");
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    /**
-     * Guards {@link #baseValues()} itself against drifting from the record's real shape — forgetting
-     * to add a new component here fails this assertion by name, rather than silently checking one
-     * component fewer than the record has.
-     */
-    private static void assertNamesMatchComponents(Map<String, Object> values) {
-        Set<String> names = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            names.add(rc.getName());
-        }
-        assertEquals(names, new TreeSet<>(values.keySet()),
-                "this test's value map has drifted from FleetConfig.Profile's actual components — "
-                        + "update baseValues() alongside the record");
-    }
-
-    /**
-     * Builds a {@link FleetConfig.Profile} through the TRUE canonical constructor — resolved by the
-     * record's own component types, not by argument count — so this never accidentally exercises a
-     * back-compat overload the way a literal {@code new Profile(...)} call risks doing.
-     */
-    private static FleetConfig.Profile profileOf(Map<String, Object> values) throws ReflectiveOperationException {
-        Class<?>[] types = Arrays.stream(COMPONENTS).map(RecordComponent::getType).toArray(Class<?>[]::new);
-        Object[] args = Arrays.stream(COMPONENTS).map(rc -> values.get(rc.getName())).toArray();
-        Constructor<FleetConfig.Profile> ctor = FleetConfig.Profile.class.getDeclaredConstructor(types);
-        return ctor.newInstance(args);
-    }
-
-    @Test
-    void exclusionListSizeIsPinned() {
-        assertEquals(0, EXCLUDED_FROM_SURVIVAL_CHECK.size(),
-                "EXCLUDED_FROM_SURVIVAL_CHECK grew from 0 — every entry needs a justification in "
-                        + "this test class's javadoc AND this assertion re-pinned to the new size; a "
-                        + "growing exclusion list that silences failures on its own is not a guard");
-    }
-
-    /**
-     * The mutation this is built to catch: make {@code withProfile(String)}'s final constructor call
-     * literal at some arg count, add one more component to the record with a new back-compat
-     * constructor at the old arity, and the stale call silently rebinds. Every component here is real
-     * and non-null/non-blank, so none of it should be replaced by {@code withProfile}, except
-     * {@code profile} itself, which the method is documented to replace.
-     */
-    @Test
-    void withProfilePreservesEveryOtherComponent() throws ReflectiveOperationException {
-        Map<String, Object> base = baseValues();
-        FleetConfig.Profile profile = profileOf(base);
-        FleetConfig.Profile renamed = profile.withProfile("renamed-profile-guard");
-
-        List<String> dropped = new ArrayList<>();
-        int checked = 0;
-        for (RecordComponent rc : COMPONENTS) {
-            String name = rc.getName();
-            if (EXCLUDED_FROM_SURVIVAL_CHECK.contains(name)) {
-                continue;
-            }
-            checked++;
-            Object expected = "profile".equals(name) ? "renamed-profile-guard" : base.get(name);
-            Object actual;
-            try {
-                actual = rc.getAccessor().invoke(renamed);
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException("failed to read FleetConfig.Profile." + name + "()", e);
-            }
-            if (!Objects.equals(expected, actual)) {
-                dropped.add(String.format(Locale.ROOT,
-                        "%s: withProfile() was expected to carry (%s) for '%s' but returned %s — a "
-                                + "component silently dropped by withProfile(), the shape of the "
-                                + "defect this test exists to catch (its final \"return new "
-                                + "Profile(...)\" call binding to a back-compat constructor instead "
-                                + "of the true canonical one)",
-                        name, expected, name, actual));
-            }
-        }
-
-        System.out.printf(Locale.ROOT,
-                "FleetConfig.Profile.withProfile() component-survival coverage — %d components, %d "
-                        + "checked, %d excluded, %d survived%n",
-                COMPONENTS.length, checked, EXCLUDED_FROM_SURVIVAL_CHECK.size(), checked - dropped.size());
-        assertEquals(List.of(), dropped,
-                "withProfile() silently dropped these components: " + dropped);
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/FleetConfigTest.java

@@ -1189,7 +1189,7 @@ class FleetConfigTest {
     @Test
     void coordinatorEffectiveUriHonorsUriEnv() {
         FleetConfig.Coordinator withEnv = new FleetConfig.Coordinator(
-                "amqp://stale-clear-text@127.0.0.1:5672/coord", "LEAD_COORD_URI", "fleet01-lead", null, null);
+                "amqp://stale-clear-text@127.0.0.1:5672/coord", "LEAD_COORD_URI", "fleet01-lead", null);
 
         assertEquals("amqp://from-env@127.0.0.1:5672/coord",
                 withEnv.effectiveUri(Map.of("LEAD_COORD_URI", "amqp://from-env@127.0.0.1:5672/coord")),
@@ -1200,61 +1200,12 @@ class FleetConfigTest {
                 "a blank uriEnv variable must not fall back to the literal uri");
 
         FleetConfig.Coordinator noEnv = new FleetConfig.Coordinator(
-                "amqp://guest:guest@127.0.0.1:5672/coord", null, null, null, null);
+                "amqp://guest:guest@127.0.0.1:5672/coord", null, null, null);
         assertEquals("amqp://guest:guest@127.0.0.1:5672/coord", noEnv.effectiveUri(Map.of()),
                 "the literal uri is used when no uriEnv is configured");
         assertEquals(LeadMailbox.DEFAULT_PREFETCH, noEnv.prefetchOrDefault());
     }
 
-    /**
-     * fleetd #361: the live block ships as just {@code uriEnv} + {@code selfId} (see
-     * {@code Fleetd.example.yaml} / the operator's real {@code fleetd.yaml}, gitignored). That exact
-     * shape, with no {@code peers:} key at all, must keep parsing unchanged after this field is added.
-     */
-    @Test
-    void coordinatorBlockWithNoPeersKeyStillParses(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("coordinator-no-peers.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                coordinator:
-                  uriEnv: COORD_AMQP_URI
-                  selfId: mac
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertNotNull(cfg.coordinator());
-        assertEquals("mac", cfg.coordinator().selfId());
-        assertEquals(List.of(), cfg.coordinator().peers(), "no peers: key means no configured peers, never null");
-    }
-
-    @Test
-    void coordinatorPeersParsesAndDropsBlankEntries(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("coordinator-peers.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                coordinator:
-                  selfId: mac
-                  uri: amqp://guest:guest@127.0.0.1:5672/coord
-                  peers:
-                    - fleet01
-                    - ""
-                    - fleet02
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertEquals(List.of("fleet01", "fleet02"), cfg.coordinator().peers(),
-                "a blank peer entry must be dropped, never kept as an empty coord-id");
-    }
-
-    @Test
-    void coordinatorPeersDefaultsToEmptyWhenConstructedWithNull() {
-        FleetConfig.Coordinator c = new FleetConfig.Coordinator(
-                "amqp://guest:guest@127.0.0.1:5672/coord", null, "mac", null, null);
-        assertEquals(List.of(), c.peers(), "a null peers list must default to empty, never NPE downstream");
-    }
-
     @Test
     void absentWorktreeGroupLeavesItNull(@TempDir Path dir) throws Exception {
         Path f = dir.resolve("no-worktree-group.yaml");
@@ -2629,391 +2580,4 @@ class FleetConfigTest {
                 "with no pool to choose from, every configured profile is a candidate and the "
                         + "first one wins");
     }
-
-    // ── idle-sleep guard: default-on config block ───────────────────────────────────────────────
-
-    @Test
-    void idleSleepGuardIsOnByDefaultWhenTheBlockIsEntirelyAbsent(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  host: 127.0.0.1
-                  port: 8080
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertNull(cfg.idleSleepGuard(), "an absent block parses to null, unlike most other blocks here");
-        // The block itself is absent, but the FEATURE stays on: Fleetd treats a null block the
-        // same as enabled: true (see FleetConfig.idleSleepGuard's javadoc) — this test only pins
-        // the parse result, the on-by-default behaviour is Fleetd's own null check.
-    }
-
-    @Test
-    void idleSleepGuardExplicitlyEnabledIsOn(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                idleSleepGuard:
-                  enabled: true
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertTrue(cfg.idleSleepGuard().isEnabled());
-    }
-
-    @Test
-    void idleSleepGuardExplicitlyDisabledIsOff(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                idleSleepGuard:
-                  enabled: false
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertFalse(cfg.idleSleepGuard().isEnabled());
-    }
-
-    @Test
-    void idleSleepGuardBlockPresentButEmptyDefaultsToEnabled(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                idleSleepGuard: {}
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertTrue(cfg.idleSleepGuard().isEnabled(),
-                "unlike ConfigReload/Health, this block defaults to ON even when present but empty");
-    }
-
-    // --- models: central allow-list of usable models -----------------------------------------
-
-    /**
-     * An absent {@code models:} block is today's behaviour exactly: no profile's {@code model:} is
-     * checked against anything, whatever it says. This is the "existing config keeps working"
-     * invariant — an operator on a gitignored {@code fleetd.yaml} that predates this feature must
-     * not be broken by upgrading the daemon.
-     */
-    @Test
-    void absentModelsBlockValidatesNothing(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  gx10:
-                    baseUrl: http://gx10.gw:8000
-                    model: totally-unheard-of-model-xyz
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-    }
-
-    /**
-     * {@code models:} present but with an empty (or absent) {@code allow:} must behave exactly like
-     * the block being absent — an operator adding the block for the first time with nothing in it
-     * yet must not be surprised by every profile suddenly refusing to start.
-     */
-    @Test
-    void modelsBlockPresentButEmptyValidatesNothing(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  gx10:
-                    baseUrl: http://gx10.gw:8000
-                    model: whatever-the-operator-typed
-                models:
-                  allow: []
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-    }
-
-    /**
-     * The core of the ticket: a profile naming a model outside the configured allow-list fails
-     * config load, naming both the model and the profile that wanted it.
-     */
-    @Test
-    void aProfileNamingAModelOutsideTheAllowListRefusesToStart(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  rogue:
-                    baseUrl: http://gx11.gw:8000
-                    model: claude-opus-9000
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                    - model: claude-haiku-5
-                """);
-        FleetConfig cfg = FleetConfig.load(f);
-
-        IllegalStateException e = assertThrows(IllegalStateException.class, cfg::validateModels);
-        assertTrue(e.getMessage().contains("rogue"), "the refusal names the offending profile");
-        assertTrue(e.getMessage().contains("claude-opus-9000"), "the refusal names the offending model");
-        assertFalse(e.getMessage().contains("'sonnet'"),
-                "the profile whose model IS allowed must not be reported");
-    }
-
-    /** A profile whose {@code model:} is on the allow-list loads fine. */
-    @Test
-    void aProfileNamingAModelOnTheAllowListLoadsFine(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-    }
-
-    /**
-     * A profile that never sets {@code model:} (a {@code subscription: true} profile relying on the
-     * account's own default is the live example) must not be refused just because an allow-list is
-     * active — there is nothing to check it against.
-     */
-    @Test
-    void aProfileWithNoModelPassesEvenWithAnActiveAllowList(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  opus:
-                    subscription: true
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-    }
-
-    /**
-     * Reproduces the live config shape this ticket measured: a mix of {@code amazon-bedrock},
-     * {@code opencode} and {@code openai}-backed profiles, some naming a bare Claude id and some a
-     * provider-prefixed opencode id, in ONE allow-list. Both forms are just opaque strings compared
-     * for exact equality — proves the shape decision holds against the shape actually seen live,
-     * not just against a synthetic single-provider example.
-     */
-    @Test
-    void aBareClaudeIdAndAnOpencodeProviderPrefixedIdBothFitOneAllowList(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  terra:
-                    kind: opencode
-                    model: openai/gpt-5.6-terra
-                  nova:
-                    kind: opencode
-                    model: amazon-bedrock/amazon.nova-pro-v1:0
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                    - model: openai/gpt-5.6-terra
-                    - model: amazon-bedrock/amazon.nova-pro-v1:0
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-    }
-
-    /** The same live shape, but one opencode profile's model is missing from the allow-list. */
-    @Test
-    void anUnlistedOpencodeProviderPrefixedModelRefusesToStart(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  terra:
-                    kind: opencode
-                    model: openai/gpt-5.6-terra-withdrawn
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                    - model: openai/gpt-5.6-terra
-                """);
-        FleetConfig cfg = FleetConfig.load(f);
-
-        IllegalStateException e = assertThrows(IllegalStateException.class, cfg::validateModels);
-        assertTrue(e.getMessage().contains("terra"), "the refusal names the offending profile");
-        assertTrue(e.getMessage().contains("openai/gpt-5.6-terra-withdrawn"),
-                "the refusal names the offending model, with its provider prefix intact");
-    }
-
-    /**
-     * Editing a {@code profiles:} entry alone must never be able to widen what is permitted — only
-     * editing {@code models.allow:} itself can. This is the invariant the ticket states explicitly;
-     * this test pins it by giving a profile a plausible-looking model that was never added to the
-     * allow-list and confirming it is still refused.
-     */
-    @Test
-    void addingAProfileCannotWidenTheAllowListByItself(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  brand-new:
-                    baseUrl: http://gx12.gw:8000
-                    model: claude-sonnet-6-preview
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """);
-        FleetConfig cfg = FleetConfig.load(f);
-
-        IllegalStateException e = assertThrows(IllegalStateException.class, cfg::validateModels);
-        assertTrue(e.getMessage().contains("brand-new"));
-        assertTrue(e.getMessage().contains("claude-sonnet-6-preview"));
-    }
-
-    /** {@code models} is a brand-new top-level key and must be recognized, not WARN-ed as unknown. */
-    @Test
-    void modelsIsAKnownTopLevelKey() {
-        assertTrue(FleetConfig.KNOWN_TOP_LEVEL_KEYS.contains("models"));
-    }
-
-    // --- fleetd #422: model on/off (spawn-time gate + hot reload) -----------------------------
-
-    /**
-     * Criterion 3: an {@code allow:} entry written before {@code enabled:} existed — no such key in
-     * the YAML at all — must behave exactly as it always did: on, and absent from {@link
-     * FleetConfig.Models#offIds()}. This is the old-style fixture the ticket asks for, proven
-     * through a real YAML load rather than only through the {@code ModelEntry(String)} back-compat
-     * constructor.
-     */
-    @Test
-    void anOldStyleAllowEntryWithNoEnabledFieldStaysOn(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-        assertTrue(cfg.models().ids().contains("claude-sonnet-5"), "membership is unaffected");
-        assertTrue(cfg.models().offIds().isEmpty(), "no enabled: field ⇒ nothing is off");
-    }
-
-    /**
-     * Criterion 7 (the whole point of the ticket, mirroring criterion 3's shape): a profile naming a
-     * model that is turned off ({@code enabled: false}) must still be VALID config —
-     * {@code validateModels()} checks membership only, never the on/off state, so it must not throw.
-     * Collapsing "off" into "removed from allow:" would make this test fail, which is exactly the
-     * design trap the ticket calls out.
-     */
-    @Test
-    void anOffModelIsStillValidConfigForValidateModels(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: false
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels,
-                "an off model must stay a valid allow-list member — only the spawn gate reads enabled");
-        assertTrue(cfg.models().ids().contains("deepseek-v4-flash"));
-        assertTrue(cfg.models().offIds().contains("deepseek-v4-flash"));
-    }
-
-    /**
-     * Criterion 8: one {@code enabled: false} entry names a model, not a profile — every profile
-     * naming that model is off, on purpose (the live example: {@code deepseek-v4-flash} backs both
-     * {@code local} and {@code local-direct}). Proven here at the {@code Models}/config-load level;
-     * {@code CompositePeerLauncherTest} proves the spawn-time consequence for both profiles.
-     */
-    @Test
-    void turningOffOneModelIsIndependentOfHowManyProfilesNameIt(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                  local-direct:
-                    baseUrl: http://local.gw:8001
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: false
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertDoesNotThrow(cfg::validateModels);
-        // One allow-list entry, one off id — the fan-out to both profiles happens at the reader
-        // (CompositePeerLauncher), not by duplicating the entry per profile.
-        assertEquals(Set.of("deepseek-v4-flash"), cfg.models().offIds());
-        assertEquals("deepseek-v4-flash", cfg.profiles().get("local").model());
-        assertEquals("deepseek-v4-flash", cfg.profiles().get("local-direct").model());
-    }
-
-    /** An {@code enabled: true} entry (explicit, not just absent) also stays on — not just null. */
-    @Test
-    void explicitlyEnabledTrueStaysOn(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, """
-                bind:
-                  port: 8080
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                      enabled: true
-                """);
-
-        FleetConfig cfg = FleetConfig.load(f);
-        assertTrue(cfg.models().offIds().isEmpty());
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/config/FleetConfigValidateAllTest.java

@@ -1,358 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.lang.reflect.Method;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * The gap this class exists to close: mutation testing on the fleetd ticket "central allow-list
- * of usable models" found that although {@link FleetConfig#validateModels()}'s own logic was well
- * pinned, nothing proved either real caller ({@code Fleetd.main} and {@link ConfigRef#reload()})
- * still invoked it — deleting the call site left the full suite green (1478/0/0/0). A follow-up
- * measurement (same technique — remove one call site, run the suite, not read the code) found the
- * SAME gap for all five of {@link FleetConfig}'s other validators at startup, and for four of the
- * six inside {@link ConfigRef#reload()}. This is a class of gap, not one line's mistake: every one
- * of those thirteen tests called the validator itself directly, never the real caller that was
- * supposed to.
- *
- * <p>The fix replaces the six individual {@code cfg.validateXxx()} calls at each of the two real
- * call sites with one {@link FleetConfig#validateAll()}, which reaches every validator by
- * reflection rather than by a hand-maintained list of names. A hand-maintained list of six names
- * would have exactly the defect it replaces: the seventh validator someone adds next month has no
- * reason to be added to it, and nothing would say so. This class proves TWO separate claims, and
- * keeps them separate on purpose:
- *
- * <ol>
- *   <li>{@link #theSweepMechanismIsGenericNotHardcodedToFleetConfigsSixNames()} and its neighbours
- *       prove the reflective sweep itself ({@link FleetConfig#invokeAllValidators}) is a general
- *       mechanism — it runs whatever public, no-arg, void {@code validateXxx()} methods a class
- *       happens to declare today, including a class with more of them than {@link FleetConfig}
- *       has right now. This is the proof that a future, real seventh validator on {@link
- *       FleetConfig} would be swept automatically, without needing to add a real (unwanted)
- *       seventh validator just to exercise the claim.</li>
- *   <li>{@link #validateAllReachesEveryOneOfTodaysSixValidators()} proves {@link
- *       FleetConfig#validateAll()} itself is wired to that same generic mechanism and genuinely
- *       reaches each of today's six real validators — reusing the exact minimal failing
- *       configurations {@code FleetConfigTest} already established for each one directly, so a
- *       single call to {@code validateAll()} is shown to reproduce every one of those six
- *       failures.</li>
- * </ol>
- *
- * <p>Together with the direct-{@code Fleetd.main}-invocation tests in {@code
- * FleetdStartupValidationTest} (which prove the real startup call site still calls {@code
- * validateAll()}) and the {@code ConfigRefTest} reload tests (which prove the same for {@link
- * ConfigRef#reload()}), removing {@code cfg.validateAll();} from either real call site now fails
- * a test in this module.
- *
- * <p><b>What is NOT pinned, measured rather than assumed.</b> Reverting {@link
- * FleetConfig#validateAll()} to a hardcoded list of today's six method calls leaves the whole
- * suite green (measured at review: 1491 tests, 0 failures). Nothing ties {@code validateAll()} to
- * the generic sweep — claim 1 proves {@link FleetConfig#invokeAllValidators} is generic, and claim
- * 2 proves {@code validateAll()} reaches today's six, and a hardcoded list satisfies both. So the
- * reflective sweep is a convenience, not the guarantee. The guarantee is {@link
- * #fleetConfigDeclaresExactlyTheseSixValidatorsToday()}: it fails the moment a seventh validator
- * is declared, which forces whoever adds it to look at this file.
- */
-class FleetConfigValidateAllTest {
-
-    // ── Claim 1: the reflective sweep is a general mechanism, not six names in disguise ──────────
-
-    /**
-     * A throwaway fixture class, unrelated to {@link FleetConfig} in every way except shape: three
-     * public, no-arg, void methods named {@code validateXxx}. Proves the sweep works on ANY class
-     * with this shape, not on something special-cased to {@link FleetConfig}.
-     */
-    static class ThreeValidators {
-        final List<String> ran = new ArrayList<>();
-
-        public void validateAlpha() {
-            ran.add("validateAlpha");
-        }
-
-        public void validateBeta() {
-            ran.add("validateBeta");
-        }
-
-        public void validateGamma() {
-            ran.add("validateGamma");
-        }
-    }
-
-    @Test
-    void theSweepMechanismIsGenericNotHardcodedToFleetConfigsSixNames() {
-        ThreeValidators target = new ThreeValidators();
-        FleetConfig.invokeAllValidators(target);
-        assertEquals(List.of("validateAlpha", "validateBeta", "validateGamma"), target.ran,
-                "every validateXxx() method on this unrelated class must run, in alphabetical "
-                        + "order — the sweep reads the class's own shape, not a name FleetConfig "
-                        + "happens to know about");
-    }
-
-    /**
-     * The core of the "self-maintaining" requirement: the exact same class shape as {@link
-     * ThreeValidators}, plus one more method — standing in for "a developer adds a validator next
-     * month". Nothing about the sweep changes to pick it up; the new method is invoked purely
-     * because it exists and matches the shape. This is what makes adding a seventh real validator
-     * to {@link FleetConfig} safe without touching {@link FleetConfig#validateAll()} or either
-     * call site — there is no "wire it in" step left to forget.
-     */
-    static class FourValidators {
-        final List<String> ran = new ArrayList<>();
-
-        public void validateAlpha() {
-            ran.add("validateAlpha");
-        }
-
-        public void validateBeta() {
-            ran.add("validateBeta");
-        }
-
-        public void validateGamma() {
-            ran.add("validateGamma");
-        }
-
-        public void validateDelta() {
-            ran.add("validateDelta");
-        }
-    }
-
-    @Test
-    void addingAFourthValidatorMethodGetsSweptWithNoOtherChange() {
-        FourValidators target = new FourValidators();
-        FleetConfig.invokeAllValidators(target);
-        assertEquals(List.of("validateAlpha", "validateBeta", "validateDelta", "validateGamma"),
-                sorted(target.ran),
-                "the fourth method must be reached automatically — proving a class can grow the "
-                        + "set of things it validates with no change to the sweep itself");
-    }
-
-    private static List<String> sorted(List<String> in) {
-        List<String> copy = new ArrayList<>(in);
-        copy.sort(String::compareTo);
-        return copy;
-    }
-
-    @Test
-    void aFailingValidatorStopsTheSweepAndPropagatesUnchanged() {
-        class OneFails {
-            @SuppressWarnings("unused")
-            public void validateOk() {
-                // passes
-            }
-
-            public void validateBoom() {
-                throw new IllegalStateException("refusing to start: boom");
-            }
-        }
-        IllegalStateException e = assertThrows(IllegalStateException.class,
-                () -> FleetConfig.invokeAllValidators(new OneFails()));
-        assertEquals("refusing to start: boom", e.getMessage(),
-                "the real exception must propagate unchanged, not be wrapped or swallowed");
-    }
-
-    /**
-     * Every rule the sweep's filter applies, proven independently: only public, no-arg, void
-     * methods whose name starts with {@code "validate"} run, {@code validateAll} itself is
-     * excluded (so a class that declares one of its own — as {@link FleetConfig} does — cannot
-     * recurse into itself), and a same-shaped-but-wrongly-named or wrongly-shaped method never
-     * runs. A reader who "simplifies" the filter in {@link FleetConfig#invokeAllValidators} in a
-     * way that widens or narrows it breaks one of these.
-     */
-    static class FilterEdgeCases {
-        final List<String> ran = new ArrayList<>();
-
-        public void validateReal() {
-            ran.add("validateReal");
-        }
-
-        /** Wrong name — must not run. */
-        public void checkSomething() {
-            ran.add("checkSomething");
-        }
-
-        /** Wrong shape — takes an argument. */
-        public void validateWithArg(String ignored) {
-            ran.add("validateWithArg");
-        }
-
-        /** Wrong shape — returns something. */
-        public boolean validateReturnsBoolean() {
-            ran.add("validateReturnsBoolean");
-            return true;
-        }
-
-        /** Excluded by name on purpose, so the sweep cannot call itself. */
-        public void validateAll() {
-            ran.add("validateAll");
-        }
-    }
-
-    @Test
-    void onlyPublicNoArgVoidValidateNamedMethodsRun() {
-        FilterEdgeCases target = new FilterEdgeCases();
-        FleetConfig.invokeAllValidators(target);
-        assertEquals(List.of("validateReal"), target.ran,
-                "checkSomething (wrong name), validateWithArg (wrong shape), "
-                        + "validateReturnsBoolean (wrong shape), and validateAll (excluded by "
-                        + "name) must all be skipped");
-    }
-
-    // ── Claim 2: FleetConfig.validateAll() is wired to that mechanism and reaches all six today ──
-
-    /**
-     * Reflectively enumerates {@link FleetConfig}'s own public, no-arg, void {@code validateXxx()}
-     * methods (excluding {@code validateAll} itself) — the exact same filter {@link
-     * FleetConfig#invokeAllValidators} applies. This is not the mechanism proof (that is claim 1,
-     * above, on an unrelated class) — it is a visible denominator: today there are six, named
-     * here, so a reader adding a seventh sees this assertion name the new count rather than a
-     * silent pass at the old one.
-     */
-    @Test
-    void fleetConfigDeclaresExactlyTheseSixValidatorsToday() {
-        Set<String> names = new TreeSet<>();
-        for (Method m : FleetConfig.class.getMethods()) {
-            if (java.lang.reflect.Modifier.isPublic(m.getModifiers())
-                    && m.getParameterCount() == 0
-                    && m.getReturnType() == void.class
-                    && m.getName().startsWith("validate")
-                    && !m.getName().equals("validateAll")) {
-                names.add(m.getName());
-            }
-        }
-        assertEquals(new TreeSet<>(Set.of("validateAuthExposure", "validateLeadTabPrefixes",
-                "validateSubscriptionProfiles", "validateCharters", "validateMembers",
-                "validateModels")), names,
-                "FleetConfig's public validate*() methods changed. Do TWO things, in this "
-                        + "order. First confirm validateAll() still delegates to "
-                        + "invokeAllValidators(this) — a hardcoded list there passes every other "
-                        + "test in this class, so this assertion is the only place that will ever "
-                        + "make you check. Only then update the expected set to match.");
-    }
-
-    /** A minimal, otherwise-valid file — same shape FleetConfigTest and ConfigRefTest use. */
-    private static String minimalValidYaml() {
-        return """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet
-                """;
-    }
-
-    @Test
-    void aFullyValidConfigPassesValidateAll(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, minimalValidYaml());
-        assertDoesNotThrow(() -> FleetConfig.load(f).validateAll());
-    }
-
-    /**
-     * The heart of claim 2: for each of today's six real validators, a minimal file that fails
-     * ONLY that one — the exact fixtures {@code FleetConfigTest} uses to test each validator
-     * directly — must also fail through {@link FleetConfig#validateAll()}. If a future edit to
-     * {@code validateAll()} silently dropped one validator from the sweep (e.g. a typo'd name
-     * filter), exactly one of these six would start passing when it must not.
-     */
-    @Test
-    void validateAllReachesEveryOneOfTodaysSixValidators(@TempDir Path dir) throws Exception {
-        // validateAuthExposure: a non-loopback bind without token mode.
-        assertValidateAllRefuses(dir, "auth-exposure.yaml", """
-                bind:
-                  host: 0.0.0.0
-                  port: 8765
-                """, "auth.mode: token");
-
-        // validateLeadTabPrefixes: a fleet-wide tabLabel that starts with a lead's own tabPrefix.
-        assertValidateAllRefuses(dir, "lead-tab-prefixes.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                fleet:
-                  tabLabel: "lead: {role} {profile}"
-                  leaders:
-                    opus:
-                      tab: "lead: opus"
-                """, "fleet.tabLabel");
-
-        // validateSubscriptionProfiles: subscription: true with env: reseating ANTHROPIC_BASE_URL.
-        assertValidateAllRefuses(dir, "subscription-profiles.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  sonnet:
-                    subscription: true
-                    argv: ["ccs", "sonnet"]
-                    env:
-                      ANTHROPIC_BASE_URL: http://anything-not-on-the-allowlist
-                """, "ANTHROPIC_BASE_URL");
-
-        // validateCharters: a charter key that is not a role wire name.
-        assertValidateAllRefuses(dir, "charters.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                fleet:
-                  charters:
-                    architetc: text
-                """, "architetc");
-
-        // validateMembers: an architect slot naming an unconfigured profile.
-        assertValidateAllRefuses(dir, "members.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  gx10:
-                    baseUrl: http://gx10.gw:8000
-                fleet:
-                  architects:
-                    lead-designer:
-                      profile: sonnet
-                """, "lead-designer");
-
-        // validateModels: a profile naming a model outside the configured allow-list.
-        assertValidateAllRefuses(dir, "models.yaml", """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                profiles:
-                  sonnet:
-                    baseUrl: http://gx10.gw:8000
-                    model: claude-sonnet-5
-                  rogue:
-                    baseUrl: http://gx11.gw:8000
-                    model: claude-opus-9000
-                models:
-                  allow:
-                    - model: claude-sonnet-5
-                """, "rogue");
-    }
-
-    private static void assertValidateAllRefuses(Path dir, String fileName, String yaml,
-                                                  String mustContain) throws Exception {
-        Path f = dir.resolve(fileName);
-        Files.writeString(f, yaml);
-        FleetConfig cfg = FleetConfig.load(f);
-        IllegalStateException e = assertThrows(IllegalStateException.class, cfg::validateAll,
-                fileName + ": validateAll() must refuse this config");
-        assertTrue(e.getMessage().contains(mustContain),
-                fileName + ": expected message to contain \"" + mustContain + "\" but was: "
-                        + e.getMessage());
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/config/FleetConfigWithDefaultsPreservesEveryComponentTest.java

@@ -1,196 +0,0 @@
-package dev.ltms.fleet.config;
-
-import org.junit.jupiter.api.Test;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.RecordComponent;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.TreeSet;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-/**
- * Guards against a "defect factory" built into this file's own established pattern, found live
- * while building the (parked) idle-sleep-guard PR: every time a component is added to
- * {@link FleetConfig}, the record grows by one arg AND a new back-compat constructor is added at
- * the OLD arity, so existing callers keep compiling. That is correct and required — see the
- * constructor ladder just below the record header. But {@link #withDefaults()}'s own {@code return
- * new FleetConfig(...)} call sits in this same file, written at a literal argument count. The very
- * next time a component is added, the freshly-added back-compat constructor at the OLD arity
- * silently captures that stale call, because it is now a legal overload at that arg count too. It
- * compiles. Every other test passes, because nothing else exercises the new field. The new
- * component is defaulted away — {@code null}, or whatever that back-compat overload defaults it to
- * — on every {@link FleetConfig#load}. Measured, not theoretical: this exact sequence happened
- * live when the {@code idleSleepGuard} component was added on a sibling branch; it was caught only
- * because that branch's own new tests happened to assert on the new field's value.
- *
- * <p>This test proves the opposite property, and does it in a way that survives the next field
- * being added without being rewritten: reflectively enumerate {@link FleetConfig}'s own record
- * components (never a hardcoded count — the arity is exactly what changes over time), build one
- * config through the true canonical constructor with a real, distinctive, non-null value in EVERY
- * component (reusing the exact reflective-construction pattern
- * {@link ConfigRefTopLevelReportingCoverageTest} already established for this file:
- * {@code getDeclaredConstructor(exact record-component types)}, which resolves the canonical
- * constructor by its true shape, not by binding to whichever overload happens to match arg count —
- * the same way Jackson resolves it), call the real {@link FleetConfig#withDefaults()}, and assert
- * every one of those values survives unchanged.
- *
- * <p>Why this is a valid check for every component, not just some: {@link #withDefaults()}'s own
- * comments document that it only ever REPLACES a component when the incoming value is {@code null}
- * (or blank, for {@code placement}) — {@code broker}/{@code primary}/{@code leadHeartbeat}/
- * {@code configReload}/{@code coordinator}/{@code worktreeGroup}/{@code memberLoginShell}/
- * {@code memberSkills}/{@code idleSleepGuard} are left as-is unconditionally, and {@code bind}/{@code guard}/{@code lifecycle}/{@code auth}/
- * {@code fleet}/{@code quarantineCooldownSeconds}/{@code memberCredentials}/{@code placement} are
- * replaced only on null/blank input. A value that is never null or blank going in must therefore
- * never change coming out, for every current component. No exclusion is needed today.
- *
- * <p>{@link #EXCLUDED_FROM_SURVIVAL_CHECK} exists anyway, kept deliberately empty and size-pinned
- * by {@link #exclusionListSizeIsPinned()}: a future component that {@code withDefaults()} is
- * <em>documented</em> to transform unconditionally (unlike every field today) would legitimately
- * need one. Pinning the size at 0 means growing that set to make a failure go away is itself a
- * visible diff to this test, not a silent one — a checker that can be silenced by adding to its
- * own escape hatch is not a checker.
- */
-class FleetConfigWithDefaultsPreservesEveryComponentTest {
-
-    private static final RecordComponent[] COMPONENTS = FleetConfig.class.getRecordComponents();
-
-    /** See the class javadoc — deliberately empty today; grow it only with a matching justification. */
-    private static final Set<String> EXCLUDED_FROM_SURVIVAL_CHECK = Set.of();
-
-    /** One real, distinctive, non-null (non-blank where blankness would mean "unset") value per component. */
-    private static Map<String, Object> baseValues() {
-        Map<String, Object> v = new LinkedHashMap<>();
-        v.put("bind", new FleetConfig.Bind("127.0.0.1", 8765));
-        v.put("herdrSocket", "~/.config/herdr/guard.sock");
-        v.put("memberHerdrSocket", "~/.config/herdr/member-guard.sock");
-        v.put("profiles", Map.of("sonnet", minimalProfile("sonnet")));
-        v.put("guard", new FleetConfig.Guard(List.of("host-guard")));
-        v.put("worktreeRoot", "/wt/guard");
-        v.put("lifecycle", new FleetConfig.Lifecycle(300, 5, 30, true));
-        v.put("spawnReadyTimeoutMs", 12_345);
-        v.put("spawnReadyPollMs", 234);
-        v.put("broker", new FleetConfig.Broker("amqp://guard", null, 7));
-        v.put("primary", new FleetConfig.Primary("term-guard", 4, 4000));
-        v.put("fleet", new FleetConfig.Fleet(
-                Map.of("opus", new FleetConfig.Leader("sonnet", "lead: opus-guard", 1, null, 10,
-                        "claude", null, null, null)),
-                Map.of(), Map.of(), Map.of(), Map.of(), "{role}: {profile} #{n}"));
-        v.put("leadHeartbeat", new FleetConfig.LeadHeartbeat(301, 61_000L, 4));
-        v.put("health", new FleetConfig.Health(true, 31, 601, 61, null));
-        v.put("placement", "round-robin");
-        v.put("auth", new FleetConfig.Auth("loopback-trust", null));
-        v.put("configReload", new FleetConfig.ConfigReload(true, 11));
-        v.put("quarantineCooldownSeconds", 1801);
-        v.put("memberCredentials", new FleetConfig.MemberCredentials(
-                FleetConfig.MemberCredentials.POLICY_DENY_BY_DEFAULT,
-                List.of("git"), List.of("git", "ssh"), null));
-        v.put("coordinator", new FleetConfig.Coordinator("amqp://coord-guard", null, "self-guard", 3, null));
-        v.put("worktreeGroup", "group-guard");
-        v.put("memberLoginShell", "/bin/zsh");
-        v.put("memberSkills", "/skills/guard");
-        v.put("idleSleepGuard", new FleetConfig.IdleSleepGuard(true));
-        v.put("models", new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("model-guard"))));
-        assertNamesMatchComponents(v);
-        return v;
-    }
-
-    /** A minimal, otherwise-null {@link FleetConfig.Profile} — just enough to name one in a map. */
-    private static FleetConfig.Profile minimalProfile(String name) {
-        return new FleetConfig.Profile(name, null, null, null, null, null, null, null, null, null,
-                null, null, null, null, null, null, null, null, null, null, null, null, null, null,
-                null, null);
-    }
-
-    /**
-     * Guards {@link #baseValues()} itself against drifting from the record's real shape — the same
-     * assurance {@link ConfigRefTopLevelReportingCoverageTest} already relies on. This is what makes
-     * "no hardcoded arity" true in practice: forgetting to add a new component here fails this
-     * assertion by name, rather than silently checking one component fewer than the record has.
-     */
-    private static void assertNamesMatchComponents(Map<String, Object> values) {
-        Set<String> names = new TreeSet<>();
-        for (RecordComponent rc : COMPONENTS) {
-            names.add(rc.getName());
-        }
-        assertEquals(names, new TreeSet<>(values.keySet()),
-                "this test's value map has drifted from FleetConfig's actual top-level components — "
-                        + "update baseValues() alongside the record");
-    }
-
-    /**
-     * Builds a {@link FleetConfig} through the TRUE canonical constructor — resolved by the record's
-     * own component types, not by argument count — so this never accidentally exercises a
-     * back-compat overload the way a literal {@code new FleetConfig(...)} call risks doing.
-     */
-    private static FleetConfig configOf(Map<String, Object> values) throws ReflectiveOperationException {
-        Class<?>[] types = Arrays.stream(COMPONENTS).map(RecordComponent::getType).toArray(Class<?>[]::new);
-        Object[] args = Arrays.stream(COMPONENTS).map(rc -> values.get(rc.getName())).toArray();
-        Constructor<FleetConfig> ctor = FleetConfig.class.getDeclaredConstructor(types);
-        return ctor.newInstance(args);
-    }
-
-    @Test
-    void exclusionListSizeIsPinned() {
-        assertEquals(0, EXCLUDED_FROM_SURVIVAL_CHECK.size(),
-                "EXCLUDED_FROM_SURVIVAL_CHECK grew from 0 — every entry needs a justification in "
-                        + "this test class's javadoc AND this assertion re-pinned to the new size; a "
-                        + "growing exclusion list that silences failures on its own is not a guard");
-    }
-
-    /**
-     * The mutation this is built to catch: make {@code withDefaults()}'s final constructor call
-     * literal at some arg count, add one more component to the record with a new back-compat
-     * constructor at the old arity, and the stale call silently rebinds. Every component here is
-     * real and non-null (non-blank for the one String — {@code placement} — where blank has
-     * meaning), so none of it should be replaced by {@code withDefaults()}; any component that
-     * comes back different was silently dropped.
-     */
-    @Test
-    void everyComponentGivenARealValueSurvivesWithDefaults() throws ReflectiveOperationException {
-        Map<String, Object> base = baseValues();
-        FleetConfig config = configOf(base);
-        FleetConfig defaulted = config.withDefaults();
-
-        List<String> dropped = new ArrayList<>();
-        int checked = 0;
-        for (RecordComponent rc : COMPONENTS) {
-            String name = rc.getName();
-            if (EXCLUDED_FROM_SURVIVAL_CHECK.contains(name)) {
-                continue;
-            }
-            checked++;
-            Object expected = base.get(name);
-            Object actual;
-            try {
-                actual = rc.getAccessor().invoke(defaulted);
-            } catch (ReflectiveOperationException e) {
-                throw new RuntimeException("failed to read FleetConfig." + name + "()", e);
-            }
-            if (!Objects.equals(expected, actual)) {
-                dropped.add(String.format(Locale.ROOT,
-                        "%s: withDefaults() was given a real, non-null value (%s) for '%s' but "
-                                + "returned %s — a component silently dropped by withDefaults(), the "
-                                + "shape of the defect this test exists to catch (its final "
-                                + "\"return new FleetConfig(...)\" call binding to a back-compat "
-                                + "constructor instead of the true canonical one)",
-                        name, expected, name, actual));
-            }
-        }
-
-        System.out.printf(Locale.ROOT,
-                "FleetConfig.withDefaults() component-survival coverage — %d components, %d checked, "
-                        + "%d excluded, %d survived%n",
-                COMPONENTS.length, checked, EXCLUDED_FROM_SURVIVAL_CHECK.size(), checked - dropped.size());
-        assertEquals(List.of(), dropped,
-                "withDefaults() silently dropped these real, given components: " + dropped);
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/deploy/SystemdUnitSafetyTest.java

@@ -1,232 +0,0 @@
-package dev.ltms.fleet.deploy;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Pattern;
-import java.util.stream.Stream;
-
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.MethodSource;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #360: {@code deploy/fleetd.service} started clean on fleet01 and broke the daemon in
- * three ways that nothing logs at startup.
- *
- * <ul>
- *   <li>{@code ProtectSystem=}, {@code ProtectHome=}, {@code ProtectKernelTunables=} and
- *       {@code ProtectControlGroups=} each give the unit its own mount namespace. fleetd resolves
- *       a caller's role by running {@code lsof} to find the loopback peer PID (see
- *       {@code mcp/LsofPeerPidLookup}). Inside such a namespace {@code lsof} returns nothing,
- *       every caller falls back to ANONYMOUS, and the primary is refused every orchestration call
- *       with "unauthenticated: anonymous may not SPAWN" -- while healthz still reports ok.
- *       Measured by bisection on fleet01 2026-09-05 (lsof line count): no sandbox 3,
- *       {@code ProtectSystem=strict} 0, {@code ProtectHome=read-only} 0,
- *       {@code ProtectKernelTunables} 0, {@code ProtectControlGroups} 0,
- *       {@code RestrictSUIDSGID} 3, {@code NoNewPrivileges} 3 -- so only the first four are
- *       forbidden.
- *   <li>{@code PrivateTmp=true} gives the unit its own {@code /tmp}. fleetd writes the member
- *       ZDOTDIR credential-scrub directory and the opencode config directory under
- *       {@code java.io.tmpdir}, and the member pane -- a child of a *different* unit
- *       (herdr.service) -- has to read them back. A private {@code /tmp} on either unit turns the
- *       credential scrub into a silent no-op.
- *   <li>Running {@code java} directly from {@code ExecStart} skips the login shell. Every secret
- *       fleetd needs (AI_GATEWAY_TOKEN, WORKER_GITEA_TOKEN, LAVINMQ_URI, COORD_AMQP_URI) lives in
- *       a file only the login shell sources; systemd runs no login shell on its own. Started that
- *       way the daemon boots fine with empty credentials, and the failure appears hours later as a
- *       member that cannot open a pull request.
- * </ul>
- *
- * <p>Review round 2 on fleetd #360 found the same shape one file further down the chain:
- * {@code herdr.service}'s {@code ExecStart} only names {@code deploy/herdr-inner.sh}, so that
- * script is the ONLY place two more of these properties live, and nothing was reading it.
- *
- * <ul>
- *   <li>If the script does not exec a login shell, herdr -- and every member pane it spawns as a
- *       child -- starts with none of the secrets only a login shell sources, the same silent
- *       empty-credentials failure as fleetd.service's {@code ExecStart}, one process further away.
- *   <li>If the script does not set a real, non-zero pty size before starting herdr (with
- *       {@code stty}), herdr reports a 0x0 window and every pane spawn fails with
- *       "ghostty error -2" -- which surfaces as a fleetd spawn failure, not a herdr one.
- * </ul>
- *
- * <p>None of these five failures makes the unit (or the script) fail to start, or makes
- * {@code /healthz} report unhealthy, so nothing short of reading the files catches a regression.
- * This test is that read.
- *
- * <p><b>It checks source text, not behaviour</b> -- it cannot start systemd or fork an mount
- * namespace in a build sandbox. It parses the same two files an operator would install and fails
- * if a forbidden directive is active, exactly the way {@code McpContractDocTest} guards
- * {@code docs/MCP-Contract.md} against naming a tool that does not exist.
- */
-class SystemdUnitSafetyTest {
-
-    /** Tests run with the module directory (fleetd/) as cwd; deploy/ is the repo-root sibling. */
-    private static final Path FLEETD_SERVICE = Path.of("../deploy/fleetd.service");
-    private static final Path HERDR_SERVICE = Path.of("../deploy/herdr.service");
-    private static final Path HERDR_INNER_SCRIPT = Path.of("../deploy/herdr-inner.sh");
-
-    private static final List<String> NAMESPACING_DIRECTIVES = List.of(
-            "ProtectSystem", "ProtectHome", "ProtectKernelTunables", "ProtectControlGroups");
-
-    /**
-     * A shell invoked with a login flag, e.g. {@code zsh -lc '...'} or {@code /bin/sh -l}. The
-     * property under test is the {@code -l}, not the specific shell or the rest of its flags, so
-     * this matches a token ending in "sh" followed by a flag cluster containing "l" -- tighter
-     * than a bare {@code contains("-lc")}, which a "-lc" anywhere in the line would also satisfy.
-     */
-    private static final Pattern LOGIN_SHELL_INVOCATION =
-            Pattern.compile("(?:^|\\s)\\S*sh\\s+-[A-Za-z]*l[A-Za-z]*\\b");
-
-    private static final Pattern POSITIVE_ROWS = Pattern.compile("\\brows\\s+([1-9]\\d*)\\b");
-    private static final Pattern POSITIVE_COLS = Pattern.compile("\\bcols\\s+([1-9]\\d*)\\b");
-
-    static Stream<Path> bothUnits() {
-        return Stream.of(FLEETD_SERVICE, HERDR_SERVICE);
-    }
-
-    private static boolean invokesALoginShell(List<String> activeLines) {
-        return activeLines.stream().anyMatch(l -> LOGIN_SHELL_INVOCATION.matcher(l).find());
-    }
-
-    /** An active {@code stty} line naming both a positive row count and a positive column count. */
-    private static boolean setsANonZeroPtySize(List<String> activeLines) {
-        return activeLines.stream()
-                .filter(l -> l.startsWith("stty"))
-                .anyMatch(l -> POSITIVE_ROWS.matcher(l).find() && POSITIVE_COLS.matcher(l).find());
-    }
-
-    /** Lines that are actually in force: comments and blank lines don't count. */
-    private static List<String> activeLines(Path unit) throws Exception {
-        List<String> active = new ArrayList<>();
-        for (String line : Files.readAllLines(unit)) {
-            String stripped = line.strip();
-            if (!stripped.isEmpty() && !stripped.startsWith("#")) {
-                active.add(stripped);
-            }
-        }
-        return active;
-    }
-
-    @ParameterizedTest
-    @MethodSource("bothUnits")
-    @DisplayName("[SOURCE TEXT] no active mount-namespacing directive -- it blinds lsof and turns every caller ANONYMOUS")
-    void doesNotActivateAMountNamespace(Path unit) throws Exception {
-        List<String> active = activeLines(unit);
-
-        for (String directive : NAMESPACING_DIRECTIVES) {
-            Pattern activeDirective = Pattern.compile("^" + Pattern.quote(directive) + "\\s*=");
-            List<String> hits = active.stream().filter(l -> activeDirective.matcher(l).find()).toList();
-            assertTrue(hits.isEmpty(),
-                    unit + " sets " + directive + " (" + hits + "). That directive gives the unit its "
-                            + "own mount namespace; inside it, fleetd's lsof-based caller lookup "
-                            + "(mcp/LsofPeerPidLookup) returns nothing, so every MCP caller falls back to "
-                            + "ANONYMOUS and the primary is refused every orchestration call with "
-                            + "\"unauthenticated: anonymous may not SPAWN\" -- while the daemon still "
-                            + "starts and /healthz still reports ok. Measured on fleet01 2026-09-05 "
-                            + "(fleetd #360). A commented-out mention in the file's own DO-NOT-add block "
-                            + "is fine; an active directive is not.");
-        }
-    }
-
-    @ParameterizedTest
-    @MethodSource("bothUnits")
-    @DisplayName("[SOURCE TEXT] PrivateTmp is not true -- it silently no-ops the credential scrub")
-    void privateTmpIsNotTrue(Path unit) throws Exception {
-        List<String> active = activeLines(unit);
-        Pattern privateTmpTrue = Pattern.compile("^PrivateTmp\\s*=\\s*true\\b");
-
-        boolean hasPrivateTmpTrue = active.stream().anyMatch(l -> privateTmpTrue.matcher(l).find());
-        assertFalse(hasPrivateTmpTrue,
-                unit + " sets PrivateTmp=true. fleetd writes the member ZDOTDIR credential-scrub "
-                        + "directory and the opencode config directory under java.io.tmpdir, and the "
-                        + "member pane -- a child of a DIFFERENT unit -- has to read them back. A "
-                        + "private /tmp on either unit turns the credential scrub into a silent no-op: "
-                        + "no error, no log line, the scrub just never happens (fleetd #360).");
-    }
-
-    @Test
-    @DisplayName("[SOURCE TEXT] fleetd.service's ExecStart goes through a login shell -- otherwise every secret is empty")
-    void execStartUsesALoginShell() throws Exception {
-        List<String> active = activeLines(FLEETD_SERVICE);
-        List<String> execStartLines = active.stream().filter(l -> l.startsWith("ExecStart=")).toList();
-
-        assertTrue(execStartLines.size() == 1,
-                FLEETD_SERVICE + " must have exactly one active ExecStart= line; found "
-                        + execStartLines.size() + ": " + execStartLines);
-
-        String execStart = execStartLines.get(0);
-        assertTrue(LOGIN_SHELL_INVOCATION.matcher(execStart).find(),
-                FLEETD_SERVICE + "'s ExecStart (" + execStart + ") does not run a login shell (a shell "
-                        + "invoked with a \"-l\" flag, e.g. \"zsh -lc\"). Every secret fleetd needs "
-                        + "(AI_GATEWAY_TOKEN, WORKER_GITEA_TOKEN, LAVINMQ_URI, COORD_AMQP_URI) lives in a "
-                        + "file only the login shell sources; systemd runs no login shell on its own. "
-                        + "Running java directly boots fine with every credential empty, and the failure "
-                        + "surfaces hours later as a member that cannot open a pull request (fleetd #360).");
-    }
-
-    @Test
-    @DisplayName("[SOURCE TEXT] herdr-inner.sh execs a login shell -- otherwise herdr and every member it spawns start with empty credentials")
-    void herdrInnerScriptUsesALoginShell() throws Exception {
-        List<String> active = activeLines(HERDR_INNER_SCRIPT);
-
-        assertTrue(invokesALoginShell(active),
-                HERDR_INNER_SCRIPT + " does not exec a login shell (a shell invoked with a \"-l\" flag, "
-                        + "e.g. \"zsh -lc\"). herdr.service's ExecStart only names this script, so this "
-                        + "is the ONLY place herdr's login-shell property lives. Without it, herdr -- and "
-                        + "every member pane it spawns as a child of herdr -- starts with none of the "
-                        + "secrets that only a login shell sources (this host: ~/.fleet/secrets.sh via "
-                        + "~/.zprofile), and the failure surfaces hours later as a member with no "
-                        + "credentials at all, not just fleetd (fleetd #360).");
-    }
-
-    @Test
-    @DisplayName("[SOURCE TEXT] herdr-inner.sh sets a non-zero pty size before starting herdr -- otherwise every pane spawn fails with \"ghostty error -2\"")
-    void herdrInnerScriptSetsANonZeroPtySize() throws Exception {
-        List<String> active = activeLines(HERDR_INNER_SCRIPT);
-
-        assertTrue(setsANonZeroPtySize(active),
-                HERDR_INNER_SCRIPT + " does not run \"stty rows N cols M\" with both N and M positive "
-                        + "before starting herdr. Without a real pty size, herdr reports a 0x0 window and "
-                        + "every pane spawn fails with \"ghostty error -2\" -- which surfaces as a fleetd "
-                        + "spawn failure, not a herdr one, and gives no hint that the actual cause is this "
-                        + "script (fleetd #360).");
-    }
-
-    /**
-     * The denominator guard, same shape as {@code McpContractDocTest}'s: a check that scans for a
-     * forbidden pattern passes trivially if it is handed nothing to scan. Pin that all three files
-     * exist, are non-trivial, and that the DO-NOT block's commented mentions are still there -- so
-     * the "comment survives, directive doesn't" distinction above is actually being exercised.
-     */
-    @Test
-    @DisplayName("[SOURCE TEXT] the namespacing check is not vacuous -- all three files exist and the DO-NOT block still mentions every forbidden directive in a comment")
-    void theCheckActuallyHasSomethingToCheck() throws Exception {
-        assertTrue(Files.size(FLEETD_SERVICE) > 200,
-                FLEETD_SERVICE + " is missing or unexpectedly small -- the checks above would pass "
-                        + "vacuously against an empty or absent file");
-        assertTrue(Files.size(HERDR_SERVICE) > 200,
-                HERDR_SERVICE + " is missing or unexpectedly small -- the checks above would pass "
-                        + "vacuously against an empty or absent file");
-        assertTrue(Files.size(HERDR_INNER_SCRIPT) > 50,
-                HERDR_INNER_SCRIPT + " is missing or unexpectedly small -- the login-shell and "
-                        + "pty-size checks above would either pass vacuously or fail with an opaque "
-                        + "\"file not found\" instead of naming the actual consequence (empty "
-                        + "credentials / \"ghostty error -2\") against an empty or absent file");
-
-        String fleetdService = Files.readString(FLEETD_SERVICE);
-        for (String directive : NAMESPACING_DIRECTIVES) {
-            assertTrue(fleetdService.contains(directive),
-                    FLEETD_SERVICE + " no longer mentions " + directive + " anywhere, not even in the "
-                            + "DO-NOT-add comment block that explains why it must stay out. That comment "
-                            + "is the whole point of fleetd #360 -- it is what stops the next edit from "
-                            + "re-adding the directive without knowing why.");
-        }
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/health/FleetHealthMonitorTest.java

@@ -24,13 +24,10 @@ import org.slf4j.LoggerFactory;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 import java.util.function.LongSupplier;
 
@@ -207,139 +204,6 @@ class FleetHealthMonitorTest {
                 .workingSuspectAfterOrDefault());
     }
 
-    // --- fleetd #386: a stall detector whose only clock freezes with a sleeping host is worse
-    // than a silent one — it reports "quiet" for a member that was genuinely busy for hours.
-
-    @Test void monotonicClockFrozenPastThresholdOnRealClockStillReportsStallSuspected() {
-        Logger logger = (Logger) LoggerFactory.getLogger(FleetHealthMonitor.class);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            AtomicLong mono = new AtomicLong(0);
-            AtomicLong real = new AtomicLong(0);
-            FakeHerdr herdr = new FakeHerdr().withAgent("busy", "term_busy", "pane_busy", "tab_busy");
-            var scheduler = Executors.newSingleThreadScheduledExecutor();
-            FleetHealthMonitor monitor = monitorWithClocks(herdr,
-                    List.of(member("term_busy", MemberSession.State.BUSY, 0, 0)), scheduler,
-                    mono::get, real::get, 60, 600, (_, _) -> { });
-
-            monitor.tick(); // establishes the clock baseline; nothing has diverged yet
-            assertEquals(0, appender.list.stream().filter(event -> event.getFormattedMessage()
-                    .contains("state=STALL_SUSPECTED")).count());
-
-            // The host "sleeps": the monotonic clock stands completely still while the real clock
-            // keeps moving, past the 600s stall threshold.
-            real.set(TimeUnit.SECONDS.toNanos(700));
-            monitor.tick();
-            monitor.stop();
-
-            assertTrue(appender.list.stream().anyMatch(event -> event.getFormattedMessage()
-                            .contains("member=term_busy state=STALL_SUSPECTED")),
-                    "the real clock crossed the stall threshold even though the monotonic clock never moved");
-        } finally {
-            logger.detachAppender(appender);
-        }
-    }
-
-    @Test void clockDivergenceIsLoggedOnceNotOncePerTick() {
-        Logger logger = (Logger) LoggerFactory.getLogger(FleetHealthMonitor.class);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            AtomicLong mono = new AtomicLong(0);
-            AtomicLong real = new AtomicLong(0);
-            var scheduler = Executors.newSingleThreadScheduledExecutor();
-            FleetHealthMonitor monitor = monitorWithClocks(new FakeHerdr(), List.of(), scheduler,
-                    mono::get, real::get, 60, 600, (_, _) -> { });
-
-            monitor.tick(); // baseline: no divergence possible yet
-
-            // One sleep gap: the monotonic clock is frozen while the real clock jumps far past one
-            // tick interval (60s).
-            real.set(TimeUnit.SECONDS.toNanos(700));
-            monitor.tick();
-
-            // The host is awake again: both clocks advance together from here, so no more divergence.
-            mono.set(TimeUnit.SECONDS.toNanos(10));
-            real.set(TimeUnit.SECONDS.toNanos(710));
-            monitor.tick();
-            mono.set(TimeUnit.SECONDS.toNanos(20));
-            real.set(TimeUnit.SECONDS.toNanos(720));
-            monitor.tick();
-            monitor.stop();
-
-            assertEquals(1, appender.list.stream().filter(event -> event.getFormattedMessage()
-                            .contains("the monotonic clock did not advance"))
-                    .count(), "one sleep gap must produce exactly one divergence line, not one per tick");
-        } finally {
-            logger.detachAppender(appender);
-        }
-    }
-
-    /**
-     * fleetd #386 follow-up, added on merge. The fix carries a PER-MEMBER drift baseline, so drift
-     * from a sleep that happened BEFORE a member went busy is never charged to that member. The
-     * two tests shipped with the fix both start with the member already BUSY, so a single global
-     * baseline passes them — this one fails without the per-member map.
-     *
-     * <p>Order matters: the host sleeps while nothing is busy, and only then does a member take a
-     * turn. Its stall clock must start at zero.
-     */
-    @Test void driftFromASleepBeforeAMemberWentBusyIsNotChargedToThatMember() {
-        Logger logger = (Logger) LoggerFactory.getLogger(FleetHealthMonitor.class);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            AtomicLong mono = new AtomicLong(0);
-            AtomicLong real = new AtomicLong(0);
-            AtomicReference<List<MemberSession>> roster = new AtomicReference<>(List.of());
-            FakeHerdr herdr = new FakeHerdr().withAgent("busy", "term_busy", "pane_busy", "tab_busy");
-            var scheduler = Executors.newSingleThreadScheduledExecutor();
-            AgentControl agents = new AgentControl(herdr);
-            FleetHealthMonitor monitor = new FleetHealthMonitor(agents, roster::get,
-                    new MessageService(agents, new Injector(agents), new Rendezvous(), new InMemoryReplyInbox()),
-                    scheduler, mono::get, real::get, 60, 600, (_, _) -> { });
-
-            monitor.tick();                                   // baseline, no members yet
-
-            // The host sleeps for 700s with nobody busy: the monotonic clock stands still.
-            real.set(TimeUnit.SECONDS.toNanos(700));
-            monitor.tick();
-
-            // Awake again. Only NOW does a member start a turn, with a fresh activity stamp taken
-            // from the monotonic clock. Both clocks advance together from here.
-            mono.set(TimeUnit.SECONDS.toNanos(10));
-            real.set(TimeUnit.SECONDS.toNanos(710));
-            roster.set(List.of(member("term_busy", MemberSession.State.BUSY,
-                    0, TimeUnit.SECONDS.toNanos(10))));
-            monitor.tick();
-
-            mono.set(TimeUnit.SECONDS.toNanos(20));
-            real.set(TimeUnit.SECONDS.toNanos(720));
-            monitor.tick();
-            monitor.stop();
-
-            assertEquals(0, appender.list.stream().filter(event -> event.getFormattedMessage()
-                            .contains("member=term_busy state=STALL_SUSPECTED")).count(),
-                    "the member has been busy for 10s, not 710s — the earlier sleep is not its stall");
-        } finally {
-            logger.detachAppender(appender);
-        }
-    }
-
-    private static FleetHealthMonitor monitorWithClocks(FakeHerdr herdr, List<MemberSession> roster,
-            java.util.concurrent.ScheduledExecutorService scheduler, LongSupplier clock,
-            LongSupplier realtimeClock, long intervalSeconds, long workingSuspectAfterSeconds,
-            BiConsumer<String, String> failTarget) {
-        AgentControl agents = new AgentControl(herdr);
-        return new FleetHealthMonitor(agents, () -> roster,
-                new MessageService(agents, new Injector(agents), new Rendezvous(), new InMemoryReplyInbox()),
-                scheduler, clock, realtimeClock, intervalSeconds, workingSuspectAfterSeconds, failTarget);
-    }
-
     @Test void goneMemberRecoveryLogsOnceWithoutRefiringTargetFailure() {
         Logger logger = (Logger) LoggerFactory.getLogger(FleetHealthMonitor.class);
         Level previousLevel = logger.getLevel();
@@ -570,120 +434,4 @@ class FleetHealthMonitorTest {
             logger.detachAppender(appender);
         }
     }
-
-    // --- fleetd #280: a GONE/NEVER_READY guess whose fleet_ask lapses AFTER the first sweep must
-    // still be swept, without ever reaching into a target that has since recovered or left the
-    // roster. See FleetHealthMonitor.recheckTerminalTarget's javadoc for the full reachability chain.
-
-    @Test void terminalTransitionSchedulesExactlyOneDelayedRecheck() {
-        ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(1);
-        FleetHealthMonitor monitor = monitor(new FakeHerdr(),
-                List.of(member("term_a", MemberSession.State.BUSY, 0, 0)), scheduler, () -> 1, 600,
-                (_, _) -> { });
-
-        monitor.reportTransition("term_a", HealthState.GONE);
-
-        // Driven via reportTransition directly (not tick()), so the queue holds only the recheck.
-        assertEquals(1, scheduler.getQueue().size());
-        ScheduledFuture<?> scheduled = (ScheduledFuture<?>) scheduler.getQueue().peek();
-        assertTrue(scheduled.getDelay(TimeUnit.SECONDS) > 100,
-                "the delay must clear the worst-case fleet_ask lapse window (up to 115s)");
-
-        // An unchanged tick must not queue a second one (CB-580's fire-once rule extends to this).
-        monitor.reportTransition("term_a", HealthState.GONE);
-        assertEquals(1, scheduler.getQueue().size());
-        monitor.stop();
-    }
-
-    @Test void recheckIsANoOpOnceTheTargetHasRecovered() {
-        RecordingFailTarget failTarget = new RecordingFailTarget();
-        FleetHealthMonitor monitor = monitorWith(failTarget);
-        monitor.reportTransition("term_a", HealthState.GONE);
-        assertEquals(1, failTarget.calls.size());
-
-        monitor.reportTransition("term_a", HealthState.IDLE); // recovered before the recheck fired
-        monitor.recheckTerminalTarget("term_a", HealthState.GONE);
-
-        assertEquals(1, failTarget.calls.size(), "a recovered target must not be reached into again");
-        monitor.stop();
-    }
-
-    @Test void recheckIsANoOpForATargetItNeverObserved() {
-        // Mirrors "left the roster": tick() prunes states.keySet() to the current roster on release
-        // (see FleetHealthMonitor.tick), so a target this monitor never recorded is the same case.
-        RecordingFailTarget failTarget = new RecordingFailTarget();
-        FleetHealthMonitor monitor = monitorWith(failTarget);
-
-        monitor.recheckTerminalTarget("term_never_seen", HealthState.GONE);
-
-        assertEquals(0, failTarget.calls.size(), "an untracked/released target must not be reached into");
-        monitor.stop();
-    }
-
-    /**
-     * The scenario from the ticket, end to end, driven through the real {@link MessageService}: a
-     * target's ask is still genuinely open when health first observes GONE (sweep must skip it,
-     * exactly as {@code abandonDoesNotFailAnAsyncTicketWaitingForAnAnswer} pins), the ask then lapses
-     * on its own, an unchanged tick still must not refire, and only the delayed recheck sweeps the
-     * now-lapsed ticket to FAILED.
-     */
-    @Test void delayedRecheckSweepsATicketWhoseAskLapsedAfterGoneWasFirstObserved() throws Exception {
-        FakeHerdr herdr = new FakeHerdr().withAgent("worker", "term_a", "pane-term_a", "tab_a")
-                .readText("$ prompt");
-        AgentControl agents = new AgentControl(herdr);
-        Rendezvous rendezvous = new Rendezvous();
-        Injector injector = new Injector(agents);
-        InMemoryReplyInbox inbox = new InMemoryReplyInbox();
-        inbox.own("term_a");
-        MessageService messages = new MessageService(agents, injector, rendezvous, inbox);
-        FleetHealthMonitor monitor = new FleetHealthMonitor(agents,
-                () -> List.of(member("term_a", MemberSession.State.READY, 0, 0)), messages,
-                new ScheduledThreadPoolExecutor(1), () -> 1, 60, 600, messages::abandon);
-
-        String ticket = messages.sendAsync("term_a", "task that asks");
-        long deadline = System.currentTimeMillis() + 2000;
-        while (!rendezvous.isWaiting("term_a") && System.currentTimeMillis() < deadline) {
-            Thread.sleep(5);
-        }
-        assertTrue(rendezvous.isWaiting("term_a"), "the async send should have opened its waiter");
-        injector.onStatus("term_a", AgentStatus.IDLE);    // deliver the task
-        injector.onStatus("term_a", AgentStatus.WORKING); // the worker picks it up
-
-        // The worker asks, with a short timeout so its own fleet_ask lapses quickly in test time.
-        CompletableFuture<MessageService.AskResult> ask = CompletableFuture.supplyAsync(
-                () -> messages.ask("term_a", "which config?", 200));
-        awaitPhase(messages, ticket, MessageService.Phase.ASKING);
-
-        monitor.reportTransition("term_a", HealthState.GONE);
-        assertEquals(MessageService.Phase.ASKING, messages.poll(ticket).phase(),
-                "the first sweep must not fail a ticket that is still genuinely being asked");
-
-        // The worker's own fleet_ask now lapses on its own — task.question clears to null.
-        assertEquals(MessageService.AskOutcome.TIMED_OUT, ask.get(5, TimeUnit.SECONDS).outcome());
-
-        // An unchanged tick still must not refire (CB-580).
-        monitor.reportTransition("term_a", HealthState.GONE);
-        assertEquals(MessageService.Phase.PENDING, messages.poll(ticket).phase());
-
-        // The delayed recheck scheduled for the original transition finally sweeps it.
-        monitor.recheckTerminalTarget("term_a", HealthState.GONE);
-        assertEquals(MessageService.Phase.FAILED, messages.poll(ticket).phase());
-
-        monitor.stop();
-    }
-
-    private static MessageService.TaskView awaitPhase(MessageService messages, String ticket,
-            MessageService.Phase phase) throws InterruptedException {
-        long deadline = System.currentTimeMillis() + 2000;
-        MessageService.TaskView view;
-        do {
-            view = messages.poll(ticket);
-            if (view.phase() == phase) {
-                return view;
-            }
-            Thread.sleep(5);
-        } while (System.currentTimeMillis() < deadline);
-        assertEquals(phase, view.phase());
-        return view;
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/herdr/AgentControlContractTest.java

@@ -17,93 +17,15 @@ import static org.junit.jupiter.api.Assumptions.assumeTrue;
  * SHELL directly (never {@code claude}, so no subscription/token involvement) and always tears
  * the throwaway space down.
  *
- * <p>The seed shell's own startup (restoring its session, printing its banner) is asynchronous
- * and its length is not a fleetd contract — measured here at ~2.5s on one host (fleetd #449).
- * The old version used two fixed sleeps: 1000ms before typing, then 800ms before reading. It
- * failed, and the pane showed the typed line followed by the startup banner with no command
- * output at all — which looks, at a glance, exactly like the env map never reaching the shell.
- * So this polls for a real signal instead of guessing a sleep length.
- *
- * <p><strong>What was measured, and what was not.</strong> Polling fixes it: 5 standalone runs
- * green. The load-bearing half is {@link #waitForText}, and one cell proves it. Keep the old
- * 1000ms write sleep and change only the read — the 800ms fixed sleep becomes a 5s poll — and
- * the test goes from 0 of 3 passing to 3 of 3. Removing the write wait instead
- * ({@link #SHELL_READY_TIMEOUT_MS} set to 0, so input is typed at once) also passes 3 of 3. So
- * the cause is the 800ms READ deadline, not the 1000ms write delay. The old version fails every
- * time, not sometimes, so "race" is the wrong word for it. The earlier explanation — that input
- * typed before the prompt is swallowed by the shell's startup — is not supported by anything
- * measured here. Please do not repeat it: if it were true, typing at 0ms would be worse than
- * typing at 1000ms, and it is not.
- *
- * <p><strong>Where this was measured.</strong> A 12-core macOS host, load average 2.6 to 5.9,
- * on commit 20c1094. The same four cells were also run under load and gave the same answer, but
- * that run is not clean evidence: the load average climbed from 7 to 50 while the cells ran, and
- * the old version ran last, at the top of that climb. Above about load 20 everything here is
- * slow for reasons that have nothing to do with this seam. So read the claim as "measured near
- * idle on a 12-core host", and nothing stronger. If this test fails on a smaller or busier
- * machine, raise {@link #OUTPUT_TIMEOUT_MS} before you suspect the seam.
- *
- * <p>{@link #waitUntilSettled} is kept as cheap insurance against that swallow case, not because
- * anyone showed it was needed. If you want to delete it, the honest test is whether you can make
- * this test fail by typing early. Nobody has managed that yet.
- *
  * <p>Tagged {@code contract}; run with {@code mvn test -Pcontract}.
  */
 @Tag("contract")
 class AgentControlContractTest {
 
-    private static final long POLL_INTERVAL_MS = 150;
-    /** Bound for the seed shell to settle: observed ~2.5s three times running; this leaves headroom. */
-    private static final long SHELL_READY_TIMEOUT_MS = 8_000;
-    /** Bound for the typed command's output to appear once the shell is ready: observed ~0.2s. */
-    private static final long OUTPUT_TIMEOUT_MS = 5_000;
-
     private boolean noSocket() {
         return !Files.exists(UnixSocketHerdrClient.defaultSocketPath());
     }
 
-    private static String readPane(UnixSocketHerdrClient herdr, String paneId) {
-        return herdr.call("pane.read", Map.of("pane_id", paneId, "source", "visible"))
-                .path("read").path("text").asText("");
-    }
-
-    /**
-     * Poll {@code pane.read} until two consecutive reads come back identical — the shell's own
-     * startup output (restore banner, prompt) has stopped changing — or {@code timeoutMs} elapses.
-     * Never asserts by itself; the caller's own assertion is what actually verifies the outcome.
-     * Setting {@code timeoutMs} to 0 skips the wait entirely and the test still passes here, so
-     * treat this as insurance rather than as the fix — see the class javadoc.
-     */
-    private static String waitUntilSettled(UnixSocketHerdrClient herdr, String paneId, long timeoutMs)
-            throws InterruptedException {
-        long deadline = System.currentTimeMillis() + timeoutMs;
-        String previous = null;
-        while (System.currentTimeMillis() < deadline) {
-            Thread.sleep(POLL_INTERVAL_MS);
-            String current = readPane(herdr, paneId);
-            if (current.equals(previous) && !current.isBlank()) {
-                return current;
-            }
-            previous = current;
-        }
-        return previous == null ? "" : previous;
-    }
-
-    /** Poll {@code pane.read} until {@code needle} appears or {@code timeoutMs} elapses. */
-    private static String waitForText(UnixSocketHerdrClient herdr, String paneId, String needle, long timeoutMs)
-            throws InterruptedException {
-        long deadline = System.currentTimeMillis() + timeoutMs;
-        String last = "";
-        while (System.currentTimeMillis() < deadline) {
-            last = readPane(herdr, paneId);
-            if (last.contains(needle)) {
-                return last;
-            }
-            Thread.sleep(POLL_INTERVAL_MS);
-        }
-        return last;
-    }
-
     @Test
     void tabCreateInjectsEnvIntoTheSeedShell() throws Exception {
         assumeTrue(!noSocket(), "no herdr socket — skipping");
@@ -114,13 +36,15 @@ class AgentControlContractTest {
                     Map.of("ANTHROPIC_BASE_URL", "http://gx00.gw:8000"));
             try {
                 assertNotNull(tab.rootPaneId(), "tab.create must return the seed pane");
-                waitUntilSettled(herdr, tab.rootPaneId(), SHELL_READY_TIMEOUT_MS);
+                Thread.sleep(1000); // let the seed shell reach its prompt
                 herdr.call("pane.send_input", Map.of(
                         "pane_id", tab.rootPaneId(),
                         "text", "printf 'PROBE_BASE=[%s]\\n' \"$ANTHROPIC_BASE_URL\"",
                         "keys", List.of("enter")));
-                String visible = waitForText(herdr, tab.rootPaneId(),
-                        "PROBE_BASE=[http://gx00.gw:8000]", OUTPUT_TIMEOUT_MS);
+                Thread.sleep(800);
+                String visible = herdr.call("pane.read",
+                                Map.of("pane_id", tab.rootPaneId(), "source", "visible"))
+                        .path("read").path("text").asText("");
                 assertTrue(visible.contains("PROBE_BASE=[http://gx00.gw:8000]"),
                         "env map must reach the seed shell; saw: " + visible);
             } finally {

fleetd/src/test/java/dev/ltms/fleet/herdr/FakeHerdr.java

@@ -7,7 +7,6 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 /**
@@ -40,12 +39,8 @@ public final class FakeHerdr implements HerdrClient {
     private final Map<String, List<String>> extraTabs = new LinkedHashMap<>();
     private int agentNameTakenFor = 0;
     private int agentPaneBusyFor = 0;
-    private String agentStartErrorCode = null;
     private int workerTabPaneCount = 1;
     private String paneCloseErrorCode = null;
-    private final Map<String, String> paneCloseErrorCodeFor = new ConcurrentHashMap<>();
-    private String tabCloseErrorCode = null;
-    private final Map<String, String> tabCloseErrorCodeFor = new ConcurrentHashMap<>();
     private String agentSendErrorCode = null;
     private boolean noPanes = false;
     private volatile String agentStatus = "idle"; // steady-state agent.get status
@@ -85,56 +80,18 @@ public final class FakeHerdr implements HerdrClient {
         return this;
     }
 
-    /** Make every {@code agent.start} call fail with this herdr error code. */
-    public FakeHerdr agentStartFailsWith(String code) {
-        this.agentStartErrorCode = code;
-        return this;
-    }
-
     /** Make the worker tab (w9:t2) report this many panes in {@code tab.list} (default 1). */
     public FakeHerdr withWorkerTabPaneCount(int n) {
         this.workerTabPaneCount = n;
         return this;
     }
 
-    /** Make {@code pane.close} fail with this herdr error code, for every pane. */
+    /** Make {@code pane.close} fail with this herdr error code. */
     public FakeHerdr paneCloseFailsWith(String code) {
         this.paneCloseErrorCode = code;
         return this;
     }
 
-    /**
-     * Make {@code pane.close} fail with this herdr error code, but only for the given {@code
-     * pane_id} — every other pane's {@code pane.close} still succeeds. Unlike {@link
-     * #paneCloseFailsWith}, which fails every call regardless of which pane it targets, this lets a
-     * test reap/release several sessions at once and make exactly one of them fail to stop, so the
-     * others' teardown can be asserted to proceed normally (fleetd #290).
-     */
-    public FakeHerdr paneCloseFailsForPane(String paneId, String code) {
-        this.paneCloseErrorCodeFor.put(paneId, code);
-        return this;
-    }
-
-    /** Make {@code tab.close} fail with this herdr error code, for every tab. */
-    public FakeHerdr tabCloseFailsWith(String code) {
-        this.tabCloseErrorCode = code;
-        return this;
-    }
-
-    /**
-     * Make {@code tab.close} fail with this herdr error code, but only for the given {@code
-     * tab_id} — every other tab's {@code tab.close} still succeeds. The {@code tab.close}
-     * counterpart to {@link #paneCloseFailsForPane} (fleetd #290): lets a test make exactly one
-     * session's tab teardown fail while proving the rest of {@code stop()} — {@code
-     * releaseZdotdir}, and the caller's worktree removal — still runs (fleetd #293). Named "ForTab"
-     * rather than "ForPane" (unlike its sibling) because {@code tab.close} keys on {@code tab_id},
-     * not a pane id.
-     */
-    public FakeHerdr tabCloseFailsForTab(String tabId, String code) {
-        this.tabCloseErrorCodeFor.put(tabId, code);
-        return this;
-    }
-
     /**
      * Make {@code pane.list} report no panes at all — models a second herdr daemon (CB-185) that
      * simply does not host the pane a {@link PaneLocator} is searching for.
@@ -318,10 +275,6 @@ public final class FakeHerdr implements HerdrClient {
                                             + required + "`", "invalid_request", null);
                         }
                     }
-                    if (agentStartErrorCode != null) {
-                        throw new HerdrException("herdr error [" + agentStartErrorCode + "]: agent.start failed",
-                                agentStartErrorCode, null);
-                    }
                     long starts = calls.stream().filter(c -> c.method().equals("agent.start")).count();
                     if (starts <= agentPaneBusyFor) {
                         throw new HerdrException(
@@ -385,17 +338,7 @@ public final class FakeHerdr implements HerdrClient {
                             .formatted(workerTabPaneCount,
                                     seeded.isEmpty() ? "" : "," + String.join(",", seeded)));
                 }
-                case "tab.close" -> {
-                    Object tabIdParam = params instanceof Map<?, ?> m ? m.get("tab_id") : null;
-                    String perTabCode = tabIdParam == null ? null
-                            : tabCloseErrorCodeFor.get(String.valueOf(tabIdParam));
-                    String code = perTabCode != null ? perTabCode : tabCloseErrorCode;
-                    if (code != null) {
-                        throw new HerdrException("herdr error [" + code + "]: tab.close failed",
-                                code, null);
-                    }
-                    yield mapper.readTree("{\"type\":\"ok\"}");
-                }
+                case "tab.close" -> mapper.readTree("{\"type\":\"ok\"}");
                 case "pane.get" -> mapper.readTree("""
                         {"type":"pane_info","pane":{"pane_id":"w9:pW","workspace_id":"w9",
                           "tab_id":"w9:t2","agent_status":"idle"}}""");
@@ -417,13 +360,9 @@ public final class FakeHerdr implements HerdrClient {
                                   "foreground_processes":[]}}""");
                 }
                 case "pane.close" -> {
-                    Object paneIdParam = params instanceof Map<?, ?> m ? m.get("pane_id") : null;
-                    String perPaneCode = paneIdParam == null ? null
-                            : paneCloseErrorCodeFor.get(String.valueOf(paneIdParam));
-                    String code = perPaneCode != null ? perPaneCode : paneCloseErrorCode;
-                    if (code != null) {
-                        throw new HerdrException("herdr error [" + code + "]: pane.close failed",
-                                code, null);
+                    if (paneCloseErrorCode != null) {
+                        throw new HerdrException("herdr error [" + paneCloseErrorCode + "]: pane.close failed",
+                                paneCloseErrorCode, null);
                     }
                     yield mapper.readTree("{\"type\":\"ok\"}");
                 }

fleetd/src/test/java/dev/ltms/fleet/herdr/HerdrContractTest.java

@@ -14,7 +14,7 @@ import static org.junit.jupiter.api.Assumptions.assumeTrue;
  * Contract test against a REAL running herdr. Tagged {@code contract} so it is
  * excluded from {@code mvn test}; run it with {@code mvn test -Pcontract}. It fails
  * loudly if herdr drifts from the protocol {@code fleetd} was built against
- * (0.8.0, protocol 19) — catching breakage that unit tests with canned frames cannot.
+ * (0.7.0, protocol 14) — catching breakage that unit tests with canned frames cannot.
  */
 @Tag("contract")
 class HerdrContractTest {
@@ -24,13 +24,13 @@ class HerdrContractTest {
     }
 
     @Test
-    void pingReturnsProtocol19() {
+    void pingReturnsProtocol14() {
         assumeTrue(Files.exists(socket()), "no herdr socket at " + socket() + " — skipping");
         try (UnixSocketHerdrClient herdr = UnixSocketHerdrClient.connect()) {
             JsonNode pong = herdr.call("ping");
             assertEquals("pong", pong.get("type").asText());
-            assertEquals(19, pong.get("protocol").asInt(),
-                    "fleetd is built against herdr protocol 19");
+            assertEquals(14, pong.get("protocol").asInt(),
+                    "fleetd is built against herdr protocol 14");
             assertFalse(pong.get("version").asText().isBlank());
         }
     }

fleetd/src/test/java/dev/ltms/fleet/herdr/LeadTabScannerTest.java

@@ -6,7 +6,6 @@ import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -36,12 +35,6 @@ class LeadTabScannerTest {
         final Map<String, String[]> tabs = new LinkedHashMap<>();
         /** pane_id → [tab_id, terminal_id]. */
         final Map<String, String[]> panes = new LinkedHashMap<>();
-        /**
-         * tab_id → whether herdr reports a running agent there. Defaults to {@code true} for every
-         * tab that has a pane, so every existing fixture keeps meaning "a live lead" unless a test
-         * says otherwise via {@link #deadAgent}.
-         */
-        final Set<String> deadTabs = new LinkedHashSet<>();
         int calls;
         boolean failing;
 
@@ -60,18 +53,6 @@ class LeadTabScannerTest {
             return this;
         }
 
-        /** Mark {@code tabId} as labelled but agent-less — a dead lead's leftover tab (fleetd #359). */
-        TopologyHerdr deadAgent(String tabId) {
-            deadTabs.add(tabId);
-            return this;
-        }
-
-        /** Undo {@link #deadAgent} — models {@code agent.list} reporting the tab live again. */
-        TopologyHerdr reviveAgent(String tabId) {
-            deadTabs.remove(tabId);
-            return this;
-        }
-
         @Override
         public JsonNode call(String method, Object params) {
             calls++;
@@ -102,19 +83,6 @@ class LeadTabScannerTest {
                                     .formatted(id, p[0], p[1])));
                     return read("{\"panes\":[%s]}".formatted(String.join(",", items)));
                 }
-                case "agent.list" -> {
-                    // One agent per distinct tab that has a pane and isn't marked dead — mirrors
-                    // AgentControl.list()'s "agents" shape closely enough for the scanner's join,
-                    // which only reads tab_id off each entry.
-                    Set<String> seen = new LinkedHashSet<>();
-                    panes.forEach((paneId, p) -> {
-                        String tabId = p[0];
-                        if (!deadTabs.contains(tabId) && seen.add(tabId)) {
-                            items.add("{\"tab_id\":\"%s\"}".formatted(tabId));
-                        }
-                    });
-                    return read("{\"agents\":[%s]}".formatted(String.join(",", items)));
-                }
                 default -> throw new AssertionError("unexpected herdr call: " + method);
             }
         }
@@ -240,114 +208,6 @@ class LeadTabScannerTest {
                 scanner(herdr, twoLeadsConfigured(), new AtomicLong()).get().get("term_opus_split"));
     }
 
-    // ── fleetd #359: a labelled tab is only a lead when something is running in it ─────────────────
-
-    /**
-     * The core invariant this ticket restores: {@code get()} must never report a terminal for a
-     * lead whose pane no longer runs an agent. Before this fix the scanner joined labelled tabs to
-     * panes with no liveness check at all, so a tab left behind by a crashed/relaunched lead (see
-     * {@code LeadLauncher}'s own staleness handling) was reported as live forever — which is exactly
-     * what let duplicate lead tabs make {@code LeadCoordLoop.resolveLocalLead()} permanently unable
-     * to pick one. Mutate this away (drop the {@code agent.list} cross-check in {@link
-     * LeadTabScanner#scan()}) and this test must fail.
-     */
-    @Test
-    void aLabelledTabWithNoRunningAgentIsNotReported() {
-        TopologyHerdr herdr = twoLeads().deadAgent("w1:t1"); // opus-5.0's tab is labelled but dead
-
-        Map<String, String> leads = scanner(herdr, twoLeadsConfigured(), new AtomicLong()).get();
-
-        assertFalse(leads.containsKey("term_opus"),
-                "a labelled tab with no running agent must never be reported as a live lead");
-        assertEquals("gpt-sol-5.6", leads.get("term_gpt"),
-                "the other, genuinely live lead must be unaffected");
-    }
-
-    /**
-     * The other direction, pinned separately so a fix cannot satisfy the test above by simply
-     * returning nothing: a labelled tab that DOES have a running agent must still be reported. A
-     * scanner that always comes back empty is worse than the bug it fixes.
-     */
-    @Test
-    void aLabelledTabWithARunningAgentIsStillReported() {
-        Map<String, String> leads = scanner(twoLeads(), twoLeadsConfigured(), new AtomicLong()).get();
-
-        assertEquals("opus-5.0", leads.get("term_opus"));
-        assertEquals("gpt-sol-5.6", leads.get("term_gpt"));
-    }
-
-    /**
-     * fleetd #359 review, finding 2 — the exact scenario the ticket's own evidence showed:
-     * {@code agent.list} can come back successfully but short, without the herdr call ever throwing.
-     * A lead this class already reported as live must not be dropped on the strength of one such
-     * read: {@link LeadTabScanner#get()}'s "keep the cache on failure" contract only fires on an
-     * exception, so without a fix a single short {@code agent.list} silently empties the cached map —
-     * which would resolve that lead's pane as {@code Role.WORKER} downstream, refusing every
-     * orchestration call. Mutate this away (drop the one-scan grace in {@link
-     * LeadTabScanner#scan()}) and this test must fail.
-     */
-    @Test
-    void aTransientAgentListMissDoesNotDemoteALeadAlreadyKnownLive() {
-        TopologyHerdr herdr = twoLeads();
-        AtomicLong clock = new AtomicLong();
-        LeadTabScanner s = scanner(herdr, twoLeadsConfigured(), clock);
-        assertTrue(s.get().containsKey("term_opus"), "opus must be known live before the miss");
-
-        // One scan where agent.list comes back without opus's tab, even though the tab and pane are
-        // completely unchanged — the tab/pane are still there, only the liveness read is short.
-        herdr.deadAgent("w1:t1");
-        clock.addAndGet(TTL);
-
-        assertTrue(s.get().containsKey("term_opus"),
-                "a single missed detection must not empty the cached map for a lead already known live");
-        assertEquals("gpt-sol-5.6", s.get().get("term_gpt"), "the unaffected lead is unchanged");
-    }
-
-    /**
-     * The other half of finding 2, so the grace above cannot be mistaken for permanent amnesty: the
-     * original #359 invariant (a genuinely dead tab is not reported forever) must still hold once a
-     * SECOND, independent scan agrees the agent is gone.
-     */
-    @Test
-    void aLeadMissingFromAgentListOnTwoConsecutiveScansIsFinallyDropped() {
-        TopologyHerdr herdr = twoLeads();
-        AtomicLong clock = new AtomicLong();
-        LeadTabScanner s = scanner(herdr, twoLeadsConfigured(), clock);
-        assertTrue(s.get().containsKey("term_opus"));
-
-        herdr.deadAgent("w1:t1");
-        clock.addAndGet(TTL);
-        assertTrue(s.get().containsKey("term_opus"), "first miss is a grace period, not a verdict");
-
-        clock.addAndGet(TTL); // a second, independent scan — still no agent
-        assertFalse(s.get().containsKey("term_opus"),
-                "a second consecutive miss for the same terminal must finally drop it");
-    }
-
-    /** A lead that recovers between the two misses keeps its grace spent, not renewed for free. */
-    @Test
-    void aLeadThatRecoversBetweenMissesIsReportedNormallyAndResetsItsGrace() {
-        TopologyHerdr herdr = twoLeads();
-        AtomicLong clock = new AtomicLong();
-        LeadTabScanner s = scanner(herdr, twoLeadsConfigured(), clock);
-        assertTrue(s.get().containsKey("term_opus"));
-
-        herdr.deadAgent("w1:t1");
-        clock.addAndGet(TTL);
-        assertTrue(s.get().containsKey("term_opus"), "graced on the first miss");
-
-        herdr.reviveAgent("w1:t1"); // the miss really was transient
-        clock.addAndGet(TTL);
-        assertTrue(s.get().containsKey("term_opus"), "found live again — reported normally");
-
-        // A later, unrelated miss must get its own fresh grace scan rather than being dropped
-        // immediately because the earlier miss had already "used up" a slot for this terminal.
-        herdr.deadAgent("w1:t1");
-        clock.addAndGet(TTL);
-        assertTrue(s.get().containsKey("term_opus"),
-                "a miss after a genuine recovery is a new event and deserves its own grace scan");
-    }
-
     /**
      * CB-579 acceptance (6): this is the bug the ticket closes. A stale pin used to be merged back
      * over every scan and never expire; now a scan is the whole answer, so a lead whose tab is gone

fleetd/src/test/java/dev/ltms/fleet/inject/CompletionResolverTest.java

@@ -20,7 +20,6 @@ import java.util.regex.Pattern;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /** Unit behaviour of the CB-106 completion resolver in isolation from the injector. */
@@ -358,54 +357,6 @@ class CompletionResolverTest {
                 "the failure carries whatever was on screen: " + waiter.getNow(null).text());
     }
 
-    @Test
-    void aPlausibleLookingReplyInsideTheFloorStillFails() {
-        // fleetd#376 guard. A fix was attempted that inspected the pane inside the floor and resolved
-        // a COMPLETION when the text "looked like a real reply". Every cheap test for that is unsafe:
-        // lastAssistantBlock falls back to the WHOLE pane when there is no ⏺ marker, and a crash pane
-        // almost always contains sentence punctuation — in a file path, a version, or a hostname.
-        // This pane is the trap: it reads like a finished answer and it is a backend failure.
-        FakeHerdr herdr = new FakeHerdr().readText(
-                "Error: connection reset while loading src/main/java/Foo.java v1.2.3\n❯ ");
-        Rendezvous rendezvous = new Rendezvous();
-        long[] clock = {10_000_000_000L};
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous,
-                ExhaustedPatternLookup.none(), ExhaustionSink.none(), () -> clock[0]);
-
-        var waiter = rendezvous.open("term_a");
-        var turn = new CompletionResolver.InFlight(waiter, null, clock[0]);
-        clock[0] += CompletionResolver.MIN_TURN_NANOS - 1; // inside the floor
-
-        resolver.resolve("term_a", turn);
-
-        assertEquals(Rendezvous.Kind.FAILED, waiter.getNow(null).kind(),
-                "inside the floor the verdict is always FAILED — never guess a completion from pane text");
-    }
-
-    @Test
-    void theTooFastFailureDoesNotAssertACauseItCannotKnow() {
-        // fleetd#376: the message used to say "most likely a backend error before any work started".
-        // When no error pattern matches, that cause is a guess, and a reader who believes it stops
-        // looking at the pane. The verdict stays FAILED; only the claim about WHY is withdrawn.
-        FakeHerdr herdr = new FakeHerdr().readText("I am running on opencode/mimo-v2.5-free.\n❯ ");
-        Rendezvous rendezvous = new Rendezvous();
-        long[] clock = {10_000_000_000L};
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous,
-                ExhaustedPatternLookup.none(), ExhaustionSink.none(), () -> clock[0]);
-
-        var waiter = rendezvous.open("term_a");
-        var turn = new CompletionResolver.InFlight(waiter, null, clock[0]);
-        clock[0] += CompletionResolver.MIN_TURN_NANOS - 1; // inside the floor
-
-        resolver.resolve("term_a", turn);
-
-        String text = waiter.getNow(null).text();
-        assertEquals(Rendezvous.Kind.FAILED, waiter.getNow(null).kind(), "still fails, still loud");
-        assertFalse(text.contains("most likely a backend error"),
-                "an unmatched fast turn must not assert a backend error: " + text);
-        assertTrue(text.contains("mimo-v2.5-free"), "the pane is still carried: " + text);
-    }
-
     @Test
     void aBusyToDoneTransitionJustOutsideTheFloorResolvesNormally() {
         FakeHerdr herdr = new FakeHerdr().readText("⏺ a real, if quick, answer\n❯ ");
@@ -533,27 +484,6 @@ class CompletionResolverTest {
 
     // --- CB-578 stage A: backend-exhausted classification ---------------------------------
 
-    @Test
-    void aNormalMemberReportMentioningTheExhaustionPatternDoesNotNotifyTheSink() {
-        String block = "⏺ I reviewed capacity handling. The usage limit has been reached means no more work can start.\n❯ ";
-        FakeHerdr herdr = new FakeHerdr().readText(block);
-        Rendezvous rendezvous = new Rendezvous();
-        ExhaustedPatternLookup patterns = target -> Pattern.compile("usage limit has been reached");
-        java.util.List<String> notified = new java.util.ArrayList<>();
-        ExhaustionSink sink = (target, reason, profile) -> notified.add(target + ": " + reason);
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous, patterns, sink);
-
-        var waiter = rendezvous.open("term_a");
-        resolver.resolve("term_a", new CompletionResolver.InFlight(waiter, null));
-
-        assertEquals(Rendezvous.Kind.BACKEND_EXHAUSTED, waiter.getNow(null).kind(),
-                "a matching report still fails the send as exhausted");
-        assertTrue(waiter.getNow(null).text().contains("I reviewed capacity handling."),
-                "the exhausted result keeps the whole matched pane line");
-        assertTrue(notified.isEmpty(),
-                "a normal report mentioning an exhaustion pattern must not quarantine a credential");
-    }
-
     @Test
     void classifiesAMatchingScrapeAsBackendExhaustedInsteadOfACompletedReply() {
         String block = "⏺ Working on it...\nThe usage limit has been reached. Try again later.\n❯ ";
@@ -604,53 +534,6 @@ class CompletionResolverTest {
                 "the sink is told the matched reason: " + notified.get(0));
     }
 
-    @Test
-    void aRealExhaustionBehindTerminalChromeStillNotifiesTheSink() {
-        String block = "⏺ │ The usage limit has been reached. Try again later.\n❯ ";
-        FakeHerdr herdr = new FakeHerdr().readText(block);
-        Rendezvous rendezvous = new Rendezvous();
-        ExhaustedPatternLookup patterns = target -> Pattern.compile("usage limit has been reached");
-        java.util.List<String> notified = new java.util.ArrayList<>();
-        ExhaustionSink sink = (target, reason, profile) -> notified.add(target + ": " + reason);
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous, patterns, sink);
-
-        var waiter = rendezvous.open("term_a");
-        resolver.resolve("term_a", new CompletionResolver.InFlight(waiter, null));
-
-        assertEquals(Rendezvous.Kind.BACKEND_EXHAUSTED, waiter.getNow(null).kind(),
-                "a real exhaustion must still fail the send as exhausted");
-        assertEquals(1, notified.size(),
-                "a real exhaustion behind terminal chrome must reach the sink");
-    }
-
-    /**
-     * The live fleet configures {@code exhaustedPattern: "The usage limit has been reached"} — with
-     * the leading {@code "The"}. Every other test here uses a pattern without it, which is the shape
-     * that made fleetd #348 need a looser rule than a start-of-line check. This pins the deployed
-     * shape as well, so a later tightening of {@link CompletionResolver} cannot silently stop
-     * recording the exhaustion this fleet actually reports.
-     *
-     * <p>What it does not prove: that this is the only pattern shape an operator will write.
-     */
-    @Test
-    void anExhaustionPatternCarryingItsLeadingWordsStillNotifiesTheSink() {
-        String block = "⏺ │ The usage limit has been reached. Try again later.\n❯ ";
-        FakeHerdr herdr = new FakeHerdr().readText(block);
-        Rendezvous rendezvous = new Rendezvous();
-        ExhaustedPatternLookup patterns = target -> Pattern.compile("The usage limit has been reached");
-        java.util.List<String> notified = new java.util.ArrayList<>();
-        ExhaustionSink sink = (target, reason, profile) -> notified.add(target + ": " + reason);
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous, patterns, sink);
-
-        var waiter = rendezvous.open("term_a");
-        resolver.resolve("term_a", new CompletionResolver.InFlight(waiter, null));
-
-        assertEquals(Rendezvous.Kind.BACKEND_EXHAUSTED, waiter.getNow(null).kind(),
-                "the live pattern shape must still fail the send as exhausted");
-        assertEquals(1, notified.size(),
-                "the live pattern shape must still reach the sink");
-    }
-
     @Test
     void aLosingBackendExhaustedClassificationNeverNotifiesTheExhaustionSink() {
         // The waiter was already resolved (e.g. by the worker's own reply) before this scrape landed —
@@ -885,22 +768,19 @@ class CompletionResolverTest {
     @Test
     void coverageIsOffWhenNoProfileHasAPatternConfigured() {
         assertEquals("off (no profile has an exhaustedPattern configured; profiles: [terra])",
-                CompletionResolver.coverage("exhaustedPattern", CompletionResolver.UnsetMeaning.OFF,
-                        Set.of("terra"), Set.of()));
+                CompletionResolver.coverage("exhaustedPattern", Set.of("terra"), Set.of()));
     }
 
     @Test
     void coverageIsFullWhenEveryProfileHasAPatternConfigured() {
         assertEquals("full (all profiles configured: [gx10, terra])",
-                CompletionResolver.coverage("exhaustedPattern", CompletionResolver.UnsetMeaning.OFF,
-                        Set.of("terra", "gx10"), Set.of("terra", "gx10")));
+                CompletionResolver.coverage("exhaustedPattern", Set.of("terra", "gx10"), Set.of("terra", "gx10")));
     }
 
     @Test
     void coverageIsPartialAndNamesWhichProfilesAreConfigured() {
         assertEquals("partial (configured: [terra]; not configured: [gx10])",
-                CompletionResolver.coverage("exhaustedPattern", CompletionResolver.UnsetMeaning.OFF,
-                        Set.of("terra", "gx10"), Set.of("terra")));
+                CompletionResolver.coverage("exhaustedPattern", Set.of("terra", "gx10"), Set.of("terra")));
     }
 
     /**
@@ -914,69 +794,17 @@ class CompletionResolverTest {
      *
      * <p>Every earlier test here passed the exhaustion case only, so none of them could see it. This
      * one pins that the message names the key the caller actually meant.
-     *
-     * <p>fleetd#415: the expected wording changed here too. {@code errorPattern} has a built-in
-     * fallback ({@link CompletionResolver#BACKEND_ERROR}), so an empty {@code configuredProfiles}
-     * for it is not "off" — see {@link #coverageDistinguishesOffFromBuiltInDefaultForTheSameEmptyInput}
-     * for the test built specifically to pin that distinction.
      */
     @Test
     void coverageNamesTheConfigKeyItsCallerMeansRatherThanAlwaysSayingExhaustedPattern() {
-        assertEquals("built-in default for all profiles (no profile customises errorPattern; "
-                        + "profiles: [gx10, terra])",
-                CompletionResolver.coverage("errorPattern", CompletionResolver.UnsetMeaning.BUILT_IN_DEFAULT,
-                        Set.of("terra", "gx10"), Set.of()));
-    }
-
-    /**
-     * fleetd#415: {@code coverage()} measures pattern coverage (how many profiles set the key), but
-     * for {@code errorPattern} the empty case is not the feature-off state — a profile with no
-     * configured {@code errorPattern} still runs the classification against
-     * {@link CompletionResolver#BACKEND_ERROR}. For {@code exhaustedPattern} there is no fallback,
-     * so empty really is off. Same shape of input (empty {@code configuredProfiles}, one profile),
-     * different {@link CompletionResolver.UnsetMeaning} — the wording must differ, or this method is
-     * back to conflating pattern coverage with feature state for the one key where they disagree.
-     */
-    @Test
-    void coverageDistinguishesOffFromBuiltInDefaultForTheSameEmptyInput() {
-        String exhaustedLine = CompletionResolver.coverage("exhaustedPattern",
-                CompletionResolver.UnsetMeaning.OFF, Set.of("gx10", "terra"), Set.of());
-        String errorLine = CompletionResolver.coverage("errorPattern",
-                CompletionResolver.UnsetMeaning.BUILT_IN_DEFAULT, Set.of("gx10", "terra"), Set.of());
-
-        assertEquals("off (no profile has an exhaustedPattern configured; profiles: [gx10, terra])",
-                exhaustedLine);
-        assertEquals("built-in default for all profiles (no profile customises errorPattern; "
-                        + "profiles: [gx10, terra])", errorLine);
-        assertNotEquals(exhaustedLine, errorLine,
-                "the same empty-coverage input must not read as the same feature state for both keys");
+        assertEquals("off (no profile has an errorPattern configured; profiles: [gx10, terra])",
+                CompletionResolver.coverage("errorPattern", Set.of("terra", "gx10"), Set.of()));
     }
 
     // --- fleetd#201 Unit 1: target-keyed backend-error pattern + typed sink ----------------------
 
     @Test
-    void aNormalMemberReportMentioningTheFallbackErrorPatternFailsButDoesNotNotifyTheSink() {
-        String block = "⏺ I checked the retry path. An API Error: makes it back off.\n❯ ";
-        FakeHerdr herdr = new FakeHerdr().readText(block);
-        Rendezvous rendezvous = new Rendezvous();
-        java.util.List<String> notified = new java.util.ArrayList<>();
-        BackendErrorSink sink = (target, matchedLine, reason) -> notified.add(target + ": " + matchedLine);
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous,
-                ExhaustedPatternLookup.none(), ExhaustionSink.none(), BackendErrorPatternLookup.legacy(), sink);
-
-        var waiter = rendezvous.open("term_a");
-        resolver.resolve("term_a", new CompletionResolver.InFlight(waiter, null));
-
-        assertEquals(Rendezvous.Kind.FAILED, waiter.getNow(null).kind(),
-                "a scrape mentioning the pattern must still fail the send");
-        assertTrue(waiter.getNow(null).text().contains("I checked the retry path. An API Error: makes it back off."),
-                "the failure must keep the whole pane tail");
-        assertTrue(notified.isEmpty(),
-                "a normal report mentioning the fallback pattern must not record a credential failure");
-    }
-
-    @Test
-    void aConfiguredBackendErrorPatternAtTheStartOfALineClassifiesAMatchAndNotifiesTheSinkOnce() {
+    void aConfiguredBackendErrorPatternClassifiesAMatchAsAFailureAndNotifiesTheSinkOnce() {
         String block = "⏺ 503 Service Unavailable: upstream credential rejected\n❯ ";
         FakeHerdr herdr = new FakeHerdr().readText(block);
         Rendezvous rendezvous = new Rendezvous();
@@ -1096,7 +924,7 @@ class CompletionResolverTest {
     }
 
     @Test
-    void aConfiguredPatternAtTheStartOfALineAlsoClassifiesTheRawScrapeFallbackAndNotifiesTheSink() {
+    void aConfiguredPatternAlsoClassifiesTheRawScrapeFallbackAndNotifiesTheSink() {
         // No ⏺ marker and leading TUI chrome ⇒ lastAssistantBlock() yields "", so classification must
         // fall back to the raw scrape (fleetd#211) — and it must use the configured pattern too.
         String block = """
@@ -1121,40 +949,6 @@ class CompletionResolverTest {
         assertTrue(notified.get(0).contains("503 Service Unavailable"), notified.get(0));
     }
 
-    /**
-     * fleetd #339 follow-up: a genuine backend error rendered behind terminal chrome must still
-     * record the credential outage. #339 added a start-of-line check to stop a member's own prose
-     * being counted as an outage, and a bare {@code lookingAt} also rejected this — the send failed
-     * but the sink never fired. #339's invariant 3 named that direction as the worse one: a real
-     * outage going unrecorded leaves the fleet spawning into a dead credential.
-     *
-     * <p>The raw-scrape path is where this matters, because its own comment says to expect leading
-     * TUI chrome there.
-     */
-    @Test
-    void aRealErrorBehindTerminalChromeStillNotifiesTheSink() {
-        String block = """
-                ╭──────────────────────────────────────╮
-                │ 503 Service Unavailable: upstream credential rejected
-                """;
-        FakeHerdr herdr = new FakeHerdr().readText(block);
-        Rendezvous rendezvous = new Rendezvous();
-        BackendErrorPatternLookup patterns = target -> Pattern.compile("(?i)503 Service Unavailable");
-        java.util.List<String> notified = new java.util.ArrayList<>();
-        BackendErrorSink sink = (target, matchedLine, reason) -> notified.add(target + ": " + matchedLine);
-        CompletionResolver resolver = new CompletionResolver(new AgentControl(herdr), rendezvous,
-                ExhaustedPatternLookup.none(), ExhaustionSink.none(), patterns, sink);
-
-        var waiter = rendezvous.open("term_a");
-        resolver.resolve("term_a", new CompletionResolver.InFlight(waiter, null));
-
-        assertEquals(Rendezvous.Kind.FAILED, waiter.getNow(null).kind(),
-                "a real backend error must still fail the send");
-        assertEquals(1, notified.size(),
-                "a real error line behind box chrome is still a real outage — it must reach the sink, "
-                        + "or the fleet keeps spawning into a dead credential");
-    }
-
     // --- fleetd#201 Unit 1: classification inside the fleetd#164 MIN_TURN_NANOS floor -------------
 
     @Test
@@ -1200,16 +994,8 @@ class CompletionResolverTest {
         assertTrue(waiter.isDone());
         assertEquals(Rendezvous.Kind.FAILED, waiter.getNow(null).kind(),
                 "still a failure — the floor itself, not the pattern, is why");
-        // fleetd#376: this used to assert the phrase "too fast to be real work", which carried the
-        // claim "most likely a backend error before any work started". With no pattern matched that
-        // cause is a guess, so the wording was withdrawn. What this test really guards is unchanged:
-        // the floor alone still fails the turn, it stays generic, and it never notifies the sink.
-        String reason = waiter.getNow(null).text();
-        assertTrue(reason.contains("inside the floor"),
-                "a non-match inside the floor stays the generic floor reason: " + reason);
-        assertFalse(reason.contains("most likely a backend error"),
-                "a non-match must not assert a cause it did not establish: " + reason);
-        assertTrue(reason.contains("still starting up"), "the pane is still carried: " + reason);
+        assertTrue(waiter.getNow(null).text().contains("too fast to be real work"),
+                "a non-match inside the floor stays the generic too-fast reason: " + waiter.getNow(null).text());
         assertTrue(notified.isEmpty(), "a non-match must never notify the typed sink");
     }
 }

fleetd/src/test/java/dev/ltms/fleet/inject/InjectorTest.java

@@ -48,7 +48,7 @@ class InjectorTest {
 
     @Test
     void deliversWhenIdle() {
-        CompletableFuture<Void> f = injector.enqueue(T, "hello", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> f = injector.enqueue(T, "hello", TestTurnTokens.inert(T));
         assertFalse(f.isDone(), "not delivered until an injectable status arrives");
         injector.onStatus(T, AgentStatus.IDLE);
         assertTrue(f.isDone());
@@ -170,32 +170,6 @@ class InjectorTest {
         assertEquals(List.of("a", "b", "c"), sent());
     }
 
-    @Test
-    void cancellingTheMiddleDeliveryKeepsTheFollowingDeliveryReachable() {
-        Injector.Delivery first = injector.enqueue(T, "same text", TestTurnTokens.inert(T));
-        Injector.Delivery cancelled = injector.enqueue(T, "same text", TestTurnTokens.inert(T));
-        injector.enqueue(T, "after cancelled", TestTurnTokens.inert(T));
-
-        assertEquals(Injector.Cancellation.CANCELLED, injector.cancel(cancelled));
-        injector.onStatus(T, AgentStatus.IDLE);
-        injector.onStatus(T, AgentStatus.WORKING);
-        injector.onStatus(T, AgentStatus.IDLE);
-
-        assertEquals(List.of("same text", "after cancelled"), sent(),
-                "cancellation must match the exact Delivery and preserve the remaining FIFO queue");
-        assertTrue(first.completion().isDone());
-    }
-
-    @Test
-    void cancellationReportsDeliveredWhenPickupWonTheRace() {
-        Injector.Delivery delivery = injector.enqueue(T, "already sent", TestTurnTokens.inert(T));
-        injector.onStatus(T, AgentStatus.IDLE);
-
-        assertEquals(Injector.Cancellation.DELIVERED, injector.cancel(delivery),
-                "a cancellation after pickup must not claim that the text stayed queued");
-        assertEquals(List.of("already sent"), sent());
-    }
-
     @Test
     void activeWhileQueuedOrInFlightThenQuietAfterTurnCompletes() {
         assertTrue(injector.activeTargets().isEmpty());
@@ -323,68 +297,6 @@ class InjectorTest {
         assertTrue(inj.activeTargets().isEmpty(), "the wedged target is reclaimed, not polled forever");
     }
 
-    /** A listener whose post-turn housekeeping always starts, as SessionManager's does with clearAfterTurn on. */
-    private static final class PostTurnListener implements TurnListener {
-        @Override public void onTurnComplete(String target) { }
-        @Override public boolean hasPostTurnAction(String target) { return true; }
-        @Override public boolean onTurnCompleteWithPostAction(String target) { return true; }
-    }
-
-    @Test
-    void aWorkerThatWedgesInUnknownAwaitingPostTurnPickupIsReleased() {
-        // fleetd #306: the post-turn phase had no way out of a sustained unknown streak, so the
-        // pickup latch stayed set, the target was polled forever, and every later message to it was
-        // blocked by the delivery gate — while the session still looked healthy.
-        Captor cap = new Captor();
-        Injector inj = new Injector(new AgentControl(herdr), new PostTurnListener());
-        inj.enqueue(T, "task", TestTurnTokens.inert(T));
-
-        inj.onStatus(T, AgentStatus.IDLE);    // deliver
-        inj.onStatus(T, AgentStatus.WORKING); // turn starts
-        inj.onStatus(T, AgentStatus.IDLE);    // turn completes; housekeeping dispatched
-        for (int i = 0; i < STALL_SAMPLES; i++) inj.onStatus(T, AgentStatus.UNKNOWN); // then wedges
-
-        assertTrue(inj.activeTargets().isEmpty(),
-                "a target wedged awaiting post-turn pickup must be reclaimed, not polled forever");
-        assertEquals(List.of(), cap.failed,
-                "the delegated turn already completed — a stuck /clear must not be reported as a failed turn");
-    }
-
-    @Test
-    void aWorkerThatWedgesInUnknownAfterPickingUpTheResetIsReleased() {
-        // The sibling latch. postTurnObserved is set when the reset is seen picked up (WORKING) and
-        // is cleared only on a later injectable sample, so a wedge right after pickup sticks too.
-        Captor cap = new Captor();
-        Injector inj = new Injector(new AgentControl(herdr), new PostTurnListener());
-        inj.enqueue(T, "task", TestTurnTokens.inert(T));
-
-        inj.onStatus(T, AgentStatus.IDLE);
-        inj.onStatus(T, AgentStatus.WORKING);
-        inj.onStatus(T, AgentStatus.IDLE);    // turn complete; reset dispatched
-        inj.onStatus(T, AgentStatus.WORKING); // reset picked up -> postTurnObserved
-        for (int i = 0; i < STALL_SAMPLES; i++) inj.onStatus(T, AgentStatus.UNKNOWN);
-
-        assertTrue(inj.activeTargets().isEmpty(), "a wedge after reset pickup must also be reclaimed");
-        assertEquals(List.of(), cap.failed, "still not a turn failure");
-    }
-
-    @Test
-    void aBriefUnknownDuringPostTurnHousekeepingDoesNotDropTheLatch() {
-        // The other direction: the escape must not fire on a glitch, or the queued next delegation
-        // would overtake housekeeping that is still running.
-        Injector inj = new Injector(new AgentControl(herdr), new PostTurnListener());
-        inj.enqueue(T, "first", TestTurnTokens.inert(T));
-        inj.enqueue(T, "second", TestTurnTokens.inert(T));
-
-        inj.onStatus(T, AgentStatus.IDLE);
-        inj.onStatus(T, AgentStatus.WORKING);
-        inj.onStatus(T, AgentStatus.IDLE);    // first completes; reset dispatched
-        for (int i = 0; i < 10; i++) inj.onStatus(T, AgentStatus.UNKNOWN); // well under the grace
-
-        assertFalse(inj.activeTargets().isEmpty(), "a brief glitch must not release the post-turn latch");
-        assertEquals(List.of("first"), sent(), "the queued delegation must not overtake housekeeping");
-    }
-
     @Test
     void aTransientUnknownGlitchNeitherFailsNorBlocksCompletion() {
         Captor cap = new Captor();
@@ -404,7 +316,7 @@ class InjectorTest {
     void sendFailureDropsMessageAndFailsItsFuture() {
         FakeHerdr failing = new FakeHerdr().agentSendFailsWith("send_failed");
         Injector inj = new Injector(new AgentControl(failing));
-        CompletableFuture<Void> f = inj.enqueue(T, "boom", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> f = inj.enqueue(T, "boom", TestTurnTokens.inert(T));
 
         inj.onStatus(T, AgentStatus.IDLE);
         assertTrue(f.isCompletedExceptionally());
@@ -413,7 +325,7 @@ class InjectorTest {
 
     @Test
     void dropFailsPendingWaiters() {
-        CompletableFuture<Void> f = injector.enqueue(T, "orphan", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> f = injector.enqueue(T, "orphan", TestTurnTokens.inert(T));
         injector.drop(T, new HerdrException("worker gone", "pane_not_found", null));
         assertTrue(f.isCompletedExceptionally(), "queued waiters unblock when the worker vanishes");
     }
@@ -422,8 +334,8 @@ class InjectorTest {
     void dropPassesTheRealCauseForQueuedAndDeliveredWork() {
         Captor cap = new Captor();
         Injector inj = new Injector(new AgentControl(herdr), cap);
-        CompletableFuture<Void> delivered = inj.enqueue(T, "delivered", TestTurnTokens.inert(T)).completion();
-        CompletableFuture<Void> queued = inj.enqueue(T, "queued", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> delivered = inj.enqueue(T, "delivered", TestTurnTokens.inert(T));
+        CompletableFuture<Void> queued = inj.enqueue(T, "queued", TestTurnTokens.inert(T));
 
         inj.onStatus(T, AgentStatus.IDLE);    // deliver the first message
         inj.onStatus(T, AgentStatus.WORKING); // its turn is now in flight; one remains queued
@@ -475,7 +387,7 @@ class InjectorTest {
         Captor cap = new Captor();
         List<String> forgotten = new ArrayList<>();
         Injector inj = new Injector(new AgentControl(herdr), cap, _ -> false, forgotten::add);
-        CompletableFuture<Void> f = inj.enqueue(T, "task", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> f = inj.enqueue(T, "task", TestTurnTokens.inert(T));
 
         for (int i = 0; i < READINESS_SAMPLES; i++) inj.onStatus(T, AgentStatus.IDLE);
 
@@ -589,7 +501,7 @@ class InjectorTest {
         StatusPoller poller = new StatusPoller(new AgentControl(idle), inj, 10);
         poller.start();
         try {
-            CompletableFuture<Void> delivered = inj.enqueue(T, "via-poller", TestTurnTokens.inert(T)).completion();
+            CompletableFuture<Void> delivered = inj.enqueue(T, "via-poller", TestTurnTokens.inert(T));
             delivered.get(2, TimeUnit.SECONDS); // completes when the poller drives the send
         } finally {
             poller.stop();
@@ -608,7 +520,7 @@ class InjectorTest {
     void deliveredFutureCarriesSendFailure() {
         FakeHerdr failing = new FakeHerdr().agentSendFailsWith("send_failed");
         Injector inj = new Injector(new AgentControl(failing));
-        CompletableFuture<Void> f = inj.enqueue(T, "boom", TestTurnTokens.inert(T)).completion();
+        CompletableFuture<Void> f = inj.enqueue(T, "boom", TestTurnTokens.inert(T));
         inj.onStatus(T, AgentStatus.IDLE);
         ExecutionException ex = assertThrows(ExecutionException.class, f::get);
         assertInstanceOf(HerdrException.class, ex.getCause());

fleetd/src/test/java/dev/ltms/fleet/inject/StatusPollerRoutingTest.java

@@ -41,7 +41,7 @@ class StatusPollerRoutingTest {
         poller.start();
         try {
             CompletableFuture<Void> delivered =
-                    injector.enqueue(LEAD_TARGET, "via-poller", TestTurnTokens.inert(LEAD_TARGET)).completion();
+                    injector.enqueue(LEAD_TARGET, "via-poller", TestTurnTokens.inert(LEAD_TARGET));
             // Must resolve quickly: refining against the WRONG daemon (member) never classifies
             // out of UNKNOWN, so this would time out under the bug.
             delivered.get(2, TimeUnit.SECONDS);
@@ -65,7 +65,7 @@ class StatusPollerRoutingTest {
         poller.start();
         try {
             CompletableFuture<Void> delivered =
-                    injector.enqueue(LEAD_TARGET, "via-poller", TestTurnTokens.inert(LEAD_TARGET)).completion();
+                    injector.enqueue(LEAD_TARGET, "via-poller", TestTurnTokens.inert(LEAD_TARGET));
             assertThrows(TimeoutException.class, () -> delivered.get(500, TimeUnit.MILLISECONDS),
                     "a lead target must never be refined from the member daemon's pane content");
         } finally {

fleetd/src/test/java/dev/ltms/fleet/lead/LeadLauncherTest.java

@@ -9,7 +9,6 @@ import org.junit.jupiter.api.Test;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -107,7 +106,6 @@ class LeadLauncherTest {
 
         assertEquals(0, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads());
         assertFalse(herdr.called("agent.start"), "the live lead must not be duplicated");
-        assertFalse(herdr.called("tab.close"), "a labelled tab WITH a live agent must never be closed");
     }
 
     /**
@@ -124,121 +122,6 @@ class LeadLauncherTest {
                 "a stale label is not a lead; the lead must be relaunched");
     }
 
-    /**
-     * fleetd #359 review finding 1 — the exact scenario the ticket's own live evidence produced: on a
-     * real host, {@code agent.list} reported "0 live" for a tab a plain {@code ps} confirmed was
-     * running a real session. A single such reading must never close the tab outright — that would
-     * destroy the operator's actual lead, a worse failure than the stale-tab bug this ticket exists
-     * to fix. The first dead reading only flags the tab; mutate this away (make the first reading
-     * close instead of flag) and this test must fail.
-     */
-    @Test
-    void aStaleLabelledTabIsFlaggedRatherThanClosedOnTheFirstReconcile() {
-        FakeHerdr herdr = new FakeHerdr()
-                .withWorkspace("wL", "fleet")
-                .withTab("wL", "wL:t1", "lead: opus"); // label only, first look — could be a live session agent.list missed
-
-        assertEquals(1, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads());
-
-        assertFalse(herdr.called("tab.close"),
-                "one missed reading must never close a tab that might be hosting a live session");
-        assertTrue(flaggedTabIds(herdr).contains("wL:t1"),
-                "the stale tab must be flagged pending-close so a later reconcile can confirm it");
-    }
-
-    /**
-     * The operator's own trace on fleet01 (#359): a daemon that restarted several times, each
-     * occasion finding "0 live" for whatever reason, had left several identically-labelled dead
-     * tabs sitting side by side. Every one of them is flagged on its first dead reading, not closed —
-     * none is more or less trustworthy than another.
-     */
-    @Test
-    void allStaleLabelledTabsAreFlaggedRatherThanClosedOnTheFirstReconcile() {
-        FakeHerdr herdr = new FakeHerdr()
-                .withWorkspace("wL", "fleet")
-                .withTab("wL", "wL:t1", "lead: opus")
-                .withTab("wL", "wL:t2", "lead: opus")
-                .withTab("wL", "wL:t3", "lead: opus"); // three restarts' worth of debris, none confirmed twice yet
-
-        assertEquals(1, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads());
-
-        assertFalse(herdr.called("tab.close"), "no tab may be closed on its first dead reading");
-        assertEquals(Set.of("wL:t1", "wL:t2", "wL:t3"), flaggedTabIds(herdr),
-                "every dead labelled tab must be flagged, not just the first one found");
-    }
-
-    /**
-     * fleetd #359 review finding 1, the other half — a tab already flagged pending-close by an
-     * earlier reconcile, and STILL dead on this one, has now been read dead on two independent,
-     * separately-connected reconciles. That is strong enough evidence to actually close it. Mutate
-     * this away (never close a flagged tab) and this test must fail — the original #359 growth bug
-     * would come back for good.
-     */
-    @Test
-    void aTabAlreadyFlaggedPendingCloseIsClosedWhenStillDeadOnALaterReconcile() {
-        FakeHerdr herdr = new FakeHerdr()
-                .withWorkspace("wL", "fleet")
-                .withTab("wL", "wL:t1", "lead: opus [fleetd:pending-close]"); // flagged last reconcile, still dead
-
-        assertEquals(1, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads());
-
-        assertTrue(herdr.called("tab.close"),
-                "a tab dead on two independent reconciles must finally be closed");
-        assertEquals("wL:t1", ((Map<?, ?>) herdr.lastCall("tab.close").params()).get("tab_id"));
-    }
-
-    /** All of several already-flagged, still-dead tabs are closed — not just the first found. */
-    @Test
-    void allTabsAlreadyFlaggedPendingCloseAreClosedWhenStillDead() {
-        FakeHerdr herdr = new FakeHerdr()
-                .withWorkspace("wL", "fleet")
-                .withTab("wL", "wL:t1", "lead: opus [fleetd:pending-close]")
-                .withTab("wL", "wL:t2", "lead: opus [fleetd:pending-close]")
-                .withTab("wL", "wL:t3", "lead: opus [fleetd:pending-close]");
-
-        assertEquals(1, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads());
-
-        List<Object> closedTabIds = herdr.calls.stream()
-                .filter(c -> c.method().equals("tab.close"))
-                .<Object>map(c -> ((Map<?, ?>) c.params()).get("tab_id"))
-                .toList();
-        assertEquals(3, closedTabIds.size(),
-                "every confirmed-dead labelled tab must be closed, not just the first one found");
-        assertEquals(Set.of("wL:t1", "wL:t2", "wL:t3"), Set.copyOf(closedTabIds));
-    }
-
-    /**
-     * A tab flagged pending-close on a previous reconcile that is running an agent again — the miss
-     * that flagged it was transient. It must never be closed, and its flag must be cleared so a
-     * future, unrelated miss starts its own two-reading count from zero.
-     */
-    @Test
-    void aFlaggedTabRunningAnAgentAgainHasItsFlagClearedInsteadOfBeingClosed() {
-        FakeHerdr herdr = new FakeHerdr()
-                .withWorkspace("wL", "fleet")
-                .withTab("wL", "wL:t1", "lead: opus [fleetd:pending-close]")
-                .withAgent("lead-opus", "term_lead", "wL:p1", "wL:t1"); // it recovered — really alive now
-
-        assertEquals(0, launcher(herdr, configWith(lead("opus", "lead: opus", 1))).ensureLeads(),
-                "the lead is live again — nothing to relaunch");
-
-        assertFalse(herdr.called("tab.close"), "a tab running an agent again must never be closed");
-        assertFalse(herdr.called("agent.start"), "the lead is live again — nothing to relaunch");
-        assertEquals("wL:t1", ((Map<?, ?>) herdr.lastCall("tab.rename").params()).get("tab_id"));
-        assertEquals("lead: opus", ((Map<?, ?>) herdr.lastCall("tab.rename").params()).get("label"),
-                "the pending-close flag must be cleared once the tab is confirmed live again");
-    }
-
-    /** Every {@code tab.rename} call whose label carries the pending-close marker, by tab id. */
-    private static Set<String> flaggedTabIds(FakeHerdr herdr) {
-        return herdr.calls.stream()
-                .filter(c -> c.method().equals("tab.rename"))
-                .filter(c -> String.valueOf(((Map<?, ?>) c.params()).get("label"))
-                        .endsWith("[fleetd:pending-close]"))
-                .map(c -> String.valueOf(((Map<?, ?>) c.params()).get("tab_id")))
-                .collect(java.util.stream.Collectors.toUnmodifiableSet());
-    }
-
     /**
      * A lead the operator opened by hand is live once its tab carries the configured `tab:` label —
      * CB-579 retired the `terminal:` pin, so a hand-opened lead is found the same way an

fleetd/src/test/java/dev/ltms/fleet/mcp/ConnectionIdentityTest.java

@@ -20,17 +20,6 @@ class ConnectionIdentityTest {
         assertEquals("term_a", with(_ -> FakeHerdr.WORKER_PID).callerTerminal("127.0.0.1", 55555));
     }
 
-    @Test
-    void resolvesWorkerFromAnyLoopbackSourceAddressNotJust127001() {
-        // fleetd #305. On Linux the whole 127.0.0.0/8 is bound to lo, so a worker can connect with
-        // a source address of 127.0.0.2. If identity resolution skips that address the caller has
-        // no terminal, and a caller with no terminal is the primary under loopback-trust — so this
-        // must resolve the worker, not null.
-        assertEquals("term_a", with(_ -> FakeHerdr.WORKER_PID).callerTerminal("127.0.0.2", 55555));
-        assertEquals("term_a", with(_ -> FakeHerdr.WORKER_PID).callerTerminal("127.1.2.3", 55555));
-        assertEquals("term_a", with(_ -> FakeHerdr.WORKER_PID).callerTerminal("::ffff:127.0.0.2", 55555));
-    }
-
     @Test
     void nullForOffHostCaller() {
         // A non-loopback peer can't be an on-host worker → treat as primary/unknown.
@@ -43,22 +32,6 @@ class ConnectionIdentityTest {
         assertNull(with(_ -> 999_999).callerTerminal("127.0.0.1", 55555));
     }
 
-    @Test
-    void callerIsUnresolvedWhenThePeerPidLookupFails() {
-        // fleetd #317: LsofPeerPidLookup returns -1 on any failure — a fork error, or (silently)
-        // simply no matching lsof line. Caller.resolved() is the one place that sentinel is tested.
-        ConnectionIdentity.Caller c = with(_ -> -1).resolve("127.0.0.1", 55555);
-        assertFalse(c.resolved(), "a -1 pid means the lookup failed, not that this pid owns no pane");
-    }
-
-    @Test
-    void callerIsResolvedWhenThePidIsRealEvenThoughItOwnsNoPane() {
-        // The primary's own connection: a real, lsof-found pid that just isn't a worker pane. This
-        // must read as "resolved" — the distinction #317 turns on.
-        ConnectionIdentity.Caller c = with(_ -> 999_999).resolve("127.0.0.1", 55555);
-        assertTrue(c.resolved());
-    }
-
     @Test
     void resolvesTheCallersPidAndCwd() {
         // CB-112: the primary maps to no pane, but its PID and cwd are still readable.

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetMcpAuthzTest.java

@@ -24,13 +24,8 @@ import io.modelcontextprotocol.spec.McpSchema;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -49,9 +44,6 @@ import static org.junit.jupiter.api.Assertions.*;
  */
 class FleetMcpAuthzTest {
 
-    private static final Path MCP_SOURCE = Path.of("src/main/java/dev/ltms/fleet/mcp/FleetMcp.java");
-    private static final Pattern TOOL_REGISTRATION = Pattern.compile("tool\\(\\\"(fleet_[a-z_]+)\\\"");
-
     private final FakeHerdr herdr = new FakeHerdr();
     private final AgentControl agents = new AgentControl(herdr);
     private Metrics metrics;
@@ -187,71 +179,6 @@ class FleetMcpAuthzTest {
                 "no CallerResolver supplied ⇒ authorization not enforced (legacy behaviour)");
     }
 
-    // --- fleetd #439: who may see fleet_list's coordinator row ----------------------------------
-
-    /**
-     * fleetd #439: {@link FleetMcp#coordinatorVisibleTo} is the whole policy decision for
-     * {@code fleet_list}'s {@code coordinator} row — lead-to-lead coordination state, not roster
-     * observation. Only the primary may see it; a worker, an architect, and (the case the previous
-     * pass of this ticket did not cover) an anonymous caller must all be refused.
-     */
-    @Test
-    void onlyThePrimaryMaySeeTheCoordinatorRow() {
-        assertTrue(FleetMcp.coordinatorVisibleTo(PRIMARY), "the primary must see its own coordination state");
-        assertFalse(FleetMcp.coordinatorVisibleTo(WORKER_A), "a worker must not see lead-to-lead coordination state");
-        assertFalse(FleetMcp.coordinatorVisibleTo(ARCH_DESIGN),
-                "an architect holds READ today, but that must not extend to coordinator");
-        assertFalse(FleetMcp.coordinatorVisibleTo(ANON), "authenticated as nothing must not see it either");
-    }
-
-    /**
-     * fleetd #439 / PR #462 review finding M2: the predicate above can be perfectly correct while
-     * the one production call site (the {@code fleet_list} MCP handler) never actually asks it —
-     * a literal {@code true} compiles, and the whole suite stayed green under that mutation because
-     * every existing test drives {@link FleetMcp#listFleet} directly and supplies the boolean
-     * itself. This test reads {@code FleetMcp.java}'s own source (same idiom as {@link
-     * #toolsTheServerRegisters()} / {@link #everyRegisteredToolHasItsHandlerActionPinned()}) and
-     * asserts the handler's call passes {@code coordinatorVisibleTo(principal(exchange))} — not a
-     * literal {@code true} or {@code false} — as {@code listFleet}'s trailing argument.
-     *
-     * <p>Anchored on argument position, not a bare substring search: {@code true} appears many
-     * times elsewhere in this file for unrelated reasons, so a plain {@code contains("true")}
-     * check would prove nothing. The pattern requires the literal text immediately before the
-     * closing {@code );} of the {@code listFleet(} call inside the handler block to be exactly
-     * {@code coordinatorVisibleTo(principal(exchange))}.
-     */
-    @Test
-    void theFleetListHandlerActuallyConsultsCoordinatorVisibleTo() throws Exception {
-        String source = Files.readString(MCP_SOURCE);
-
-        // Isolate the fleet_list handler block: from its declaration up to the next handler's
-        // declaration. A change to variable naming would break this scrape loudly (see the control
-        // assertion just below), rather than silently reporting "no violation found".
-        int start = source.indexOf("listHandler =");
-        assertTrue(start >= 0, "could not find the fleet_list handler (listHandler) in " + MCP_SOURCE
-                + " -- the scrape has stopped matching, fix the anchor before trusting this test");
-        int end = source.indexOf("stopHandler =", start);
-        assertTrue(end > start, "could not find the handler declared after listHandler to bound the scrape");
-        String handlerBlock = source.substring(start, end);
-
-        // CONTROL: the block we scraped really does contain a call to listFleet(...) -- if this
-        // fails, the anchors above moved and the assertion below would otherwise pass on nothing.
-        assertTrue(handlerBlock.contains("listFleet("),
-                "control failed: the scraped listHandler block contains no listFleet( call at all -- "
-                        + "the anchors have drifted, this test is not testing what it claims to");
-
-        Pattern trailingArg = Pattern.compile(
-                "listFleet\\([^;]*?,\\s*(coordinatorVisibleTo\\(principal\\(exchange\\)\\)|true|false)\\s*\\)\\s*;",
-                Pattern.DOTALL);
-        Matcher m = trailingArg.matcher(handlerBlock);
-        assertTrue(m.find(), "could not locate listFleet(...)'s trailing boolean argument in the "
-                + "listHandler block -- the call shape changed, update this test's anchor: " + handlerBlock);
-        String trailing = m.group(1);
-        assertEquals("coordinatorVisibleTo(principal(exchange))", trailing,
-                "the fleet_list handler must ask coordinatorVisibleTo(principal(exchange)) who is "
-                        + "calling, not pass a literal boolean -- found: " + trailing);
-    }
-
     // --- which action each tool hands the gate (fleetd #272) ------------------------------------
 
     /**
@@ -266,81 +193,23 @@ class FleetMcpAuthzTest {
      */
     @Test
     void pollingByTargetIsADrainAndPollingByTicketIsARead() {
-        assertEquals(Authz.Action.DRAIN, FleetMcp.pollAction("term_b", null),
+        assertEquals(Authz.Action.DRAIN, FleetMcp.pollAction("term_b"),
                 "poll by target removes the replies — that is a drain, not an observation");
-        assertEquals(Authz.Action.READ, FleetMcp.pollAction(null, null),
+        assertEquals(Authz.Action.READ, FleetMcp.pollAction(null),
                 "poll by ticket changes nothing");
-        assertEquals(Authz.Action.READ, FleetMcp.pollAction("  ", null),
+        assertEquals(Authz.Action.READ, FleetMcp.pollAction("  "),
                 "a blank target is an absent target");
     }
 
-    /**
-     * fleetd #421: a coordId branch is a THIRD operation behind fleet_poll's one name, and it must
-     * map to {@link Authz.Action#COORD_READ} — never {@link Authz.Action#READ}, even though this
-     * branch also consumes nothing. READ's grant is open to every authenticated role on the premise
-     * that the roster carries no secrets; a lead-to-lead body is not the roster, so folding this
-     * branch into READ would let any worker read every peer lead's mail in full. coordId also takes
-     * priority over target when both happen to be present — it addresses a different inbox entirely.
-     */
-    @Test
-    void pollingByCoordIdIsACoordReadNeverAPlainRead() {
-        assertEquals(Authz.Action.COORD_READ, FleetMcp.pollAction(null, "mac-opus"),
-                "reading held peer mail must not be mapped to the everyone-readable READ action");
-        assertEquals(Authz.Action.COORD_READ, FleetMcp.pollAction("  ", "mac-opus"),
-                "a blank target must not fall through to READ/DRAIN when coordId is present");
-        assertEquals(Authz.Action.READ, FleetMcp.pollAction(null, "  "),
-                "a blank coordId is an absent coordId, same as target/ticket");
-        assertEquals(Authz.Action.COORD_READ, FleetMcp.pollAction("term_b", "mac-opus"),
-                "coordId takes priority over target — this is a different inbox, not a drain");
-    }
-
-    @Test
-    void everyRegisteredToolHasItsHandlerActionPinned() {
-        Set<String> registered = toolsTheServerRegisters();
-        assertTrue(registered.size() >= 10,
-                "scraped only " + registered.size() + " tool registrations from FleetMcp (" + registered
-                        + "); the server registers eleven, so the tool(\"…\") scrape has stopped matching");
-        registered.forEach(tool -> assertDoesNotThrow(() -> FleetMcp.toolAction(tool, Map.of()),
-                () -> tool + " is registered but has no pinned authorization action"));
-
-        assertEquals(Authz.Action.SEND, FleetMcp.toolAction("fleet_send", Map.of()));
-        assertEquals(Authz.Action.REPLY, FleetMcp.toolAction("fleet_reply", Map.of()));
-        assertEquals(Authz.Action.ASK, FleetMcp.toolAction("fleet_ask", Map.of()));
-        assertEquals(Authz.Action.READ, FleetMcp.toolAction("fleet_status", Map.of()));
-        assertEquals(Authz.Action.DRAIN, FleetMcp.toolAction("fleet_ack", Map.of()));
-        assertEquals(Authz.Action.SPAWN, FleetMcp.toolAction("fleet_spawn", Map.of()));
-        assertEquals(Authz.Action.READ, FleetMcp.toolAction("fleet_list", Map.of()));
-        assertEquals(Authz.Action.STOP, FleetMcp.toolAction("fleet_stop", Map.of()));
-        assertEquals(Authz.Action.READ, FleetMcp.toolAction("fleet_profiles", Map.of()));
-        assertEquals(Authz.Action.READ, FleetMcp.toolAction("fleet_whoami", Map.of()));
-        assertEquals(Authz.Action.READ, FleetMcp.toolAction("fleet_poll", Map.of("ticket", "task")));
-        assertEquals(Authz.Action.DRAIN, FleetMcp.toolAction("fleet_poll", Map.of("target", "term_b")));
-        assertEquals(Authz.Action.COORD_READ,
-                FleetMcp.toolAction("fleet_poll", Map.of("coordId", "mac-opus")));
-    }
-
-    private static Set<String> toolsTheServerRegisters() {
-        try {
-            Matcher matcher = TOOL_REGISTRATION.matcher(Files.readString(MCP_SOURCE));
-            Set<String> tools = new LinkedHashSet<>();
-            while (matcher.find()) {
-                tools.add(matcher.group(1));
-            }
-            return tools;
-        } catch (Exception e) {
-            throw new AssertionError("could not scrape FleetMcp tool registrations", e);
-        }
-    }
-
     @Test
     void aWorkerMayNotDrainAnotherSessionsInboxByPolling() {
         FleetMcp m = mcp(true);
 
-        assertNotNull(m.denyFor(WORKER_A, FleetMcp.pollAction("term_b", null), "term_b"),
+        assertNotNull(m.denyFor(WORKER_A, FleetMcp.pollAction("term_b"), "term_b"),
                 "a worker draining a peer's inbox would destroy replies queued for the primary");
-        assertNotNull(m.denyFor(ARCH_DESIGN, FleetMcp.pollAction("term_b", null), "term_b"),
+        assertNotNull(m.denyFor(ARCH_DESIGN, FleetMcp.pollAction("term_b"), "term_b"),
                 "an architect has no lifecycle rights either — same gate as fleet_ack");
-        assertNull(m.denyFor(PRIMARY, FleetMcp.pollAction("term_b", null), "term_b"),
+        assertNull(m.denyFor(PRIMARY, FleetMcp.pollAction("term_b"), "term_b"),
                 "collecting a held reply is the primary's job");
     }
 
@@ -352,33 +221,11 @@ class FleetMcpAuthzTest {
     void pollingAnOwnTicketStaysOpenToWorkersAndArchitects() {
         FleetMcp m = mcp(true);
 
-        assertNull(m.denyFor(WORKER_A, FleetMcp.pollAction(null, null), null));
-        assertNull(m.denyFor(ARCH_DESIGN, FleetMcp.pollAction(null, null), null),
+        assertNull(m.denyFor(WORKER_A, FleetMcp.pollAction(null), null));
+        assertNull(m.denyFor(ARCH_DESIGN, FleetMcp.pollAction(null), null),
                 "an architect delegates with wait:false, so it must be able to poll its ticket");
     }
 
-    /**
-     * fleetd #421 acceptance: the whole ticket, pinned at the policy-table layer. A worker must be
-     * refused the coordId branch, the primary must be allowed, and (CB-548) an architect — which
-     * holds READ today — must be refused too, because "not primary" means not-architect here.
-     */
-    @Test
-    void aWorkerAndAnArchitectMayNotReadHeldPeerMailOnlyThePrimaryMay() {
-        FleetMcp m = mcp(true);
-        Authz.Action coordRead = FleetMcp.pollAction(null, "mac-opus");
-
-        McpSchema.CallToolResult workerDenied = m.denyFor(WORKER_A, coordRead, null);
-        assertNotNull(workerDenied, "a worker must not read held lead-to-lead mail");
-        assertTrue(workerDenied.isError());
-
-        McpSchema.CallToolResult archDenied = m.denyFor(ARCH_DESIGN, coordRead, null);
-        assertNotNull(archDenied, "an architect holds READ today, but not-primary must mean "
-                + "not-architect here too");
-        assertTrue(archDenied.isError());
-
-        assertNull(m.denyFor(PRIMARY, coordRead, null), "reading its own held mail is the primary's job");
-    }
-
     // --- identity reconstruction from the transport context ------------------------------------
 
     @Test

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetMcpLeadCoordTest.java

@@ -1,7 +1,6 @@
 package dev.ltms.fleet.mcp;
 
 import dev.ltms.fleet.msg.FakeLeadChannel;
-import dev.ltms.fleet.msg.LeadChannel;
 import dev.ltms.fleet.msg.LeadMessage;
 import io.modelcontextprotocol.spec.McpSchema;
 import org.junit.jupiter.api.Test;
@@ -94,56 +93,4 @@ class FleetMcpLeadCoordTest {
         assertTrue(FleetMcp.sendToLead(channel, PEER, "   ", null, null).isError());
         assertEquals(0, channel.published().size());
     }
-
-    /**
-     * fleetd #361: "delivered" overstated what publish actually proves — the broker's confirm means
-     * durably queued, not read. A zero-consumer target is the observable form of "this will not
-     * reach a pane right now", so the (still-successful) result must say so.
-     */
-    @Test
-    void warnsWhenThePeerMailboxHasNoConsumersButStillReportsSuccess() {
-        var channel = new FakeLeadChannel(SELF)
-                .withMailbox(PEER, LeadChannel.MailboxState.exists(PEER, 0, 0));
-
-        McpSchema.CallToolResult res = FleetMcp.sendToLead(channel, PEER, "hi", null, null);
-
-        assertFalse(res.isError(), "a zero-consumer mailbox is still a successful, durably-queued publish");
-        String out = textOf(res);
-        assertTrue(out.contains("durably confirmed"), out);
-        assertTrue(out.toLowerCase().contains("no consumers"), () -> "must warn nobody is reading it: " + out);
-    }
-
-    @Test
-    void staysQuietAboutConsumersWhenThePeerMailboxHasOne() {
-        var channel = new FakeLeadChannel(SELF)
-                .withMailbox(PEER, LeadChannel.MailboxState.exists(PEER, 0, 1));
-
-        McpSchema.CallToolResult res = FleetMcp.sendToLead(channel, PEER, "hi", null, null);
-
-        assertFalse(res.isError());
-        String out = textOf(res);
-        assertTrue(out.contains("durably confirmed"), out);
-        assertFalse(out.toLowerCase().contains("no consumers"), () -> "a consumer IS attached: " + out);
-    }
-
-    /**
-     * fleetd #361 review finding 1: an unmeasured fact must never render as a definite one. When
-     * the post-publish probe could not determine the mailbox's consumer count at all (broker slow,
-     * unreachable, or the probe timed out — {@link LeadChannel.MailboxState#unknown}), the result
-     * must stay just as quiet as the has-a-consumer case — never assert "no consumers" for a mailbox
-     * this call never actually measured.
-     */
-    @Test
-    void staysQuietAboutConsumersWhenThePeerMailboxStateIsUnknown() {
-        var channel = new FakeLeadChannel(SELF)
-                .withMailbox(PEER, LeadChannel.MailboxState.unknown(PEER));
-
-        McpSchema.CallToolResult res = FleetMcp.sendToLead(channel, PEER, "hi", null, null);
-
-        assertFalse(res.isError(), "an unresolved post-publish probe must never turn a durably-confirmed publish into an error");
-        String out = textOf(res);
-        assertTrue(out.contains("durably confirmed"), out);
-        assertFalse(out.toLowerCase().contains("no consumers"),
-                () -> "an unmeasured fact must never be reported as a definite zero-consumer mailbox: " + out);
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetMcpTest.java

@@ -3,7 +3,6 @@ package dev.ltms.fleet.mcp;
 import dev.ltms.fleet.auth.CallerResolver;
 import dev.ltms.fleet.auth.MemberRegistry;
 import dev.ltms.fleet.auth.Principal;
-import dev.ltms.fleet.auth.Role;
 import dev.ltms.fleet.config.FleetConfig;
 import dev.ltms.fleet.guard.SubscriptionGuard;
 import dev.ltms.fleet.herdr.AgentControl;
@@ -11,9 +10,6 @@ import dev.ltms.fleet.herdr.FakeHerdr;
 import dev.ltms.fleet.herdr.PaneLocator;
 import dev.ltms.fleet.herdr.WorkspaceControl;
 import dev.ltms.fleet.inject.Injector;
-import dev.ltms.fleet.msg.FakeLeadChannel;
-import dev.ltms.fleet.msg.LeadChannel;
-import dev.ltms.fleet.msg.LeadMessage;
 import dev.ltms.fleet.msg.MessageService;
 import dev.ltms.fleet.msg.Rendezvous;
 import dev.ltms.fleet.session.FakeWorktrees;
@@ -29,19 +25,15 @@ import dev.ltms.fleet.placement.BackendQuarantine;
 import dev.ltms.fleet.placement.PlacementPolicies;
 import io.modelcontextprotocol.spec.McpSchema;
 import dev.ltms.fleet.msg.InMemoryReplyInbox;
-import dev.ltms.fleet.msg.ReplyInbox;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.EnumSet;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Function;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -79,7 +71,7 @@ class FleetMcpTest {
             Thread.sleep(5);
         }
         assertTrue(rendezvous.isWaiting(target), "send should be accepted for " + target);
-        FleetMcp.reply(messages, target, Role.WORKER, "received");
+        FleetMcp.reply(messages, target, "received");
         assertEquals("received", textOf(send.get(6, TimeUnit.SECONDS)));
     }
 
@@ -110,10 +102,8 @@ class FleetMcpTest {
         }
         assertTrue(rendezvous.isWaiting("term_a"), "send should have opened its waiter");
 
-        // fleetd #365: a resolved live send must read distinctly from a merely-queued reply —
-        // see replyWithNoPendingSendIsQueuedNotError below for the other case.
-        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", Role.WORKER, "LGTM");
-        assertEquals(MessageService.ReplyOutcome.RESOLVED_SEND.description(), textOf(reply));
+        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", "LGTM");
+        assertEquals("delivered", textOf(reply));
 
         McpSchema.CallToolResult res = send.get(6, TimeUnit.SECONDS);
         assertNotEquals(Boolean.TRUE, res.isError());
@@ -138,8 +128,8 @@ class FleetMcpTest {
         }
         assertTrue(rendezvous.isWaiting("term_a"), "send should have opened its waiter");
 
-        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", Role.WORKER, "async LGTM");
-        assertEquals(MessageService.ReplyOutcome.RESOLVED_SEND.description(), textOf(reply));
+        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", "async LGTM");
+        assertEquals("delivered", textOf(reply));
 
         // Poll until the async send completes and reports the reply.
         McpSchema.CallToolResult polled = FleetMcp.poll(messages, ticket, null);
@@ -185,7 +175,7 @@ class FleetMcpTest {
             Thread.sleep(5);
         }
         assertTrue(rendezvous.isWaiting("term_a"));
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "done");
+        FleetMcp.reply(messages, "term_a", "done");
         assertEquals("done", textOf(answer.get(6, TimeUnit.SECONDS)));
 
         McpSchema.CallToolResult done = FleetMcp.poll(messages, ticket, null);
@@ -198,7 +188,7 @@ class FleetMcpTest {
     }
 
     @Test
-    void unansweredAsyncAskReturnsTheTicketToPendingThenAWorkersLateReplyStillCompletesIt() throws Exception {
+    void unansweredAsyncAskReturnsTheTicketToPending() throws Exception {
         McpSchema.CallToolResult accepted = FleetMcp.sendAsync(messages, "term_a", "do it", null, Set.of());
         String ticket = textOf(accepted).substring(textOf(accepted).indexOf("ticket=") + "ticket=".length()).trim();
 
@@ -212,15 +202,8 @@ class FleetMcpTest {
         assertTrue(textOf(ask).contains("no answer"), textOf(ask));
         assertTrue(textOf(FleetMcp.poll(messages, ticket, null)).startsWith("[pending"));
 
-        // fleetd #307: the worker resumed on its own after the primary never answered, and its real
-        // fleet_reply must complete its OWN async ticket — not strand in the inbox with
-        // fleet_poll{ticket} stuck PENDING forever and later force-failed with a false "session
-        // released before it replied" reason. This used to land in the inbox instead (see the old
-        // assertion this replaced: messages.drainReplies("term_a").getFirst()...) — that was the bug.
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "finished after timeout");
-        assertEquals("finished after timeout", textOf(FleetMcp.poll(messages, ticket, null)));
-        assertTrue(messages.drainReplies("term_a").isEmpty(),
-                "the reply completed its own ticket directly and never touched the inbox");
+        FleetMcp.reply(messages, "term_a", "finished after timeout");
+        assertEquals("finished after timeout", messages.drainReplies("term_a").getFirst().content());
     }
 
     @Test
@@ -271,7 +254,7 @@ class FleetMcpTest {
         }
         assertEquals(MessageService.Phase.FAILED, second.phase());
 
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "late reply");
+        FleetMcp.reply(messages, "term_a", "late reply");
         assertEquals("late reply", messages.drainReplies("term_a").getFirst().content());
 
         CompletableFuture<McpSchema.CallToolResult> answer = CompletableFuture.supplyAsync(
@@ -280,7 +263,7 @@ class FleetMcpTest {
         while (!rendezvous.isWaiting("term_a") && System.currentTimeMillis() < deadline) {
             Thread.sleep(5);
         }
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "done");
+        FleetMcp.reply(messages, "term_a", "done");
         assertEquals("done", textOf(answer.get(6, TimeUnit.SECONDS)));
     }
 
@@ -332,10 +315,9 @@ class FleetMcpTest {
     @Test
     void replyWithNoPendingSendIsQueuedNotError() {
         // CB-307: a reply with no open send is now queued in the inbox, not an error.
-        // fleetd #365: it must also no longer claim "delivered" — nothing was waiting for it.
-        McpSchema.CallToolResult res = FleetMcp.reply(messages, "term_a", Role.WORKER, "orphan");
+        McpSchema.CallToolResult res = FleetMcp.reply(messages, "term_a", "orphan");
         assertNotEquals(Boolean.TRUE, res.isError(), "a queued reply is not an error");
-        assertEquals(MessageService.ReplyOutcome.QUEUED.description(), textOf(res));
+        assertEquals("delivered", textOf(res));
 
         // The reply is drainable by target.
         var drained = messages.drainReplies("term_a");
@@ -343,64 +325,10 @@ class FleetMcpTest {
         assertEquals("orphan", drained.getFirst().content());
     }
 
-    @Test
-    void replyFromLeadIsRefusedBeforeItCanPublishToTheWorkerInbox() {
-        ReplyInbox inboxThatRejectsPublishes = new ReplyInbox() {
-            @Override public void own(String target) { }
-            @Override public void release(String target) { }
-            @Override public void publish(String target, String msgId, String content) {
-                fail("a lead fleet_reply must not publish to the worker inbox");
-            }
-            @Override public List<InboxMessage> peek(String target) { return List.of(); }
-            @Override public boolean ack(String target, String msgId) { return false; }
-        };
-        MessageService leadMessages = new MessageService(agents, new Injector(agents), new Rendezvous(),
-                inboxThatRejectsPublishes);
-
-        McpSchema.CallToolResult res = assertDoesNotThrow(
-                () -> FleetMcp.reply(leadMessages, "term_lead", Role.PRIMARY, "peer reply"));
-
-        assertTrue(res.isError());
-        assertEquals("fleet_reply has no route to a peer lead. Use fleet_send{coordId: ...} for a peer on another "
-                        + "daemon or fleet_send{sessionId: ...} for a peer on this host. fleet_reply resolves a member's "
-                        + "blocked fleet_send, and a peer's coord-id message is durable and non-blocking, so there is "
-                        + "nothing for it to resolve.",
-                textOf(res));
-    }
-
-    @Test
-    void replyFromUnidentifiedCallerKeepsItsOwnError() {
-        McpSchema.CallToolResult res = FleetMcp.reply(messages, null, Role.PRIMARY, "reply");
-
-        assertTrue(res.isError());
-        assertEquals("fleet_reply is for workers only — could not identify the calling worker from the connection",
-                textOf(res));
-    }
-
-    @Test
-    void replyWithBlankContentIsACleanToolErrorNotAnUncaughtException() {
-        // fleetd #302: MessageService.reply now REJECTS blank content by throwing. fleet_reply's
-        // handler is a bare BiFunction with no try/catch around it, so if this guard only checked
-        // `== null` (as it did), a whitespace-only reply would leave the handler as an uncaught
-        // IllegalArgumentException instead of a tool error the caller can read. Null and whitespace
-        // are the same caller mistake and must get the same answer — the sibling fleet_send guard
-        // has always used isBlank for exactly this reason.
-        for (String blank : new String[] {null, "", "   ", "\n\t"}) {
-            McpSchema.CallToolResult res = assertDoesNotThrow(
-                    () -> FleetMcp.reply(messages, "term_a", Role.WORKER, blank),
-                    "blank content must be refused as a tool error, never thrown out of the handler");
-            assertEquals(Boolean.TRUE, res.isError(), "blank content is an error result");
-            assertTrue(textOf(res).contains("content is required"),
-                    "the error names the missing argument: " + textOf(res));
-        }
-        assertEquals(0, messages.drainReplies("term_a").size(),
-                "a refused reply must not reach the inbox");
-    }
-
     @Test
     void bridgePollWithTargetDrainsReplies() {
         // A reply with no open send queues it in the inbox.
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "queued-msg");
+        FleetMcp.reply(messages, "term_a", "queued-msg");
 
         // fleet_poll with target drains the inbox.
         McpSchema.CallToolResult res = FleetMcp.poll(messages, null, "term_a");
@@ -451,8 +379,8 @@ class FleetMcpTest {
             Thread.sleep(5);
         }
         assertTrue(rendezvous.isWaiting("term_a"), "the answer should have reopened a waiter");
-        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", Role.WORKER, "done");
-        assertEquals(MessageService.ReplyOutcome.RESOLVED_SEND.description(), textOf(reply));
+        McpSchema.CallToolResult reply = FleetMcp.reply(messages, "term_a", "done");
+        assertEquals("delivered", textOf(reply));
         assertEquals("done", textOf(answer.get(6, TimeUnit.SECONDS)));
     }
 
@@ -620,48 +548,17 @@ class FleetMcpTest {
     void listReportsThisDaemonsOwnCoordIdWhenLeadCoordinationIsOn() {
         FakeHerdr h = new FakeHerdr();
         SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1));
 
         McpSchema.CallToolResult res = FleetMcp.listFleet(
                 workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
                 FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of()));
+                FleetMcp.QuarantineSource.none(), Map.of(), "", "mac-opus");
 
         String out = textOf(res);
-        // fleetd #361: reports both which coord-id a peer must use to reach ME, and this daemon's
-        // own mailbox state (a self-diagnosis: is my own consumer actually attached?).
+        // There is no peer-discovery surface yet, so this row answers the one question an operator
+        // cannot answer any other way: which coord-id a peer must use to reach ME.
         assertTrue(out.contains("\"coordinator\""), out);
         assertTrue(out.contains("\"selfId\":\"mac-opus\""), out);
-        assertTrue(out.contains("\"mailbox\":{\"status\":\"exists\",\"pending\":0,\"consumers\":1}"), out);
-        assertTrue(out.contains("\"held\":[]"), out);
-        assertTrue(out.contains("\"peers\":[]"), out);
-    }
-
-    /**
-     * fleetd #361 review finding 1: a self-probe that could not complete (broker unreachable, timed
-     * out) must never render the same as a measured "0 pending, 0 consumers" — that was exactly the
-     * bug: a reader could not tell "my mailbox is empty and idle" from "I could not check", and the
-     * second one is the far more alarming state.
-     */
-    @Test
-    void listReportsAnUnresolvedSelfProbeAsUnknownNeverAsAMeasuredZero() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.unknown("mac-opus"));
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of()));
-
-        String out = textOf(res);
-        assertTrue(out.contains("\"mailbox\":{\"status\":\"unknown\"}"), out);
-        assertFalse(out.contains("\"pending\""), "an unresolved probe must never carry a pending count at all: " + out);
-        assertFalse(out.contains("\"consumers\""), "an unresolved probe must never carry a consumers count at all: " + out);
     }
 
     @Test
@@ -676,310 +573,6 @@ class FleetMcpTest {
                 "an ordinary fleet's output must be unchanged by this feature");
     }
 
-    /**
-     * fleetd #439: a worker calling {@code fleet_list} must get a result with the {@code
-     * coordinator} key <strong>absent</strong> -- not an empty object, not a redacted one -- even
-     * though lead coordination is fully configured and would otherwise report a row. This drives
-     * the same {@code callerIsPrimary} value the MCP handler computes ({@code
-     * Principal.worker(...).isPrimary()}), so it pins the real production boolean, not a literal.
-     */
-    @Test
-    void listOmitsTheCoordinatorKeyEntirelyForAWorkerEvenWhenLeadCoordinationIsOn() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1));
-        boolean callerIsPrimary = Principal.worker("term_a", 1).isPrimary();
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), FleetMcp.LeadSeatSource.none(),
-                Map.of(), "", new FleetMcp.CoordinationSource(channel, List.of()), callerIsPrimary);
-
-        String out = textOf(res);
-        assertFalse(out.contains("\"coordinator\""), "a worker must never see the coordinator key at all: " + out);
-        assertFalse(out.contains("mac-opus"), "no fragment of the coordinator row may leak either: " + out);
-        assertTrue(out.contains("\"leads\""), "the rest of the result must still be present: " + out);
-        assertTrue(out.contains("\"members\""), out);
-        assertTrue(out.contains("\"healthCoverage\""), out);
-    }
-
-    /**
-     * fleetd #439 acceptance criterion 2: an architect gets exactly the same treatment as a worker.
-     * This is a real, executed test (not just reasoning by analogy) -- it drives the actual
-     * {@code Principal.architect(...).isPrimary()} value the production handler would compute for
-     * an architect caller, through the same gate a worker's call goes through.
-     */
-    @Test
-    void listOmitsTheCoordinatorKeyEntirelyForAnArchitectToo() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1));
-        boolean callerIsPrimary = Principal.architect("lead-designer", "term_design", 400).isPrimary();
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), FleetMcp.LeadSeatSource.none(),
-                Map.of(), "", new FleetMcp.CoordinationSource(channel, List.of()), callerIsPrimary);
-
-        String out = textOf(res);
-        assertFalse(out.contains("\"coordinator\""), "an architect must never see the coordinator key either: " + out);
-    }
-
-    /**
-     * fleetd #439 acceptance criterion 3: the primary's {@code fleet_list} is byte-for-byte
-     * unchanged by this fix. Proven by comparing the new gated overload (with {@code
-     * callerIsPrimary=true}, exactly what the MCP handler passes for the primary) against the
-     * pre-#439 overload that always assembled the row -- if the gate changed anything for a
-     * primary caller, these two strings would differ.
-     */
-    @Test
-    void listIsByteForByteUnchangedForThePrimaryCaller() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1));
-
-        String preExisting = textOf(FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of())));
-        String gatedAsPrimary = textOf(FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), FleetMcp.LeadSeatSource.none(),
-                Map.of(), "", new FleetMcp.CoordinationSource(channel, List.of()), true));
-
-        assertEquals(preExisting, gatedAsPrimary,
-                "a primary caller must see byte-for-byte the same result as before this fix");
-        assertTrue(gatedAsPrimary.contains("\"coordinator\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"selfId\":\"mac-opus\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"mailbox\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"heldCount\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"heldDurable\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"held\""), gatedAsPrimary);
-        assertTrue(gatedAsPrimary.contains("\"peers\""), gatedAsPrimary);
-    }
-
-    @Test
-    void listReportsHeldMessagesWithATruncatedPreviewNeverTheFullBody() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        // A homogeneous "x".repeat(200) body would not pin the exact 80-char boundary: a preview
-        // widened by one (81 chars) still CONTAINS "x".repeat(80) + "…" as a substring one position
-        // later, because every character is 'x'. Put a sentinel ("Y") exactly at index 80 — the
-        // first character a widened cap would leak — so any preview past 80 chars is caught.
-        String longContent = "x".repeat(80) + "Y" + "z".repeat(119);
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .hold(new LeadMessage("m1", "fleet01-lead", "mac-opus", longContent));
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of()));
-
-        String out = textOf(res);
-        assertTrue(out.contains("\"msgId\":\"m1\""), out);
-        assertTrue(out.contains("\"from\":\"fleet01-lead\""), out);
-        assertFalse(out.contains(longContent), "fleet_list must never dump a held message's full body: " + out);
-        assertFalse(out.contains("Y"),
-                "the sentinel at index 80 must never appear — a preview past 80 chars leaked it: " + out);
-        assertTrue(out.contains("x".repeat(80) + "…"), "expected an 80-char preview with an ellipsis: " + out);
-    }
-
-    /**
-     * fleetd #421: {@code mailbox.pending} counts only broker-ready messages, so a blocked lead's
-     * normal, healthy state is {@code "pending": 0} next to a non-empty {@code held[]} — which
-     * invites the false reading that held mail is in-memory-only. {@code heldCount}/{@code
-     * heldDurable} put an honest second number and fact beside {@code pending} instead of leaving it
-     * as the only one.
-     */
-    @Test
-    void listReportsAnHonestHeldCountAndDurabilityNotJustPendingZero() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1))
-                .hold(new LeadMessage("m1", "fleet01-lead", "mac-opus", "one"))
-                .hold(new LeadMessage("m2", "fleet01-lead", "mac-opus", "two"))
-                .hold(new LeadMessage("m3", "fleet01-lead", "mac-opus", "three"));
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of()));
-
-        String out = textOf(res);
-        assertTrue(out.contains("\"pending\":0"), out);
-        assertTrue(out.contains("\"heldCount\":3"),
-                "the honest count beside pending: 0 — three messages really are held: " + out);
-        assertTrue(out.contains("\"heldDurable\":true"),
-                "must state the durability fact, not leave pending as the only number next to held[]: " + out);
-    }
-
-    /**
-     * fleetd #440: {@code heldDurable} must be a derived fact, not a literal — so it can report
-     * {@code false} when the channel behind it says held mail is not durable (a non-durable queue,
-     * or a consumer running with {@code autoAck=true}). A test that only ever asserts {@code true}
-     * repeats the defect this ticket fixes.
-     */
-    @Test
-    void listReportsHeldDurableFalseWhenTheChannelSaysMailIsNotDurable() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("mac-opus", LeadChannel.MailboxState.exists("mac-opus", 0, 1))
-                .withHeldDurable(false)
-                .hold(new LeadMessage("m1", "fleet01-lead", "mac-opus", "one"));
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of()));
-
-        String out = textOf(res);
-        assertTrue(out.contains("\"heldDurable\":false"),
-                "heldDurable must follow the channel, not a hardcoded true: " + out);
-    }
-
-    // ── fleetd #421: a lead reads (never consumes) its own held peer mail ──────────────────────
-
-    @Test
-    void pollWithCoordIdReturnsTheFullBodyWithoutAckingAndLeavesItHeld() {
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .hold(new LeadMessage("m1", "fleet01-lead", "mac-opus", "x".repeat(200)));
-
-        McpSchema.CallToolResult first = FleetMcp.poll(messages, channel, null, null, "mac-opus");
-        assertNotEquals(Boolean.TRUE, first.isError(), textOf(first));
-        String out1 = textOf(first);
-        assertTrue(out1.contains("\"msgId\":\"m1\""), out1);
-        assertTrue(out1.contains("\"from\":\"fleet01-lead\""), out1);
-        assertTrue(out1.contains("\"content\":\"" + "x".repeat(200) + "\""),
-                "the coordId route must return the FULL body, unlike fleet_list's preview: " + out1);
-
-        // Read again: identical bodies, and nothing was acked — peek() still holds it.
-        McpSchema.CallToolResult second = FleetMcp.poll(messages, channel, null, null, "mac-opus");
-        assertEquals(out1, textOf(second), "peek is non-destructive — reading twice must return the same bodies");
-        assertTrue(channel.acked().isEmpty(), "a read must never ack — that is the whole point of the ticket");
-        assertEquals(1, channel.peek().size(), "the message must still be held after being read");
-    }
-
-    @Test
-    void pollWithCoordIdRefusesAPeersCoordIdInsteadOfReturningTheWrongMailOrNothing() {
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .hold(new LeadMessage("m1", "fleet01-lead", "mac-opus", "secret coordination body"));
-
-        // The ORIGINAL fleetd #421 confusion: passing a PEER's id where a self-address was meant.
-        McpSchema.CallToolResult res = FleetMcp.poll(messages, channel, null, null, "fleet01-lead");
-
-        assertEquals(Boolean.TRUE, res.isError());
-        String out = textOf(res);
-        assertFalse(out.contains("secret coordination body"),
-                "a refused read must never leak the body it refused to return: " + out);
-        assertTrue(out.contains("mac-opus"), "the error must name this daemon's own coordId: " + out);
-    }
-
-    @Test
-    void pollWithCoordIdErrorsHonestlyWhenLeadCoordinationIsNotConfigured() {
-        McpSchema.CallToolResult res = FleetMcp.poll(messages, null, null, null, "mac-opus");
-
-        assertEquals(Boolean.TRUE, res.isError());
-        assertTrue(textOf(res).toLowerCase().contains("coordinat"), textOf(res));
-    }
-
-    @Test
-    void listReportsEachDeclaredPeersLiveReachability() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        FakeLeadChannel channel = new FakeLeadChannel("mac-opus")
-                .withMailbox("fleet01-lead", LeadChannel.MailboxState.exists("fleet01-lead", 2, 1))
-                .withMailbox("fleet03-lead", LeadChannel.MailboxState.unknown("fleet03-lead"));
-        // "fleet02-lead" is declared as a peer but never configured on the fake — inspect() falls
-        // back to MailboxState.absent, exactly as a real down (never-run) peer would report.
-        // "fleet03-lead" IS configured, as unknown — a broker that could not be reached in time,
-        // which review finding 1 says must render distinctly from "fleet02-lead"'s confirmed absence.
-
-        McpSchema.CallToolResult res = FleetMcp.listFleet(
-                workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")), sessions, null,
-                FleetMcp.CapacitySource.none(), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), "",
-                new FleetMcp.CoordinationSource(channel, List.of("fleet01-lead", "fleet02-lead", "fleet03-lead")));
-
-        String out = textOf(res);
-        assertTrue(out.contains("\"coordId\":\"fleet01-lead\",\"status\":\"exists\",\"pending\":2,\"consumers\":1"), out);
-        assertTrue(out.contains("\"coordId\":\"fleet02-lead\",\"status\":\"absent\""), out);
-        assertTrue(out.contains("\"coordId\":\"fleet03-lead\",\"status\":\"unknown\""), out);
-        assertFalse(out.contains("\"coordId\":\"fleet02-lead\",\"status\":\"absent\",\"pending\""),
-                "pending/consumers must be omitted, not faked as zero, for a confirmed-absent peer: " + out);
-        assertFalse(out.contains("\"coordId\":\"fleet03-lead\",\"status\":\"unknown\",\"pending\""),
-                "pending/consumers must be omitted, not faked as zero, for an unresolved peer probe: " + out);
-    }
-
-    /**
-     * fleetd #361 review finding 2: {@code get(timeout)} alone times out the CALLER but leaves the
-     * submitted {@link LeadChannel#inspect} task running forever on its own virtual thread — against
-     * a hung (not down) broker every probe would orphan one more thread holding an AMQP channel
-     * until the connection's channel-max is exhausted, which would break {@code publish} too. This
-     * proves {@link FleetMcp#probe(LeadChannel, String, long)} does not merely give up on a slow
-     * task: it interrupts it, so the task does not go on running unbounded after the caller has
-     * already moved on. No hung broker needed — a {@link LeadChannel} fake that blocks until
-     * interrupted is enough to observe the same mechanism.
-     */
-    @Test
-    void aTimedOutProbeInterruptsTheOrphanedTaskRatherThanAbandoningIt() throws Exception {
-        CountDownLatch started = new CountDownLatch(1);
-        AtomicBoolean wasInterrupted = new AtomicBoolean(false);
-        LeadChannel hangs = new LeadChannel() {
-            @Override
-            public void publish(String toCoordId, LeadMessage m) { }
-
-            @Override
-            public List<LeadMessage> peek() { return List.of(); }
-
-            @Override
-            public void ack(String msgId) { }
-
-            @Override
-            public String selfCoordId() { return "mac-opus"; }
-
-            @Override
-            public boolean heldDurable() { return true; }
-
-            @Override
-            public MailboxState inspect(String coordId) {
-                started.countDown();
-                try {
-                    Thread.sleep(60_000);
-                } catch (InterruptedException e) {
-                    wasInterrupted.set(true);
-                    Thread.currentThread().interrupt();
-                }
-                return MailboxState.unknown(coordId);
-            }
-        };
-
-        LeadChannel.MailboxState result = FleetMcp.probe(hangs, "fleet01-lead", 100L);
-
-        assertFalse(result.exists(), "a timed-out probe must never claim the mailbox exists");
-        assertFalse(result.known(), "a timed-out probe proves nothing either way — it must report unknown");
-        assertTrue(started.await(2, TimeUnit.SECONDS), "the probe task must actually have started");
-        // The interrupt is delivered asynchronously to the orphaned task's own thread — poll briefly
-        // rather than assume it has already landed the instant probe() returns.
-        long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(2);
-        while (!wasInterrupted.get() && System.nanoTime() < deadline) {
-            Thread.sleep(20);
-        }
-        assertTrue(wasInterrupted.get(),
-                "probe() must cancel the orphaned task (interrupt it) instead of leaving it to run forever");
-    }
-
     @Test
     void capacityUsesThePlacementLiveCount() {
         FakeHerdr h = new FakeHerdr();
@@ -1011,60 +604,6 @@ class FleetMcpTest {
         assertTrue(out.contains("\"reclaimable\":0"), out);
     }
 
-    /**
-     * fleetd #284: {@code reclaimable} has exactly one definition, and this pins it over EVERY
-     * {@link MemberSession.State} — so a state added later cannot slip through unconsidered. Both
-     * views in a {@code fleet_list} response call {@link FleetMcp#reclaimable}, so they cannot
-     * drift apart.
-     *
-     * <p>{@code BACKEND_ERROR} and {@code FAILED} are NOT reclaimable on purpose. The ticket asked
-     * for them to be; that half of the ticket was wrong. Their seat is already out of
-     * {@code live}, so it is already in {@code free} — counting it here too would report the same
-     * seat twice.
-     */
-    @Test
-    void onlyReadyAndDoneSessionsAreReclaimable() {
-        Set<MemberSession.State> expected = EnumSet.of(MemberSession.State.READY, MemberSession.State.DONE);
-        for (MemberSession.State state : MemberSession.State.values()) {
-            MemberSession session = new MemberSession("p1", "term1", "ltms-local", null,
-                    "/tmp", null, 0L, 0L, 0, state, null, null);
-            assertEquals(expected.contains(state), FleetMcp.reclaimable(session, null),
-                    "state " + state + " must " + (expected.contains(state) ? "" : "not ")
-                            + "count as reclaimable");
-        }
-    }
-
-    /**
-     * fleetd #284, the operator-visible half. {@code liveCount} here is the value the real counter
-     * ({@code Fleetd.liveSessionCount}, proven against the actual spawn gate in
-     * {@code FleetdBackendErrorSinkTest}) produces for this roster: 0, because both sessions are
-     * terminal. What this test pins is what {@code fleet_list} says around it — the two seats show
-     * up once, in {@code free}, and are NOT counted a second time as {@code reclaimable}; neither
-     * is any member row; and both dead sessions are still listed so the lead can see why.
-     */
-    @Test
-    void terminalFailureSessionsFreeTheirSeatWithoutBeingCountedReclaimable() {
-        FakeHerdr h = new FakeHerdr();
-        SessionManager sessions = new SessionManager(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")));
-        MemberSession backendError = sessions.acquire("ltms-local", null, null, null);
-        MemberSession failed = sessions.acquire("ltms-local", null, null, null);
-        assertTrue(sessions.onBackendError(backendError.terminalId(), "backend exited"));
-        sessions.onTurnFailed(failed.terminalId());
-
-        String out = textOf(FleetMcp.listFleet(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")),
-                sessions, null, new FleetMcp.CapacitySource(profile -> 0, profile -> 2,
-                () -> Set.of("ltms-local"), () -> 0), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), Map.of(), ""));
-
-        assertTrue(out.contains("\"free\":2"), "both seats are back: " + out);
-        assertTrue(out.contains("\"reclaimable\":0"),
-                "the freed seats must not be counted a second time as reclaimable: " + out);
-        assertFalse(out.contains("\"reclaimable\":true"),
-                "no member row may claim a seat the profile count says is not held: " + out);
-        assertTrue(out.contains("\"state\":\"backend_error\""), "the dead session stays visible: " + out);
-        assertTrue(out.contains("\"state\":\"failed\""), "the failed session stays visible: " + out);
-    }
-
     @Test
     void inertCapacitySourceOmitsCapacityBlock() {
         FakeHerdr h = new FakeHerdr();
@@ -1290,8 +829,7 @@ class FleetMcpTest {
         String out = textOf(FleetMcp.listFleet(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")),
                 sessions, null, new FleetMcp.CapacitySource(profile -> 2, profile -> 3,
                 () -> Set.of("sonnet"), () -> 0), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), leadSeats, Map.of(), "",
-                FleetMcp.CoordinationSource.none()));
+                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), leadSeats, Map.of(), "", null));
 
         assertTrue(out.contains("\"maxLoad\":3"), "maxLoad itself must be left untouched: " + out);
         assertTrue(out.contains("\"live\":2"), out);
@@ -1314,8 +852,7 @@ class FleetMcpTest {
         String out = textOf(FleetMcp.listFleet(workerService(h, "http://gx00.gw:8000", Set.of("gx00.gw")),
                 sessions, null, new FleetMcp.CapacitySource(profile -> 0, profile -> 3,
                 () -> Set.of("sonnet"), () -> 0), new FleetMcp.HealthCoverageSource(() -> "off"),
-                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), leadSeats, Map.of(), "",
-                FleetMcp.CoordinationSource.none()));
+                FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), leadSeats, Map.of(), "", null));
 
         assertTrue(out.contains("\"live\":0"), out);
         assertTrue(out.contains("\"free\":3"), "the real gate never subtracts the lead's seat: " + out);
@@ -1369,7 +906,7 @@ class FleetMcpTest {
         String out = textOf(FleetMcp.listFleet(composite, sm, null,
                 new FleetMcp.CapacitySource(liveCount, p -> profiles.get(p).maxLoad(), profiles::keySet, () -> 0),
                 new FleetMcp.HealthCoverageSource(() -> "off"), FleetMcp.QuarantineSource.none(),
-                FleetMcp.OutageSource.none(), leadSeats, Map.of(), "", FleetMcp.CoordinationSource.none()));
+                FleetMcp.OutageSource.none(), leadSeats, Map.of(), "", null));
         int reportedFree = extractInt(out, "free");
 
         for (int i = 0; i < reportedFree; i++) {
@@ -1398,7 +935,7 @@ class FleetMcpTest {
                 sessions, null, new FleetMcp.CapacitySource(profile -> 0, profile -> 2,
                 () -> Set.of("terra"), () -> 0), new FleetMcp.HealthCoverageSource(() -> "off"),
                 FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none(), FleetMcp.LeadSeatSource.none(),
-                Map.of(), "", FleetMcp.CoordinationSource.none()));
+                Map.of(), "", null));
 
         assertTrue(out.contains("\"free\":2"), out);
         assertFalse(out.contains("leadSeats"), "no lead shares this profile's credential: " + out);
@@ -1475,10 +1012,6 @@ class FleetMcpTest {
 
     @Test
     void bridgeAckReturnsConfirmationForValidArgs() {
-        // fleet_ack only reports success for a msgId actually queued in the target's inbox
-        // (fleetd #437) — publish one via the inbox directly rather than asserting on a
-        // fabricated id nothing ever queued.
-        inbox.publish("term_a", "msg-1", "queued reply");
         McpSchema.CallToolResult res = FleetMcp.ack(messages, "term_a", "msg-1");
         assertNotEquals(Boolean.TRUE, res.isError());
         assertTrue(textOf(res).contains("msg-1"), "response should mention the msgId");
@@ -1491,51 +1024,21 @@ class FleetMcpTest {
         assertTrue(FleetMcp.ack(messages, "  ", "msg-1").isError());
     }
 
-    @Test
-    void bridgeAckOfAnIdInNoInboxIsAnError() {
-        // fleetd #437: fleet_ack used to say "acknowledged <msgId>" for a message it never
-        // touched, because nothing in the chain reported hit vs. miss. "never-queued" is in no
-        // inbox at all, so this must error rather than claim success.
-        McpSchema.CallToolResult res = FleetMcp.ack(messages, "term_a", "never-queued");
-        assertTrue(res.isError());
-        assertTrue(textOf(res).contains("never-queued"), textOf(res));
-    }
-
-    @Test
-    void bridgeAckOfACoordIdTargetIsAnErrorNamingFleetPoll() {
-        // A coord-id names a peer lead's held mailbox (LeadChannel/LeadMailbox), never a
-        // worker's ReplyInbox — fleet_ack has no route to it and must say so, pointing at
-        // fleet_poll{coordId} instead of reporting a false "acknowledged".
-        McpSchema.CallToolResult res = FleetMcp.ack(messages, "coord-some-peer", "msg-1");
-        assertTrue(res.isError());
-        assertTrue(textOf(res).contains("fleet_poll{coordId}"), textOf(res));
-    }
-
     @Test
     void bridgeAckRemovesSpecificReply() {
         // Queue a reply and capture its msgId.
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "orphan");
+        FleetMcp.reply(messages, "term_a", "orphan");
         var before = messages.drainReplies("term_a");
         assertEquals(1, before.size(), "one reply in the inbox");
         String msgId = before.getFirst().msgId();
 
         // Publish the same reply again and ack it via fleet_ack surface.
-        FleetMcp.reply(messages, "term_a", Role.WORKER, "orphan-again");
+        FleetMcp.reply(messages, "term_a", "orphan-again");
         var peeked = messages.drainReplies("term_a");
         assertEquals(1, peeked.size(), "one fresh reply in the inbox");
 
-        // fleetd #437: msgId was already drained above (a fresh UUID each publish), so it is no
-        // longer in the inbox — ackReply must now report that miss instead of pretending to ack.
-        assertFalse(messages.ackReply("term_a", msgId));
-    }
-
-    @Test
-    void bridgeAckRemovingARealQueuedReplyReportsSuccessAndRemovesIt() {
-        // The worker path must not change behaviour: acking a reply that IS still in the inbox
-        // still succeeds and still removes it (fleetd #437).
-        inbox.publish("term_a", "real-1", "still queued");
-        assertTrue(messages.ackReply("term_a", "real-1"), "ack of a real queued reply must report true");
-        assertTrue(inbox.peek("term_a").isEmpty(), "the acked reply must be gone from the inbox");
+        // ackReply works (no-op since published with a different UUID, but callable).
+        assertDoesNotThrow(() -> messages.ackReply("term_a", msgId));
     }
 
     @Test

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetProfilesArmedFieldTest.java

@@ -1,62 +0,0 @@
-package dev.ltms.fleet.mcp;
-
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.guard.SubscriptionGuard;
-import dev.ltms.fleet.herdr.AgentControl;
-import dev.ltms.fleet.herdr.FakeHerdr;
-import dev.ltms.fleet.herdr.WorkspaceControl;
-import dev.ltms.fleet.member.ClaudeCodeLauncher;
-import dev.ltms.fleet.peer.PeerLauncher;
-import io.modelcontextprotocol.spec.McpSchema;
-import org.junit.jupiter.api.Test;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.assertNotEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #395: {@code fleet_profiles} must let an operator tell "this profile's usage-limit
- * detection is armed" from "nothing can ever quarantine this profile" — see {@link
- * FleetMcp.QuarantineSource#exhaustedPatternArmed()} and {@link
- * FleetMcp#profilesView(PeerLauncher, FleetMcp.QuarantineSource, FleetMcp.OutageSource)}.
- */
-class FleetProfilesArmedFieldTest {
-
-    private static PeerLauncher twoProfileLauncher(FakeHerdr h) {
-        FleetConfig.Profile armed = new FleetConfig.Profile(
-                "armed-profile", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN", null,
-                "tab", "fleetd-workers", "worker: {profile} #{n}", null, null, null);
-        FleetConfig.Profile unarmed = new FleetConfig.Profile(
-                "unarmed-profile", "http://gx01.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN", null,
-                "tab", "fleetd-workers", "worker: {profile} #{n}", null, null, null);
-        Map<String, FleetConfig.Profile> profiles = new LinkedHashMap<>();
-        profiles.put(armed.profile(), armed);
-        profiles.put(unarmed.profile(), unarmed);
-        return new ClaudeCodeLauncher(new AgentControl(h), new WorkspaceControl(h),
-                new SubscriptionGuard(Set.of("gx00.gw", "gx01.gw")), profiles, armed.profile(), _ -> "tok");
-    }
-
-    private static String textOf(McpSchema.CallToolResult r) {
-        return ((McpSchema.TextContent) r.content().getFirst()).text();
-    }
-
-    @Test
-    void armedProfileReportsArmedAndUnarmedReportsUnarmed() {
-        FakeHerdr h = new FakeHerdr();
-        PeerLauncher workers = twoProfileLauncher(h);
-        FleetMcp.QuarantineSource source = new FleetMcp.QuarantineSource(
-                _ -> null, dev.ltms.fleet.placement.BackendQuarantine.none(),
-                profile -> "armed-profile".equals(profile));
-
-        McpSchema.CallToolResult res = FleetMcp.profiles(workers, source);
-        assertNotEquals(Boolean.TRUE, res.isError());
-        String out = textOf(res);
-
-        assertTrue(out.contains("\"exhaustionDetectionArmed\""), out);
-        assertTrue(out.contains("\"armed-profile\":true"), out);
-        assertTrue(out.contains("\"unarmed-profile\":false"), out);
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetProfilesLiveDefaultTest.java

@@ -1,114 +0,0 @@
-package dev.ltms.fleet.mcp;
-
-import dev.ltms.fleet.config.ConfigRef;
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.guard.SubscriptionGuard;
-import dev.ltms.fleet.herdr.AgentControl;
-import dev.ltms.fleet.herdr.FakeHerdr;
-import dev.ltms.fleet.herdr.WorkspaceControl;
-import dev.ltms.fleet.member.ClaudeCodeLauncher;
-import dev.ltms.fleet.member.CompositePeerLauncher;
-import dev.ltms.fleet.peer.MemberRole;
-import dev.ltms.fleet.peer.PeerLauncher;
-import dev.ltms.fleet.peer.SpawnRequest;
-import dev.ltms.fleet.placement.BackendQuarantine;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-/**
- * fleetd #425: {@code fleet_profiles}' {@code "default"} field was captured once at boot
- * ({@code cfg.effectiveDefaultProfile()}, frozen into {@code CompositePeerLauncher.defaultProfile}
- * at construction) while an unqualified spawn resolves the same underlying key
- * ({@code fleet.developers}' first entry) live, on every call. Reordering {@code fleet.developers}
- * and reloading changed where a spawn landed without ever changing what {@code fleet_profiles}
- * reported — a lead following {@code CLAUDE.md}'s "check {@code fleet_profiles} once per session"
- * instruction was told a stale answer.
- *
- * <p>This test drives the exact caller {@code fleet_profiles} uses —
- * {@link FleetMcp#profilesView(PeerLauncher, FleetMcp.QuarantineSource, FleetMcp.OutageSource)} —
- * against a real, reloadable {@link ConfigRef}, so it fails if the reporting path is ever recoupled
- * to a frozen value instead of {@link CompositePeerLauncher#defaultProfile()}'s live answer.
- */
-class FleetProfilesLiveDefaultTest {
-
-    /** A minimal fleetd.yaml whose dev pool is {@code profilesInOrder}, in that definition order. */
-    private static String yamlWithDevPool(String... profilesInOrder) {
-        StringBuilder devPool = new StringBuilder();
-        for (int i = 0; i < profilesInOrder.length; i++) {
-            devPool.append("    slot").append(i).append(":\n      profile: ")
-                    .append(profilesInOrder[i]).append('\n');
-        }
-        return """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                herdrSocket: ~/.config/herdr/herdr.sock
-                profiles:
-                  opus:
-                    baseUrl: http://gx00.gw:8000
-                    model: opus-coder
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet-coder
-                guard:
-                  offSubscriptionHosts:
-                    - gx00.gw
-                fleet:
-                  developers:
-                """ + devPool;
-    }
-
-    @Test
-    void fleetProfilesDefaultTracksALiveDevPoolReorderAfterReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yamlWithDevPool("opus", "sonnet"));
-        ConfigRef ref = new ConfigRef(f, FleetConfig.load(f));
-
-        Map<String, FleetConfig.Profile> profiles = Map.of(
-                "opus", new FleetConfig.Profile("opus", "http://gx00.gw:8000", "opus-coder", null,
-                        "FLEETD_WORKER_TOKEN", List.of("claude"), "tab", "fleetd-workers",
-                        "worker: {profile} #{n}", null, null, null),
-                "sonnet", new FleetConfig.Profile("sonnet", "http://gx00.gw:8000", "sonnet-coder", null,
-                        "FLEETD_WORKER_TOKEN", List.of("claude"), "tab", "fleetd-workers",
-                        "worker: {profile} #{n}", null, null, null));
-        FakeHerdr herdr = new FakeHerdr();
-        ClaudeCodeLauncher adapter = new ClaudeCodeLauncher(new AgentControl(herdr), new WorkspaceControl(herdr),
-                new SubscriptionGuard(Set.of("gx00.gw")), profiles, "opus", _ -> null);
-        PeerLauncher workers = new CompositePeerLauncher(
-                List.of(adapter), "opus", ref, _ -> 0, BackendQuarantine.none());
-
-        assertReportedDefaultMatchesAnUnqualifiedSpawn(workers, "opus");
-
-        Files.writeString(f, yamlWithDevPool("sonnet", "opus"));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), () -> "reload should apply cleanly: " + out.error());
-
-        assertReportedDefaultMatchesAnUnqualifiedSpawn(workers, "sonnet");
-    }
-
-    /**
-     * Asserts BOTH that {@code fleet_profiles}' {@code "default"} equals {@code expected}, AND that
-     * it equals what a real unqualified {@code MemberRole#DEV} spawn actually gets placed on right
-     * now — the two facts fleetd #425 found disagreeing.
-     */
-    private static void assertReportedDefaultMatchesAnUnqualifiedSpawn(PeerLauncher workers, String expected) {
-        Map<String, Object> view = FleetMcp.profilesView(
-                workers, FleetMcp.QuarantineSource.none(), FleetMcp.OutageSource.none());
-        assertEquals(expected, view.get("default"),
-                "fleet_profiles' \"default\" must be the live dev-pool answer, not a boot-time snapshot");
-
-        String placed = workers.spawn(
-                new SpawnRequest(null, null, null, null, null, MemberRole.DEV)).profile();
-        assertEquals(expected, placed,
-                "sanity: the profile an unqualified dev spawn actually lands on");
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/mcp/FleetProfilesModelGateStateTest.java

@@ -1,109 +0,0 @@
-package dev.ltms.fleet.mcp;
-
-import dev.ltms.fleet.config.FleetConfig;
-import dev.ltms.fleet.guard.SubscriptionGuard;
-import dev.ltms.fleet.herdr.AgentControl;
-import dev.ltms.fleet.herdr.FakeHerdr;
-import dev.ltms.fleet.herdr.WorkspaceControl;
-import dev.ltms.fleet.member.ClaudeCodeLauncher;
-import dev.ltms.fleet.member.CompositePeerLauncher;
-import dev.ltms.fleet.member.HerdrPeerLauncher;
-import dev.ltms.fleet.peer.PeerLauncher;
-import dev.ltms.fleet.placement.BackendOutagePolicy;
-import dev.ltms.fleet.placement.BackendQuarantine;
-import dev.ltms.fleet.placement.PlacementPolicies;
-import org.junit.jupiter.api.Test;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-
-/**
- * fleetd #422 follow-up: {@code fleet_profiles}/{@code GET /profiles} — the reporting surface a
- * lead actually reads — must let it tell apart the three states {@link
- * dev.ltms.fleet.peer.PeerLauncher#disabledModels()} alone collapses into one empty set: no
- * {@code models:} block at all, a block armed with nothing currently off, and a block with N
- * models off. See {@link dev.ltms.fleet.peer.PeerLauncher.ModelGateState}'s javadoc for why a
- * bare {@code disabledModels()} read cannot make this distinction, and {@link
- * FleetMcp#profilesView} for where {@code modelGateArmed} is added alongside the existing {@code
- * modelsOff} key.
- *
- * <p>Every assertion here goes through {@link FleetMcp#profilesView}, never {@code
- * PeerLauncher.modelGateState()} directly — {@code CompositePeerLauncherTest} already proves the
- * accessor itself; this class proves the surface a lead reads (fleet_profiles / GET /profiles)
- * renders what that accessor reports.
- */
-class FleetProfilesModelGateStateTest {
-
-    private static FleetConfig.Profile profile(String name, String model) {
-        return new FleetConfig.Profile(name, "http://gx00.gw:8000", model, null, "FLEETD_WORKER_TOKEN",
-                null, "tab", "fleetd-workers", "worker: {profile} #{n}", null, null, null);
-    }
-
-    private static FleetMcp.QuarantineSource noQuarantine() {
-        return new FleetMcp.QuarantineSource(_ -> null, BackendQuarantine.none(), _ -> false);
-    }
-
-    private static HerdrPeerLauncher claudeAdapter(FakeHerdr h, Map<String, FleetConfig.Profile> profiles) {
-        return new ClaudeCodeLauncher(new AgentControl(h), new WorkspaceControl(h),
-                new SubscriptionGuard(Set.of("gx00.gw")), profiles, "local", _ -> "tok");
-    }
-
-    /**
-     * State 1: no {@code models:} block at all — a plain {@code ClaudeCodeLauncher} (no {@code
-     * models:} supplier exists for it to read) has nothing to gate against, matching the fleet01
-     * host measured for this ticket: {@code grep -c '^models:' fleetd.yaml} returns 0 there.
-     */
-    @Test
-    void noModelsBlockReportsGateNotArmed() {
-        FakeHerdr h = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = Map.of("local", profile("local", "deepseek-v4-flash"));
-        PeerLauncher workers = claudeAdapter(h, profiles);
-
-        Map<String, Object> view = FleetMcp.profilesView(workers, noQuarantine(), FleetMcp.OutageSource.none());
-
-        assertEquals(Boolean.FALSE, view.get("modelGateArmed"),
-                "no models: block to read from — nothing is gated, and nothing can be");
-        assertFalse(view.containsKey("modelsOff"), "nothing configured, so no off set to report either");
-    }
-
-    /** State 2: a {@code models:} block is present, but nothing in it is currently turned off. */
-    @Test
-    void modelsBlockWithNothingOffReportsGateArmedAndZeroOff() {
-        FakeHerdr h = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = Map.of("local", profile("local", "deepseek-v4-flash"));
-        FleetConfig.Models models = new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("deepseek-v4-flash", true)));
-        PeerLauncher workers = new CompositePeerLauncher(List.of(claudeAdapter(h, profiles)), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(),
-                new BackendOutagePolicy(System::nanoTime), () -> models);
-
-        Map<String, Object> view = FleetMcp.profilesView(workers, noQuarantine(), FleetMcp.OutageSource.none());
-
-        assertEquals(Boolean.TRUE, view.get("modelGateArmed"),
-                "a models: block is present, so the gate is armed even though nothing is off yet");
-        assertFalse(view.containsKey("modelsOff"),
-                "nothing is off, so the key stays absent — an empty list here would be indistinguishable "
-                        + "from today's modelsOff omission, exactly the ambiguity modelGateArmed exists to remove");
-    }
-
-    /** State 3: a {@code models:} block is present with one model currently turned off. */
-    @Test
-    void modelsBlockWithModelsOffReportsGateArmedAndTheOffSet() {
-        FakeHerdr h = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = Map.of("local", profile("local", "deepseek-v4-flash"));
-        FleetConfig.Models models = new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        PeerLauncher workers = new CompositePeerLauncher(List.of(claudeAdapter(h, profiles)), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(),
-                new BackendOutagePolicy(System::nanoTime), () -> models);
-
-        Map<String, Object> view = FleetMcp.profilesView(workers, noQuarantine(), FleetMcp.OutageSource.none());
-
-        assertEquals(Boolean.TRUE, view.get("modelGateArmed"));
-        assertEquals(List.of("deepseek-v4-flash"), view.get("modelsOff"));
-    }
-}

fleetd/src/test/java/dev/ltms/fleet/member/ClaudeCodeLauncherTest.java

@@ -925,71 +925,6 @@ class ClaudeCodeLauncherTest {
         assertTrue(herdr.called("pane.close"), "stop via handle.id() must close the pane");
     }
 
-    /** A tab-placement launcher with {@code memberCredentials policy=allow-list} under a zsh shell — the
-     * combination that makes {@link HerdrPeerLauncher#spawn} generate a real ZDOTDIR, so {@code
-     * releaseZdotdir}'s effect (the directory's deletion) is observable from a test. */
-    private ClaudeCodeLauncher serviceWithAllowList(FakeHerdr herdr) {
-        FleetConfig.Profile cfg = new FleetConfig.Profile(
-                "ltms-local", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN",
-                List.of("ccs", "ltms-local"), "tab", "fleetd-workers",
-                "worker: {profile} #{n}", null, null, null);
-        Supplier<FleetConfig.MemberCredentials> creds = () -> new FleetConfig.MemberCredentials(
-                FleetConfig.MemberCredentials.POLICY_ALLOW_LIST, List.of(), List.of(), null);
-        Function<String, String> env = name -> "SHELL".equals(name) ? "/bin/zsh" : null;
-        return new ClaudeCodeLauncher(new AgentControl(herdr), new WorkspaceControl(herdr),
-                new SubscriptionGuard(Set.of("gx00.gw")), Map.of(cfg.profile(), cfg), cfg.profile(),
-                env, 0, System::currentTimeMillis, () -> { }, null, creds);
-    }
-
-    /**
-     * fleetd #293: {@code stop()} used to run {@code spaces.closeTab} bare — any non-{@code
-     * *_not_found} herdr error propagated straight out of {@code stop()}, skipping {@code
-     * releaseZdotdir} entirely (the pane was already closed by that point, so the tab-close failure
-     * is cosmetic, not a real teardown failure). Proves both halves of the fix: {@code stop()} no
-     * longer throws for this failure, and {@code releaseZdotdir} still runs — observed here by the
-     * generated ZDOTDIR actually being deleted, since {@code releaseZdotdir}'s last line is {@code
-     * EnvAllowListScrub.deleteRecursively(dir)}.
-     */
-    @Test
-    @SuppressWarnings("unchecked")
-    void stopStillReleasesZdotdirWhenCloseTabFailsWithANonNotFoundCode() {
-        FakeHerdr herdr = new FakeHerdr();
-        ClaudeCodeLauncher svc = serviceWithAllowList(herdr);
-        PeerHandle handle = svc.spawn(new SpawnRequest(null, null, null));
-        Map<String, Object> tabCreateParams = (Map<String, Object>) herdr.lastCall("tab.create").params();
-        Map<String, String> tabEnv = (Map<String, String>) tabCreateParams.get("env");
-        String zdotdir = tabEnv.get("ZDOTDIR");
-        assertNotNull(zdotdir, "policy=allow-list under a zsh shell must have generated a ZDOTDIR: " + tabEnv);
-        Path dir = Path.of(zdotdir);
-        assertTrue(Files.isDirectory(dir), "the generated ZDOTDIR must exist before stop(): " + dir);
-        herdr.tabCloseFailsForTab("w9:t2", "internal_error");
-
-        Logger logger = (Logger) LoggerFactory.getLogger(HerdrPeerLauncher.class);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            assertDoesNotThrow(() -> svc.stop(handle.id()),
-                    "fleetd #293: a failing tab.close is cosmetic — it must not propagate out of stop()");
-        } finally {
-            logger.detachAppender(appender);
-        }
-
-        assertTrue(herdr.called("tab.close"), "tab.close was still attempted");
-        assertFalse(Files.exists(dir),
-                "releaseZdotdir must still run and delete the generated ZDOTDIR despite the tab.close "
-                        + "failure: " + dir);
-        String warn = appender.list.stream()
-                .filter(e -> e.getLevel().equals(Level.WARN))
-                .map(ILoggingEvent::getFormattedMessage)
-                .filter(m -> m.contains("tab.close") && m.contains("w9:t2"))
-                .findFirst()
-                .orElse(null);
-        assertNotNull(warn, "the failing tab.close must be logged at WARN naming the tab id — a "
-                + "silently swallowed failure with no message is not an improvement. Log lines: "
-                + appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList());
-    }
-
     // --- CB-519: host-unique id, decoupled from the pane coordinate ------------------------------
 
     @Test
@@ -1165,8 +1100,7 @@ class ClaudeCodeLauncherTest {
     @Test
     void spawnLetsAnUnrelatedHerdrErrorPropagateUnchanged() {
         // Fix 1 must only special-case a "*_not_found" answer. Any other herdr failure keeps
-        // propagating as-is — this gate does not know how to recover from it. The pane still needs
-        // closing because spawn throws before it can return the pane id to a caller that could stop it.
+        // propagating as-is — this gate does not know how to recover from it.
         FakeHerdr herdr = new FakeHerdr();
         herdr.agentStatus("unknown");
         herdr.agentGetFailsWithAfter(0, "internal_error");
@@ -1183,27 +1117,8 @@ class ClaudeCodeLauncherTest {
                 () -> svc.spawn(new SpawnRequest(null, null, null)));
 
         assertEquals("internal_error", ex.code());
-        assertEquals(1, paneCloseCount(herdr, "w9:pRoot_1"),
-                "the unchanged error leaves spawn without a pane id, so this gate closes its orphaned pane");
-    }
-
-    @Test
-    void panePlacementClosesTheSplitPaneWhenAgentStartFails() {
-        FakeHerdr herdr = new FakeHerdr().agentStartFailsWith("internal_error");
-        FleetConfig.Profile cfg = new FleetConfig.Profile(
-                "ltms-local", "http://gx00.gw:8000", "coder", null, "FLEETD_WORKER_TOKEN",
-                List.of("claude"), "pane", "fleetd-workers", "w #{n}", null, null, null);
-        ClaudeCodeLauncher svc = new ClaudeCodeLauncher(
-                new AgentControl(herdr), new WorkspaceControl(herdr),
-                new SubscriptionGuard(Set.of("gx00.gw")), Map.of(cfg.profile(), cfg), cfg.profile(), _ -> null);
-
-        dev.ltms.fleet.herdr.HerdrException ex = assertThrows(
-                dev.ltms.fleet.herdr.HerdrException.class,
-                () -> svc.spawn(new SpawnRequest(null, null, null)));
-
-        assertEquals("internal_error", ex.code(), "agent.start failure propagates unchanged");
-        assertEquals(1, paneCloseCount(herdr, "w1:pSplit"),
-                "the pane split for a peer that never starts is closed instead of left orphaned");
+        assertEquals(0, paneCloseCount(herdr, "w9:pRoot_1"),
+                "an error this gate does not recognize is not this gate's teardown to run");
     }
 
     // --- fleetd #176 fix 2: corroborated UNKNOWN refinement --------------------------------------
@@ -2827,126 +2742,4 @@ class ClaudeCodeLauncherTest {
                 "a WARN naming the cwd must fire when the profile sets no configDir: "
                         + appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList());
     }
-
-    // --- fleetd #285: seedTrustDialog under memberHerdrSocket --------------------------------------
-    //
-    // seedTrustDialog gated only on isProvisionedWorktree(cwd) and, being static, could not see
-    // memberHerdrSocketConfigured() at all — unlike its sibling writeCharterFile one method below,
-    // which already refuses the spawn when it cannot place the charter where a different-uid member
-    // can read it. Under memberHerdrSocket + configDir unset, seedTrustDialog wrote fleetd's OWN
-    // ~/.claude.json (the operator's real file) while believing it was seeding the member's. The fix
-    // makes the method an instance method so it can see memberHerdrSocketConfigured(), and applies
-    // the same "refuse, don't silently write somewhere wrong" rule writeCharterFile already uses.
-
-    @Test
-    void seedTrustDialogUnderMemberHerdrSocketSharesTheFileWithTheConfiguredGroup(
-            @TempDir Path configDir, @TempDir Path worktree, @TempDir Path worktreeRoot) throws Exception {
-        markAsProvisionedWorktree(worktree);
-        String group = currentUserGroup();
-        FakeHerdr herdr = new FakeHerdr();
-        // trustProfile always sets a bridge mcpUrl, so a reply charter is generated too, which
-        // means writeCharterFile ALSO runs under memberHerdrSocket and needs its own worktreeRoot —
-        // pass one so this test isolates the trust-seed behaviour instead of tripping that refusal.
-        FleetConfig.Profile cfg = trustProfile(configDir.toString(), worktree.toString());
-        serviceWithConfig(herdr, cfg, () -> configWithMemberHerdrSocket(worktreeRoot.toString(), group)).spawn();
-
-        Path claudeJson = configDir.resolve(".claude.json");
-        assertTrue(Files.exists(claudeJson), "still seeded into <configDir>/.claude.json under memberHerdrSocket");
-        JsonNode project = new ObjectMapper().readTree(claudeJson.toFile())
-                .path("projects").path(worktree.toString());
-        assertTrue(project.path("hasTrustDialogAccepted").asBoolean(false));
-
-        assertEquals("rw-r-----", PosixFilePermissions.toString(Files.getPosixFilePermissions(claudeJson)),
-                "under memberHerdrSocket the file must be shared group-readable, mirroring the "
-                        + "charter file's own per-file mode (fleetd #222) — a 0600 file (Claude "
-                        + "Code's own default) is unreadable by the member's different OS user");
-        String actualGroup = Files.getFileAttributeView(claudeJson, PosixFileAttributeView.class)
-                .readAttributes().group().getName();
-        assertEquals(group, actualGroup, "the file must be chgrp'd to the configured worktreeGroup");
-    }
-
-    /**
-     * The bug itself: {@code memberHerdrSocket} configured, {@code configDir} unset. Before the fix
-     * this wrote fleetd's own default {@code ~/.claude.json} (here redirected to {@code fakeHome} so
-     * a reintroduced bug still cannot touch the real operator file); after the fix it must refuse the
-     * spawn instead, naming {@code configDir} as the missing key, before the member is ever started.
-     */
-    @Test
-    void seedTrustDialogUnderMemberHerdrSocketRefusesWhenConfigDirUnset(
-            @TempDir Path fakeHome, @TempDir Path worktree) throws Exception {
-        markAsProvisionedWorktree(worktree);
-        String originalHome = System.getProperty("user.home");
-        System.setProperty("user.home", fakeHome.toString());
-        try {
-            FakeHerdr herdr = new FakeHerdr();
-            FleetConfig.Profile cfg = trustProfile(null, worktree.toString());
-            ClaudeCodeLauncher launcher = serviceWithConfig(herdr, cfg,
-                    () -> configWithMemberHerdrSocket(null, "some-group"));
-
-            IllegalStateException ex = assertThrows(IllegalStateException.class, launcher::spawn,
-                    "memberHerdrSocket + no configDir must refuse the spawn, not write fleetd's own "
-                            + "default ~/.claude.json");
-            assertTrue(ex.getMessage().contains("configDir"),
-                    "the refusal must name the missing config key — got: " + ex.getMessage());
-            assertFalse(Files.exists(fakeHome.resolve(".claude.json")),
-                    "nothing may be written to fleetd's own default home — this is the exact fleetd "
-                            + "#285 defect: writing the operator's own home instead of the member's");
-            assertFalse(herdr.called("agent.start"),
-                    "the spawn must be refused BEFORE the member is ever started — got calls: " + herdr.calls);
-        } finally {
-            System.setProperty("user.home", originalHome);
-        }
-    }
-
-    /**
-     * {@code configDir} alone is not enough — without {@code worktreeGroup} the file fleetd writes
-     * stays {@code 0600} and the member's different OS user still cannot read it, so this must also
-     * refuse, naming {@code worktreeGroup} this time.
-     */
-    @Test
-    void seedTrustDialogUnderMemberHerdrSocketRefusesWhenWorktreeGroupUnset(
-            @TempDir Path configDir, @TempDir Path worktree) throws Exception {
-        markAsProvisionedWorktree(worktree);
-        FakeHerdr herdr = new FakeHerdr();
-        FleetConfig.Profile cfg = trustProfile(configDir.toString(), worktree.toString());
-        ClaudeCodeLauncher launcher = serviceWithConfig(herdr, cfg,
-                () -> configWithMemberHerdrSocket(null, null));
-
-        IllegalStateException ex = assertThrows(IllegalStateException.class, launcher::spawn,
-                "memberHerdrSocket + no worktreeGroup must refuse the spawn, not write an unreadable file");
-        assertTrue(ex.getMessage().contains("worktreeGroup"),
-                "configDir alone is not enough — got: " + ex.getMessage());
-        assertFalse(Files.exists(configDir.resolve(".claude.json")),
-                "nothing may be written when the file cannot be shared with the member's group");
-        assertFalse(herdr.called("agent.start"),
-                "the spawn must be refused BEFORE the member is ever started");
-    }
-
-    /**
-     * Regression proof: with {@code memberHerdrSocket} ABSENT — even given a LIVE, non-null {@code
-     * config} supplier (not merely {@code config == null}, which every other seedTrustDialog test in
-     * this file already exercises) — the write must stay byte-identical to before this fix: existing
-     * {@code 0600} permissions preserved, no chgrp/chmod attempted. This is the proof the ticket asks
-     * for: the path the whole live fleet uses today is unchanged by this fix.
-     */
-    @Test
-    void seedTrustDialogPreservesExisting0600PermissionsWhenMemberHerdrSocketAbsentEvenWithALiveConfigSupplier(
-            @TempDir Path configDir, @TempDir Path worktree) throws Exception {
-        markAsProvisionedWorktree(worktree);
-        Path claudeJson = configDir.resolve(".claude.json");
-        Files.writeString(claudeJson, "{}");
-        assumeTrue(Files.getFileAttributeView(claudeJson, PosixFileAttributeView.class) != null,
-                "no POSIX permissions on this filesystem — skipping rather than failing");
-        Files.setPosixFilePermissions(claudeJson, PosixFilePermissions.fromString("rw-------"));
-
-        FakeHerdr herdr = new FakeHerdr();
-        FleetConfig.Profile cfg = trustProfile(configDir.toString(), worktree.toString());
-        FleetConfig config = new FleetConfig(null, null, null, Map.of(), null, null, null, null, null,
-                null, null, null, null, null, null, null, null, null, null, null, null, null).withDefaults();
-        serviceWithConfig(herdr, cfg, () -> config).spawn();
-
-        assertEquals("rw-------", PosixFilePermissions.toString(Files.getPosixFilePermissions(claudeJson)),
-                "with memberHerdrSocket absent — even given a live config supplier — the seed must "
-                        + "stay byte-identical to before this fix: no chgrp/chmod attempted");
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/member/CompositePeerLauncherTest.java

@@ -3,7 +3,6 @@ package dev.ltms.fleet.member;
 import ch.qos.logback.classic.Logger;
 import ch.qos.logback.classic.spi.ILoggingEvent;
 import ch.qos.logback.core.read.ListAppender;
-import dev.ltms.fleet.config.ConfigRef;
 import dev.ltms.fleet.config.FleetConfig;
 import dev.ltms.fleet.guard.SubscriptionGuard;
 import dev.ltms.fleet.herdr.Agent;
@@ -20,15 +19,11 @@ import dev.ltms.fleet.peer.PeerUnreachableException;
 import dev.ltms.fleet.peer.SpawnRequest;
 import dev.ltms.fleet.placement.BackendOutagePolicy;
 import dev.ltms.fleet.placement.BackendQuarantine;
-import dev.ltms.fleet.placement.PlacementDecision;
 import dev.ltms.fleet.placement.PlacementException;
 import dev.ltms.fleet.placement.PlacementPolicies;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
 import org.slf4j.LoggerFactory;
 
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -146,13 +141,6 @@ class CompositePeerLauncherTest {
                 null, null, credentialId, null);
     }
 
-    /** Like {@link #stubWorker(String)}, but with an explicit {@code model:} for fleetd #422 tests. */
-    private static FleetConfig.Profile stubWorkerModel(String profile, String model) {
-        return new FleetConfig.Profile(profile, "http://gx00.gw:8000", model,
-                null, "FLEETD_WORKER_TOKEN", List.of("claude"), "tab", "fleetd-workers",
-                "w #{n}", null, null, null, null, null, null, null, null, null);
-    }
-
     /**
      * An <em>order-preserving</em> profile map. Never {@code Map.of} here: its iteration order is
      * salted per JVM run, and the weighted policy breaks an exact-weight tie on candidate order —
@@ -311,41 +299,6 @@ class CompositePeerLauncherTest {
                 "two adapter kinds sharing one daemon keep the fallback route");
     }
 
-    @Test
-    void stopThroughTheSingleDaemonShortcutStillClosesTheTabWhenTheFallbackDelegateUsesPanePlacement() {
-        // fleetd #342: the single-daemon shortcut (spawnedBy empty, herdrDaemonCount()==1) always
-        // routes stop() through delegates.getFirst() — here the claude adapter, configured for
-        // PANE placement (its own profiles never create a dedicated tab). The pane being torn
-        // down here actually belongs to the opencode adapter's TAB placement, sharing the same
-        // herdr daemon — mixing placements is the point: every existing stop-fallback test in this
-        // class configures BOTH adapters as "tab", so usesTabPlacement() was true either way and
-        // the mis-routing never showed.
-        //
-        // Before the fix, HerdrPeerLauncher#stop gated tab resolution on usesTabPlacement() of the
-        // delegate it happened to be called through, so the wrongly-routed (pane-placement) claude
-        // adapter never even looked for a tab to close, and the now-empty tab leaked with nothing
-        // to reap it. The fix (fleetd #342) resolves the pane's real tab unconditionally, so the
-        // decision follows the pane's actual placement rather than the fallback delegate's static
-        // config.
-        FakeHerdr herdr = new FakeHerdr();
-        FleetConfig.Profile claudePane = new FleetConfig.Profile("claude", "http://gx00.gw:8000",
-                "coder", null, "FLEETD_WORKER_TOKEN", List.of("claude"), "pane", "fleetd-workers",
-                "w #{n}", null, null, null);
-        ClaudeCodeLauncher claude = new ClaudeCodeLauncher(new AgentControl(herdr), new WorkspaceControl(herdr),
-                new SubscriptionGuard(Set.of("gx00.gw")), Map.of("claude", claudePane), "claude", _ -> null);
-        PeerLauncher composite = new CompositePeerLauncher(List.of(claude, opencodeAdapter(herdr)), "claude");
-
-        // "w9:pW" was never spawned through this composite instance, so spawnedBy has no entry for
-        // it (the same in-memory-cache-miss shape a daemon restart leaves behind) — stop() falls
-        // through to the single-daemon shortcut and hands it to delegates.getFirst() (claude).
-        composite.stop("w9:pW");
-
-        assertTrue(herdr.called("pane.close"), "the pane itself is still closed on every routed path");
-        assertTrue(herdr.called("tab.close"),
-                "the pane's real (sole-occupant) tab must be closed even though the fallback routed "
-                        + "through a delegate configured for pane placement");
-    }
-
     @Test
     void listKeepsBothPanesWhenTwoDaemonsShareAPaneId() {
         // herdr pane ids are per-daemon counters, so two daemons really can both hold w1:p1 on
@@ -537,31 +490,6 @@ class CompositePeerLauncherTest {
         assertEquals("claude", h.profile(), "the returned handle carries the resolved default profile");
     }
 
-    /**
-     * fleetd #435: {@code FixedPlacementPolicy} — the default placement policy every config uses
-     * unless {@code placement:} is set — never consulted {@code maxLoad}, so an unqualified spawn
-     * (a blank profile, the normal delegation path) landed on a capped default anyway. Measured on
-     * 7667727: a single dev profile at {@code maxLoad: 1} with 1 live, under {@code fixed()},
-     * returned "SPAWNED on profile=a". This test goes through {@code CompositePeerLauncher.spawn}
-     * with a blank profile, not the policy in isolation, so it proves the caller actually reaches
-     * the fixed default's new cap check rather than only the {@code select} method.
-     */
-    @Test
-    void fixedPolicyGatesDefaultProfileAtMaxLoadOnUnqualifiedSpawn() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "a", stubWorker("a", 1.0f, 1),
-                "b", stubWorker("b", 1.0f, null));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "a", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "a", profiles, PlacementPolicies.fixed(), name -> "a".equals(name) ? 1 : 0);
-
-        PeerHandle h = composite.spawn(new SpawnRequest(null, null, null));
-        assertEquals("b", h.profile(),
-                "the default profile a is at maxLoad, so fixed placement must fall through to b");
-        assertEquals(0, adapter.spawnCount("a"), "a is never spawned — it is already at cap");
-    }
-
     @Test
     void weightedPolicyGatesProfileAtMaxLoad() {
         FakeHerdr herdr = new FakeHerdr();
@@ -687,67 +615,6 @@ class CompositePeerLauncherTest {
         assertEquals(1, adapter.spawnCount("b"));
     }
 
-    /**
-     * fleetd #315: {@code CompositePeerLauncher.spawn} rebuilds the {@link PlacementContext} after
-     * every failed attempt "so the policy excludes this profile" (see the comment at the retry call
-     * site) — but {@code FixedPlacementPolicy} never read {@code ctx.unreachable()}, so under the
-     * default {@code fixed} placement every retry re-picked the same dead default and a second,
-     * healthy, configured profile was never tried. This is the same scenario as
-     * {@link #failoverRetriesNextCandidateWhenProfileIsUnreachable}, but pinned to {@code fixed()}
-     * instead of {@code weighted()} — the three existing failover tests all use {@code weighted()},
-     * which is exactly why nobody caught this: the retry loop's contract has no coverage under its
-     * own default policy.
-     */
-    @Test
-    void failoverRetriesNextCandidateUnderFixedPlacementWhenProfileIsUnreachable() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "a", stubWorker("a"),
-                "b", stubWorker("b"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "a", Set.of("a"));
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "a", profiles, PlacementPolicies.fixed(), _ -> 0);
-
-        PeerHandle h = composite.spawn(new SpawnRequest(null, null, null));
-        assertEquals("b", h.profile(),
-                "fixed placement must fail over from the unreachable default a to the healthy b");
-        assertEquals(1, adapter.spawnCount("a"), "a was tried once and failed");
-        assertEquals(1, adapter.spawnCount("b"), "b was tried once and succeeded");
-    }
-
-    /**
-     * fleetd #315: the same fix — {@code FixedPlacementPolicy} consulting {@code ctx.unreachable()}
-     * — also covers the wiring-bug branch in {@code CompositePeerLauncher.spawn}: a profile that
-     * placement is allowed to choose (it is in the configured candidate list) but that no delegate
-     * declares ({@code byProfile.get(chosen.profile()) == null}). That branch adds the profile to
-     * {@code unreachable} and {@code continue}s without ever calling a launcher, so before this fix
-     * {@code fixed} handed back the same adapterless profile on every remaining attempt too.
-     */
-    @Test
-    void failoverSkipsAConfiguredProfileNoAdapterDeclaresUnderFixedPlacement() {
-        FakeHerdr herdr = new FakeHerdr();
-        // Placement's candidate list has three profiles, in this order (LinkedHashMap preserves it,
-        // and the fixed default resolves to the first — see the `ordered` helper's own javadoc).
-        Map<String, FleetConfig.Profile> profiles = new LinkedHashMap<>();
-        profiles.put("c", stubWorker("c"));
-        profiles.put("a", stubWorker("a"));
-        profiles.put("b", stubWorker("b"));
-        // The adapter only declares a and b — c is a configured profile with no owning adapter,
-        // the "wiring bug" the comment in CompositePeerLauncher.spawn calls out.
-        Map<String, FleetConfig.Profile> adapterProfiles = new LinkedHashMap<>();
-        adapterProfiles.put("a", stubWorker("a"));
-        adapterProfiles.put("b", stubWorker("b"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, adapterProfiles, "a", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "a", profiles, PlacementPolicies.fixed(), _ -> 0);
-
-        PeerHandle h = composite.spawn(new SpawnRequest(null, null, null));
-        assertEquals("a", h.profile(),
-                "c has no adapter, so fixed placement must skip it and land on the next candidate, a");
-        assertEquals(0, adapter.spawnCount("c"), "c is never spawned — no adapter owns it");
-        assertEquals(1, adapter.spawnCount("a"));
-    }
-
     @Test
     void explicitSpawnAtMaxLoadThrowsPlacementExceptionNamingProfileLiveAndCap() {
         FakeHerdr herdr = new FakeHerdr();
@@ -945,89 +812,6 @@ class CompositePeerLauncherTest {
         assertTrue(e.getMessage().contains("maxLoad"), e.getMessage());
     }
 
-    // ── fleetd #425: defaultProfile()/defaultProfileFor() must track a live reload ─────────────
-
-    /** A minimal fleetd.yaml whose dev pool is {@code profilesInOrder}, in that definition order. */
-    private static String yamlWithDevPool(String... profilesInOrder) {
-        StringBuilder devPool = new StringBuilder();
-        for (int i = 0; i < profilesInOrder.length; i++) {
-            devPool.append("    slot").append(i).append(":\n      profile: ")
-                    .append(profilesInOrder[i]).append('\n');
-        }
-        return """
-                bind:
-                  host: 127.0.0.1
-                  port: 8765
-                herdrSocket: ~/.config/herdr/herdr.sock
-                profiles:
-                  opus:
-                    baseUrl: http://gx00.gw:8000
-                    model: opus-coder
-                  sonnet:
-                    baseUrl: http://gx00.gw:8000
-                    model: sonnet-coder
-                guard:
-                  offSubscriptionHosts:
-                    - gx00.gw
-                fleet:
-                  developers:
-                """ + devPool;
-    }
-
-    /**
-     * Criterion 1 (fleetd #425): reorder {@code fleet.developers}, reload, and assert the reported
-     * default ({@link CompositePeerLauncher#defaultProfile()} — what {@code fleet_profiles}' {@code
-     * "default"} is built from, see {@code FleetMcp.profilesView}) matches what an unqualified
-     * {@code MemberRole#DEV} spawn is actually placed on, both before and after the reorder. Asserts
-     * {@code applied()} so the test proves the reload actually took, not that nothing changed.
-     */
-    @Test
-    void defaultProfileTracksALiveDevPoolReorderAfterReload(@TempDir Path dir) throws Exception {
-        Path f = dir.resolve("fleetd.yaml");
-        Files.writeString(f, yamlWithDevPool("opus", "sonnet"));
-        ConfigRef ref = new ConfigRef(f, FleetConfig.load(f));
-
-        FakeHerdr herdr = new FakeHerdr();
-        StubLauncher adapter = new StubLauncher("claude", herdr, threeProfiles(), "opus", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "opus", ref, _ -> 0, BackendQuarantine.none());
-
-        assertEquals("opus", composite.defaultProfile(),
-                "reported default starts at the dev pool's first entry");
-        assertEquals("opus", composite.spawn(
-                        new SpawnRequest(null, null, null, null, null, MemberRole.DEV)).profile(),
-                "an unqualified dev spawn must land on the same profile that was just reported");
-
-        Files.writeString(f, yamlWithDevPool("sonnet", "opus"));
-        ConfigRef.Outcome out = ref.reload();
-        assertTrue(out.applied(), () -> "reload should apply cleanly: " + out.error());
-
-        assertEquals("sonnet", composite.defaultProfile(),
-                "the reported default must follow the reorder with no daemon restart");
-        assertEquals("sonnet", composite.spawn(
-                        new SpawnRequest(null, null, null, null, null, MemberRole.DEV)).profile(),
-                "and it must still be exactly what an unqualified spawn actually gets");
-    }
-
-    /**
-     * Criterion 2 — the mirror, and the load-bearing half (fleetd #425): with NOTHING configured (no
-     * profiles at all, hence an empty pool for every role), the frozen {@code defaultProfile} field
-     * is still what gets reported. A fix that always returns {@code poolFor(role).getFirst()} with no
-     * empty-pool fallback throws or returns the wrong thing here even though criterion 1 above still
-     * passes — this is the test that catches it.
-     */
-    @Test
-    void defaultProfileFallsBackToTheFrozenFieldWhenNothingIsConfiguredAtAll() {
-        FakeHerdr herdr = new FakeHerdr();
-        StubLauncher adapter = new StubLauncher("claude", herdr, Map.of(), "opus", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "opus", Map.of(), PlacementPolicies.fixed(), _ -> 0);
-
-        assertEquals("opus", composite.defaultProfile(),
-                "with no profiles configured at all, the frozen field is the only answer available");
-        assertEquals("opus", composite.defaultProfileFor(MemberRole.DEV));
-    }
-
     // ── CB-578 stage B: a BACKEND_EXHAUSTED classification quarantines the credential ──────────
 
     @Test
@@ -1094,98 +878,6 @@ class CompositePeerLauncherTest {
         assertEquals(0, adapter.spawnCount("sol"));
     }
 
-    /**
-     * fleetd #425 rework, acceptance 1: {@link CompositePeerLauncher#routedProfileFor} must apply
-     * the SAME quarantine filtering {@link CompositePeerLauncher#spawn} does, under {@code fixed()}
-     * — the DEFAULT placement policy, deliberately not {@code weighted()} (which the regressed
-     * round's own tests all used, and which never exercises {@code FixedPlacementPolicy}'s own
-     * inline filter). This is the exact defect: the previous round's {@code defaultProfileFor}
-     * blindly returns the pool's first entry ("sol", quarantined here) with no awareness of
-     * quarantine at all, which is what turned a routine unqualified spawn into a hard throw once
-     * {@code acquireWithWorktree} pre-resolved through it.
-     */
-    @Test
-    void routedProfileForSkipsAQuarantinedPoolFirstProfileUnderFixedPolicy() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "sol", stubWorker("sol", "shared-openai"),
-                "b", stubWorker("b"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "sol", Set.of());
-        BackendQuarantine quarantine = new BackendQuarantine(() -> 0L, TimeUnit.MINUTES.toNanos(30));
-        quarantine.quarantine("shared-openai");
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "sol", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, quarantine);
-
-        assertEquals("b", composite.routedProfileFor(MemberRole.DEV),
-                "sol (the pool's first entry) is quarantined, so the routed answer must be b");
-        assertEquals("sol", composite.defaultProfileFor(MemberRole.DEV),
-                "sanity: defaultProfileFor stays blind to quarantine — that's the gap routedProfileFor closes");
-        assertEquals(0, adapter.spawnCount("sol"), "routedProfileFor never spawns anything");
-        assertEquals(0, adapter.spawnCount("b"), "routedProfileFor never spawns anything");
-    }
-
-    /**
-     * fleetd #444: {@link PlacementDecision} exists to close the window between {@link
-     * CompositePeerLauncher#place} and {@link CompositePeerLauncher#spawn(SpawnRequest,
-     * PlacementDecision)} — the placement state must be free to move in that window without the
-     * held decision being re-checked against the new state. Every quarantine test above resolves
-     * and spawns in one call, so none of them ever open that window; this test is the one that
-     * does: "sol" is placed FIRST, while nothing is quarantined yet, and only THEN is its
-     * credential quarantined, before the held decision is spawned.
-     *
-     * <p>This is the test that tells the real override apart from the alternative body the ticket
-     * measured: routing {@code decision.profile()} straight to its adapter (the real override)
-     * never re-runs {@code enforceNotQuarantined}, so the spawn against the held decision still
-     * succeeds on sol. Re-entering {@code spawn(req.withProfile(decision.profile()))} instead
-     * lands in the explicit-profile branch, which refuses a now-quarantined sol outright — before
-     * this test existed, replacing the real override's body with that re-entering call left the
-     * whole suite green.
-     */
-    @Test
-    void spawnHonorsAPlacementDecisionEvenAfterItsProfileIsQuarantinedInTheWindowAfterPlace() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "sol", stubWorker("sol", "shared-openai"),
-                "b", stubWorker("b"));
-        // The adapter's OWN fallback default is "b", deliberately different from the profile place()
-        // decides ("sol") — see the note below on why this must not be "sol" too.
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "b", Set.of());
-        BackendQuarantine quarantine = new BackendQuarantine(() -> 0L, TimeUnit.MINUTES.toNanos(30));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "sol", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, quarantine);
-
-        // 1. Resolve BEFORE anything is quarantined — sol (definition order first, fixed policy) wins.
-        // composite's own defaultProfile ("sol", the constructor arg above) never enters this: the
-        // pool poolFor(DEV) resolves to is never empty here, so place() only ever reads that field as
-        // a fallback for an empty pool, which this test does not exercise.
-        PlacementDecision decision = composite.place(MemberRole.DEV);
-        assertEquals("sol", decision.profile(), "sanity: nothing is quarantined yet, so sol is placed");
-
-        // 2. Move the placement state IN THE WINDOW between place() and spawn() — sol's credential
-        // is now quarantined. A fresh place()/spawn(req) pair would fall through to b instead; the
-        // held decision must not be re-evaluated against this new state at all.
-        quarantine.quarantine("shared-openai");
-
-        // 3. Spawn against the HELD decision, not a fresh resolve.
-        SpawnRequest req = new SpawnRequest(null, null, null, null, null, MemberRole.DEV);
-        PeerHandle handle = composite.spawn(req, decision);
-
-        assertEquals("sol", handle.profile(),
-                "the decision from place() is honored even though sol is now quarantined");
-        // A fixture whose adapter falls back to "sol" too would let an UNSTAMPED request (one
-        // routed but never given req.withProfile("sol")) land on spawnCount("sol") == 1 by
-        // COINCIDENCE, since StubLauncher.spawn falls back to its own defaultProfile whenever
-        // req.profileName() is blank. Giving the adapter "b" as its fallback instead means only an
-        // actually-stamped request can produce this count — an unstamped one would count against
-        // "b" and this assertion would fail.
-        assertEquals(1, adapter.spawnCount("sol"),
-                "the request that reached the delegate actually carried sol as its profile "
-                        + "(the adapter's own fallback default is 'b', so this can't happen by accident)");
-        assertEquals(0, adapter.spawnCount("b"),
-                "b must never be touched — neither as the decision's profile nor as an unstamped "
-                        + "request's accidental fallback");
-    }
-
     @Test
     void aQuarantineLiftsOnTheInjectedClockAndTheProfileBecomesSpawnableAgain() {
         FakeHerdr herdr = new FakeHerdr();
@@ -1401,415 +1093,4 @@ class CompositePeerLauncherTest {
         assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("claude", null, null)));
         assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("gemini", null, null)));
     }
-
-    // ── fleetd #422: the model on/off gate — a FOURTH, independent reason to refuse a spawn ──────
-    // ── (an operator decision, never a backend-reported outage) — never merged with quarantine ────
-    // ── or cool-off above ─────────────────────────────────────────────────────────────────────────
-
-    private static final BackendOutagePolicy NO_OUTAGE = new BackendOutagePolicy(() -> 0L);
-
-    /** Criterion 1: an explicit spawn onto a profile whose model is off is refused. */
-    @Test
-    void explicitSpawnOntoAnOffModelProfileIsRefused() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        PlacementException e = assertThrows(PlacementException.class,
-                () -> composite.spawn(new SpawnRequest("local", null, null)));
-        assertTrue(e.getMessage().contains("local"), "message names the profile: " + e.getMessage());
-        assertTrue(e.getMessage().contains("deepseek-v4-flash"),
-                "message names the model: " + e.getMessage());
-        assertTrue(e.getMessage().contains("operator") && e.getMessage().contains("turned off"),
-                "wording says the OPERATOR turned it off: " + e.getMessage());
-        // Distinct from quarantine/cool-off wording (criterion 1's explicit requirement).
-        assertFalse(e.getMessage().contains("quarantined"), "must not read like quarantine: " + e.getMessage());
-        assertFalse(e.getMessage().contains("cooling off"), "must not read like cool-off: " + e.getMessage());
-        assertEquals(0, adapter.spawnCount("local"), "the off-model profile is never delegated to");
-    }
-
-    /** A profile whose model is NOT off spawns normally even while another model is off. */
-    @Test
-    void explicitSpawnOntoAnEnabledModelProfileSucceedsWhileAnotherModelIsOff() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("sonnet", null, null)));
-        assertEquals(1, adapter.spawnCount("sonnet"));
-    }
-
-    /**
-     * Criterion 8: one {@code enabled: false} entry disables EVERY profile naming that model — the
-     * live example, {@code deepseek-v4-flash} backing both {@code local} and {@code local-direct}.
-     */
-    @Test
-    void turningOffOneModelRefusesEveryProfileThatNamesIt() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "local-direct", stubWorkerModel("local-direct", "deepseek-v4-flash"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertThrows(PlacementException.class, () -> composite.spawn(new SpawnRequest("local", null, null)));
-        assertThrows(PlacementException.class,
-                () -> composite.spawn(new SpawnRequest("local-direct", null, null)),
-                "local-direct shares local's model, so it must be refused too");
-        assertEquals(0, adapter.spawnCount("local"));
-        assertEquals(0, adapter.spawnCount("local-direct"));
-    }
-
-    /** Criterion 3: an old-style entry with no {@code enabled} field never refuses a spawn. */
-    @Test
-    void anEntryWithNoEnabledFieldNeverRefusesASpawn() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = Map.of("local", stubWorkerModel("local", "deepseek-v4-flash"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        // The back-compat single-arg ModelEntry constructor — no enabled field in the shape at all.
-        FleetConfig.Models models = new FleetConfig.Models(
-                List.of(new FleetConfig.Models.ModelEntry("deepseek-v4-flash")));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("local", null, null)));
-        assertEquals(1, adapter.spawnCount("local"));
-    }
-
-    /** A model absent from {@code models.allow:} entirely (nothing to gate against) is never refused. */
-    @Test
-    void aModelNotConfiguredInTheAllowListIsNeverGated() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = Map.of("local", stubWorkerModel("local", "unlisted-model"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("local", null, null)));
-    }
-
-    /** Criterion 2: an unqualified spawn skips an off-model candidate and lands on another one. */
-    @Test
-    void placementSkipsAnOffModelProfileAndRoutesToAnotherOne() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.weighted(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        PeerHandle h = composite.spawn(new SpawnRequest(null, null, null));
-        assertEquals("sonnet", h.profile(), "local's model is off, so an unqualified spawn must land on sonnet");
-        assertEquals(0, adapter.spawnCount("local"));
-    }
-
-    /**
-     * Criterion 2's second half: when EVERY candidate's model is off, the placement exception must
-     * name that as the cause — not a generic "no candidates" message.
-     */
-    @Test
-    void automaticPlacementNamesModelOffWhenEveryCandidateIsOffModel() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "local-direct", stubWorkerModel("local-direct", "deepseek-v4-flash"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.weighted(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        PlacementException e = assertThrows(PlacementException.class,
-                () -> composite.spawn(new SpawnRequest(null, null, null)),
-                "both candidates share the off model — nothing is available");
-        assertTrue(e.getMessage().contains("model") && e.getMessage().contains("turned off"),
-                "message names model-off as the cause, not a generic no-candidates message: "
-                        + e.getMessage());
-    }
-
-    /**
-     * fleetd #422 follow-up: {@code fixed} is the DEFAULT placement policy ({@code
-     * PlacementPolicies.fromName} returns it for an absent/blank name), and it built its own inline
-     * candidate filter instead of calling {@code PlacementPolicyUtil.available()} — so it never
-     * checked {@code modelOff()}. Mirrors {@code placementSkipsAnOffModelProfileAndRoutesToAnotherOne}
-     * above with only the policy swapped, to prove the gate now fires on the path most fleets use.
-     */
-    @Test
-    void fixedPlacementSkipsAnOffModelProfileToo() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        PeerHandle h = composite.spawn(new SpawnRequest(null, null, null));
-        assertEquals("sonnet", h.profile(), "local's model is off, so an unqualified spawn must land on sonnet");
-        assertEquals(0, adapter.spawnCount("local"));
-    }
-
-    /**
-     * fleetd #425 rework, acceptance 2: same shape as {@link #fixedPlacementSkipsAnOffModelProfileToo}
-     * above, but through {@link CompositePeerLauncher#routedProfileFor} rather than an actual
-     * {@link CompositePeerLauncher#spawn} — the exact call {@code SessionManager.acquireWithWorktree}
-     * makes to pre-resolve a profile for provisioning. This is the fleetd #429 case named in the
-     * ticket: an operator turns a model off, and an unqualified worktree spawn must still route
-     * around it instead of throwing "names model, which the operator has turned off" — the throw
-     * {@link CompositePeerLauncher#enforceModelEnabled} raises only on the EXPLICIT-profile branch,
-     * which is exactly the branch the regressed round accidentally routed every worktree spawn onto.
-     */
-    @Test
-    void routedProfileForSkipsAModelOffPoolFirstProfileUnderFixedPolicy() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertEquals("sonnet", composite.routedProfileFor(MemberRole.DEV),
-                "local (the pool's first entry) names an off model, so the routed answer must be sonnet");
-        assertEquals("local", composite.defaultProfileFor(MemberRole.DEV),
-                "sanity: defaultProfileFor stays blind to model-off — that's the gap routedProfileFor closes");
-        assertEquals(0, adapter.spawnCount("local"), "routedProfileFor never spawns anything");
-        assertEquals(0, adapter.spawnCount("sonnet"), "routedProfileFor never spawns anything");
-    }
-
-    /**
-     * Criterion 4: turning a model off/on is HOT — no restart — proven through a REAL
-     * {@code ConfigRef.reload()}, not a hand-rolled supplier swap. Also proves {@code models} is
-     * correctly reclassified: the reload's {@link ConfigRef.Outcome#applied()} is {@code true} and
-     * {@code "models"} never appears in {@link ConfigRef.Outcome#deferred()}.
-     */
-    @Test
-    void modelOnOffIsHotReloadedThroughARealConfigRef(@TempDir Path dir) throws Exception {
-        Path yaml = dir.resolve("fleetd.yaml");
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                """);
-        FleetConfig initial = FleetConfig.load(yaml);
-        ConfigRef configRef = new ConfigRef(yaml, initial);
-
-        FakeHerdr herdr = new FakeHerdr();
-        StubLauncher adapter = new StubLauncher("claude", herdr,
-                Map.of("local", stubWorker("local")), "local", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "local", configRef, _ -> 0, BackendQuarantine.none(), NO_OUTAGE);
-
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("local", null, null)),
-                "the model starts enabled");
-        assertEquals(1, adapter.spawnCount("local"));
-
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: false
-                """);
-        ConfigRef.Outcome outcome = configRef.reload();
-        assertTrue(outcome.applied(), "a models.allow on/off edit must apply live, never be refused");
-        assertFalse(outcome.deferred().contains("models"),
-                "models is hot-excluded now — it must never be reported as a deferred key");
-
-        PlacementException e = assertThrows(PlacementException.class,
-                () -> composite.spawn(new SpawnRequest("local", null, null)),
-                "the very next spawn must see the reload, with no restart");
-        assertTrue(e.getMessage().contains("deepseek-v4-flash"));
-        assertEquals(1, adapter.spawnCount("local"), "still just the one successful spawn from before");
-
-        // And back on, still hot, still no restart.
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: true
-                """);
-        ConfigRef.Outcome reEnabled = configRef.reload();
-        assertTrue(reEnabled.applied());
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("local", null, null)));
-        assertEquals(2, adapter.spawnCount("local"));
-    }
-
-    /**
-     * fleetd #422 follow-up, acceptance criterion 2: {@link CompositePeerLauncher#modelGateState()}
-     * is LIVE — no restart — proven through a REAL {@link ConfigRef#reload()}, exactly like {@link
-     * #modelOnOffIsHotReloadedThroughARealConfigRef} above proves for the on/off gate itself. This
-     * single reload sequence walks through all three states the ticket asks for: no {@code models:}
-     * block, a block armed with nothing off, and a block with one model off — so a reload that flips
-     * between any of the three is proven live, not just the on/off edit within an already-armed block.
-     */
-    @Test
-    void modelGateStateIsHotReloadedThroughARealConfigRef(@TempDir Path dir) throws Exception {
-        Path yaml = dir.resolve("fleetd.yaml");
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                """);
-        FleetConfig initial = FleetConfig.load(yaml);
-        ConfigRef configRef = new ConfigRef(yaml, initial);
-
-        FakeHerdr herdr = new FakeHerdr();
-        StubLauncher adapter = new StubLauncher("claude", herdr,
-                Map.of("local", stubWorker("local")), "local", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "local", configRef, _ -> 0, BackendQuarantine.none(), NO_OUTAGE);
-
-        PeerLauncher.ModelGateState notConfigured = composite.modelGateState();
-        assertFalse(notConfigured.configured(), "no models: block in the config at all");
-        assertEquals(Set.of(), notConfigured.off());
-
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: false
-                """);
-        assertTrue(configRef.reload().applied(), "adding a models: block must apply live, no restart");
-        PeerLauncher.ModelGateState armedWithOneOff = composite.modelGateState();
-        assertTrue(armedWithOneOff.configured(), "a models: block now exists — the gate is armed");
-        assertEquals(Set.of("deepseek-v4-flash"), armedWithOneOff.off());
-
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                models:
-                  allow:
-                    - model: deepseek-v4-flash
-                      enabled: true
-                """);
-        assertTrue(configRef.reload().applied(), "flipping the entry back on must apply live too");
-        PeerLauncher.ModelGateState armedWithZeroOff = composite.modelGateState();
-        assertTrue(armedWithZeroOff.configured(),
-                "the block is still present — armed and reporting zero, not the same as no block at all");
-        assertEquals(Set.of(), armedWithZeroOff.off());
-    }
-
-    /**
-     * fleetd #422 follow-up, acceptance criterion 3: the invariant is that an absent {@code
-     * models:} block stays permitted and must never be fatal. Proved, not assumed — a config
-     * without one loads, validates, reports the gate as not configured, AND still spawns normally
-     * (no {@link PlacementException} from a gate that has nothing to check against), using the same
-     * production-shaped {@code Supplier<FleetConfig>} wiring {@code Fleetd.main} actually uses.
-     */
-    @Test
-    void noModelsBlockConfigStillLoadsAndSpawnsNormally(@TempDir Path dir) throws Exception {
-        Path yaml = dir.resolve("fleetd.yaml");
-        Files.writeString(yaml, """
-                bind:
-                  port: 8080
-                profiles:
-                  local:
-                    baseUrl: http://local.gw:8000
-                    model: deepseek-v4-flash
-                """);
-        FleetConfig cfg = FleetConfig.load(yaml);
-        assertDoesNotThrow(cfg::validateAll, "a config with no models: block must load and validate cleanly");
-        ConfigRef configRef = new ConfigRef(yaml, cfg);
-
-        FakeHerdr herdr = new FakeHerdr();
-        StubLauncher adapter = new StubLauncher("claude", herdr,
-                Map.of("local", stubWorker("local")), "local", Set.of());
-        CompositePeerLauncher composite = new CompositePeerLauncher(
-                List.of(adapter), "local", configRef, _ -> 0, BackendQuarantine.none(), NO_OUTAGE);
-
-        assertFalse(composite.modelGateState().configured());
-        assertDoesNotThrow(() -> composite.spawn(new SpawnRequest("local", null, null)),
-                "no models: block means nothing to gate against — the spawn must go through");
-        assertEquals(1, adapter.spawnCount("local"));
-    }
-
-    /** {@code fleet_profiles}/{@code GET /profiles} must read the exact same live source the gate reads. */
-    @Test
-    void disabledModelsReportsWhatTheGateActuallyEnforces() {
-        FakeHerdr herdr = new FakeHerdr();
-        Map<String, FleetConfig.Profile> profiles = ordered(
-                "local", stubWorkerModel("local", "deepseek-v4-flash"),
-                "sonnet", stubWorkerModel("sonnet", "claude-sonnet-5"));
-        StubLauncher adapter = new StubLauncher("claude", herdr, profiles, "local", Set.of());
-        FleetConfig.Models models = new FleetConfig.Models(List.of(
-                new FleetConfig.Models.ModelEntry("deepseek-v4-flash", false),
-                new FleetConfig.Models.ModelEntry("claude-sonnet-5", true)));
-        CompositePeerLauncher composite = new CompositePeerLauncher(List.of(adapter), "local", profiles,
-                PlacementPolicies.fixed(), _ -> 0, null, BackendQuarantine.none(), NO_OUTAGE,
-                () -> models);
-
-        assertEquals(Set.of("deepseek-v4-flash"), composite.disabledModels());
-    }
-
-    /** A caller with no {@code models:} block (the map-based constructors) reports nothing off. */
-    @Test
-    void disabledModelsIsEmptyWithNoModelsConfigured() {
-        FakeHerdr herdr = new FakeHerdr();
-        PeerLauncher composite = composite(herdr);
-        assertEquals(Set.of(), composite.disabledModels());
-    }
 }

fleetd/src/test/java/dev/ltms/fleet/member/EnvAllowListScrubTest.java

@@ -8,7 +8,6 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -18,7 +17,6 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -47,15 +45,6 @@ class EnvAllowListScrubTest {
     /** Env var names appearing in command output; anything else (prompts, wrapped lines) is noise. */
     private static final Pattern ENV_NAME = Pattern.compile("^([A-Za-z_][A-Za-z0-9_]*)$");
 
-    /**
-     * fleetd #388: the sentinel name the generated {@code .zshenv} guard uses, kept here as a
-     * literal rather than referencing {@link EnvAllowListScrub#SCRUB_SENTINEL} — the two tests that
-     * use it must still compile and run against the pre-fix production class (which has no such
-     * constant), so the revert-and-prove-it-fails step exercises a real assertion instead of a
-     * compilation error.
-     */
-    private static final String SCRUB_SENTINEL_NAME = "_CB633_SCRUBBED";
-
     /**
      * The equality test. Expected survivors = baseline exports ∩ allowed — i.e. every survivor is
      * allowed AND every allowed name that existed survives. The operator's own secret-store exports
@@ -119,230 +108,6 @@ class EnvAllowListScrubTest {
                 "allowed N of M with N <= M — the denominator is always reported");
     }
 
-    /**
-     * fleetd #394: the actual defect. Plain {@code export "$n="} is FATAL for a zsh read-only or
-     * special parameter (e.g. {@code UID}) and aborts the whole sourced file — every name still to
-     * come is never blanked, and the {@code scrub-report.txt} below is never written at all,
-     * silently ({@code 2>/dev/null} swallows the error). This plants an unblankable, exported,
-     * read-only variable in the MIDDLE of the names the scrub attempts to blank, with two more
-     * names after it, and asserts that both of those later names are STILL blanked and the report
-     * is STILL written with the failure counted — a test that only checked names BEFORE the failure
-     * point would pass today and prove nothing.
-     *
-     * <p>The planted name is a made-up one ({@code FLEETD_TEST_UNBLANKABLE}), not {@code UID} or
-     * any other name a skip-list might already know about — invariant 1 is that the loop survives
-     * ANY unblankable name, not a known one, so the test must not lean on one either.
-     *
-     * <p>Exercises the real artefact: {@link EnvAllowListScrub#scrubScript} is run verbatim under a
-     * real {@code /bin/zsh}, not just asserted on as a Java string. The four planted names are
-     * exported one at a time via {@code typeset -x}/{@code typeset -rx} immediately before the
-     * script runs, in a fixed order — zsh's {@code export}/{@code typeset -x} appends to the
-     * process's environment table in call order (verified empirically: a freshly-exported name
-     * always sorts after every inherited one and after every earlier freshly-exported name in
-     * {@code command env}'s own output), which is what makes the "middle" position deterministic
-     * here, unlike relying on the OS's own inherited-environment order.
-     */
-    @Test
-    void unblankableNameInTheMiddleDoesNotAbortNamesAfterIt(@TempDir Path tmp) throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-
-        // Only ZDOTDIR is allowed — it must survive the scrub itself, since the report is written
-        // to "$ZDOTDIR/..." AFTER the blanking loop runs; if ZDOTDIR were blanked as a side effect,
-        // the report write would silently go to the wrong place instead of testing anything.
-        String script = EnvAllowListScrub.scrubScript(Set.of("ZDOTDIR"));
-        String setup = """
-                typeset -x FLEETD_TEST_BEFORE=1
-                typeset -rx FLEETD_TEST_UNBLANKABLE=1
-                typeset -x FLEETD_TEST_AFTER_A=1
-                typeset -x FLEETD_TEST_AFTER_B=1
-                """;
-
-        ProcessBuilder pb = new ProcessBuilder("/bin/zsh");
-        pb.environment().clear();
-        pb.environment().put("PATH", "/usr/bin:/bin");
-        pb.environment().put("ZDOTDIR", tmp.toAbsolutePath().toString());
-        pb.redirectError(ProcessBuilder.Redirect.DISCARD);
-        Process zsh = pb.start();
-        zsh.getOutputStream().write((setup + script).getBytes(StandardCharsets.UTF_8));
-        zsh.getOutputStream().flush();
-        zsh.getOutputStream().close();
-        assertTrue(zsh.waitFor(60, java.util.concurrent.TimeUnit.SECONDS),
-                "the scrub script did not exit within 60s");
-        assertEquals(0, zsh.exitValue(),
-                "the scrub script itself must never abort — an unblankable name must not kill the "
-                        + "sourced file");
-
-        EnvAllowListScrub.ScrubReport report = EnvAllowListScrub.readReport(tmp);
-        assertNotNull(report, "the report must still be written even though one name could not be "
-                + "blanked — a report that silently never appears is the #394 bug");
-        assertTrue(report.blanked().contains("FLEETD_TEST_BEFORE"),
-                "sanity: the name before the unblankable one must be blanked");
-        assertTrue(report.blanked().contains("FLEETD_TEST_AFTER_A"),
-                "the FIRST name AFTER the unblankable one must still be blanked — before the fix, "
-                        + "the whole loop aborted at the unblankable name and every later name was "
-                        + "silently left untouched");
-        assertTrue(report.blanked().contains("FLEETD_TEST_AFTER_B"),
-                "the SECOND name after the unblankable one must also still be blanked");
-        assertTrue(report.unblankable().contains("FLEETD_TEST_UNBLANKABLE"),
-                "the unblankable name is reported by name, not silently dropped");
-        // fleetd #400 note: zsh itself auto-exports SHLVL on every shell start (measured: it appears
-        // in `command env` even from a fully cleared parent), and a bare assignment to it is coerced
-        // rather than failing — exactly the shape #400 fixes. Before that fix, eval's exit status
-        // alone silently misclassified SHLVL as blanked, so this test's old "exactly one" assertion
-        // passed by accident: it never actually proved SHLVL was absent from the candidates, only
-        // that the old bug hid it. Now that classification reads the value back, SHLVL and
-        // FLEETD_TEST_UNBLANKABLE both correctly land in unblankable() — real, unplanted evidence
-        // the #400 fix works, not just the synthetic case in the dedicated #400 test above.
-        assertTrue(report.unblankable().contains("SHLVL"),
-                "fleetd #400: zsh's own auto-exported SHLVL must also be reported unblankable, not "
-                        + "silently miscounted as blanked");
-        assertEquals(report.unblankable().size(), report.failed(),
-                "the failed count must equal the number of names actually reported unblankable");
-    }
-
-    /**
-     * fleetd #400: {@code eval}'s exit status is not proof that a name was actually blanked. zsh
-     * coerces a bare {@code NAME=} assignment on an integer special parameter to a number instead of
-     * failing, so {@code eval} reports success while the value stays non-empty — a status-based
-     * classification calls that "blanked" when it was not. This drives all three shapes a name can
-     * take through the real {@code scrubScript} in ONE run: a normal, genuinely blankable name; a
-     * fatal one ({@code LINENO} — deliberately not {@code UID}, so this test does not depend on the
-     * harness's uid); and the silent-no-op one the ticket is about ({@code SECONDS}, rc 0 but
-     * unchanged). Under the pre-#400 exit-status check, {@code SECONDS} would land in
-     * {@code blanked()} — that is the exact false receipt this fix removes.
-     *
-     * <p>Criterion 3: a cleared {@code ProcessBuilder} parent does not, by itself, give the child
-     * zsh any of these names — {@code SECONDS}/{@code LINENO} are zsh's own built-in parameters and
-     * only become CANDIDATES the enumeration loop can see (i.e. show up in {@code command env}) when
-     * they arrive via the process's own environment table, not merely by existing as zsh parameters
-     * inside the shell. So each is put into {@code pb.environment()} explicitly, after
-     * {@code clear()} — confirmed empirically first (a throwaway probe piping
-     * {@code env -i PATH=... SECONDS=999 LINENO=999 FLEETD_TEST_NORMAL=1 zsh -c 'command env | cut
-     * -d= -f1'}) that all three names really appear in {@code command env}'s output under exactly
-     * this construction, not relying on whatever the test-runner's own ambient environment happens
-     * to contain.
-     */
-    @Test
-    void classifiesByObservedValueNotExitStatusAcrossAllThreeShapes(@TempDir Path tmp) throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-
-        String script = EnvAllowListScrub.scrubScript(Set.of("ZDOTDIR"));
-
-        ProcessBuilder pb = new ProcessBuilder("/bin/zsh");
-        pb.environment().clear();
-        pb.environment().put("PATH", "/usr/bin:/bin");
-        pb.environment().put("ZDOTDIR", tmp.toAbsolutePath().toString());
-        // Explicitly placed in the child's environment table — see the javadoc above on why a
-        // cleared parent alone does not put these on the enumeration loop's candidate list.
-        pb.environment().put("SECONDS", "999");   // rc 0, value coerced/unchanged — the #400 bug
-        pb.environment().put("LINENO", "999");    // fatal on assignment, eval rc != 0, contained
-        pb.environment().put("FLEETD_TEST_NORMAL", "1"); // genuinely blankable, the control case
-        pb.redirectError(ProcessBuilder.Redirect.DISCARD);
-        Process zsh = pb.start();
-        zsh.getOutputStream().write(script.getBytes(StandardCharsets.UTF_8));
-        zsh.getOutputStream().flush();
-        zsh.getOutputStream().close();
-        assertTrue(zsh.waitFor(60, java.util.concurrent.TimeUnit.SECONDS),
-                "the scrub script did not exit within 60s");
-        assertEquals(0, zsh.exitValue(),
-                "the scrub script must still reach its end with both a fatal name and a silent "
-                        + "no-op name among the candidates");
-
-        EnvAllowListScrub.ScrubReport report = EnvAllowListScrub.readReport(tmp);
-        assertNotNull(report, "the report must still be written");
-        assertTrue(report.blanked().contains("FLEETD_TEST_NORMAL"),
-                "the control case: an ordinary name is genuinely blankable and must be reported so");
-        assertTrue(report.unblankable().contains("LINENO"),
-                "a name fatal to assign to must be reported unblankable — sanity check that "
-                        + "containment still works under the new classification");
-        assertTrue(report.unblankable().contains("SECONDS"),
-                "the #400 defect: eval returns rc 0 for SECONDS (zsh coerces the assignment instead "
-                        + "of failing) but the value is left non-empty — classifying on the observed "
-                        + "value catches this; classifying on eval's exit status would have called "
-                        + "this \"blanked\" and produced a false receipt");
-        assertFalse(report.blanked().contains("SECONDS"),
-                "SECONDS must never appear as blanked — it was never actually emptied");
-    }
-
-    /**
-     * fleetd #394 follow-up: the blanking loop's {@code eval "export ${n}="} splices {@code n} into
-     * a string that zsh then interprets as shell syntax. That is only safe because every name
-     * reaching {@code _cb633_blank} already passed an identifier check in the ENUMERATION loop
-     * (20 lines away, in a different loop) — so the fix re-asserts the identical check immediately
-     * before the {@code eval} call, rather than trusting that distant guard to keep holding.
-     *
-     * <p>This test plants a value with an embedded newline, exploiting the exact "junk from
-     * multi-line values" gap the enumeration loop's own comment already documents: {@code command
-     * env}'s text output is read line-by-line, so a value's second line becomes a spurious extra
-     * "name" that was never a real exported variable. The fragment used here ({@code
-     * junk.fragment}) is merely non-conforming (it contains a dot) — never command-shaped; this
-     * test must never demonstrate command execution and plants no command-shaped payload.
-     *
-     * <p>Exercises the real artefact end-to-end: {@link EnvAllowListScrub#scrubScript} runs
-     * verbatim under a real {@code /bin/zsh}, exactly as {@code generate()} would produce it — this
-     * is not a synthetic call into just the blanking loop.
-     */
-    @Test
-    void nonIdentifierJunkFromAMultilineValueIsSkippedNotBlankedOrUnblankable(@TempDir Path tmp)
-            throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-
-        String script = EnvAllowListScrub.scrubScript(Set.of("ZDOTDIR"));
-
-        ProcessBuilder pb = new ProcessBuilder("/bin/zsh");
-        pb.environment().clear();
-        pb.environment().put("PATH", "/usr/bin:/bin");
-        pb.environment().put("ZDOTDIR", tmp.toAbsolutePath().toString());
-        // Embedded newline: `command env`'s own text output splits this into two lines, and the
-        // second ("junk.fragment") has no "=" at all, so `cut -d= -f1` returns it unchanged as a
-        // spurious candidate "name" — it was never an actual exported variable by that name.
-        pb.environment().put("FLEETD_TEST_MULTILINE", "keep\njunk.fragment");
-        pb.redirectError(ProcessBuilder.Redirect.DISCARD);
-        Process zsh = pb.start();
-        zsh.getOutputStream().write(script.getBytes(StandardCharsets.UTF_8));
-        zsh.getOutputStream().flush();
-        zsh.getOutputStream().close();
-        assertTrue(zsh.waitFor(60, java.util.concurrent.TimeUnit.SECONDS),
-                "the scrub script did not exit within 60s");
-        assertEquals(0, zsh.exitValue(), "the scrub script must reach its end");
-
-        EnvAllowListScrub.ScrubReport report = EnvAllowListScrub.readReport(tmp);
-        assertNotNull(report, "the report must still be written");
-        assertTrue(report.blanked().contains("FLEETD_TEST_MULTILINE"),
-                "sanity: the real, identifier-shaped variable must still be blanked normally");
-        assertFalse(report.blanked().contains("junk.fragment"),
-                "a non-identifier fragment is not a real variable and must never be blanked");
-        assertFalse(report.unblankable().contains("junk.fragment"),
-                "a non-identifier fragment must never even become a candidate the blanking loop "
-                        + "attempts — it must be filtered before either guard has to catch it, so "
-                        + "it is neither blanked nor counted as a failed attempt");
-    }
-
-    /** A group-shared ZDOTDIR still lets the member truncate and write its pre-created receipt. */
-    @Test
-    void groupSharedScrubWritesAndReadsItsReport(@TempDir Path tmp) throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-        Set<String> allowed = MemberEnvAllowList.derive(List.of());
-        Path zdotdir = EnvAllowListScrub.generate(tmp, allowed, currentUserGroup());
-
-        Map<String, String> cleanParent = Map.of(
-                "HOME", System.getProperty("user.home"),
-                "PATH", "/usr/bin:/bin",
-                "SHELL", "/bin/zsh");
-        exportedNamesFromCleanParent(cleanParent, zdotdir);
-
-        EnvAllowListScrub.ScrubReport report = EnvAllowListScrub.readReport(zdotdir);
-        assertNotNull(report, "a group-shared completed login shell must leave a report behind");
-        assertTrue(report.allowed() >= 0 && report.total() >= report.allowed(),
-                "allowed N of M with N <= M — the denominator is always reported");
-        assertEquals("rw-rw----", java.nio.file.attribute.PosixFilePermissions.toString(
-                        Files.getPosixFilePermissions(zdotdir.resolve(EnvAllowListScrub.REPORT_FILE))),
-                "the pre-created receipt must be group-writable");
-        assertEquals("rwxr-x---", java.nio.file.attribute.PosixFilePermissions.toString(
-                        Files.getPosixFilePermissions(zdotdir)),
-                "group sharing must not make the ZDOTDIR directory group-writable");
-    }
-
     /** Report parsing is lenient: absent file → null (no measurement), not an exception. */
     @Test
     void readReportReturnsNullForADirectoryWithoutOne(@TempDir Path dir) {
@@ -459,140 +224,6 @@ class EnvAllowListScrubTest {
                         + "shell. A difference here means the scrub is dead on Linux.");
     }
 
-    /**
-     * fleetd #388: the actual gap. zsh reads {@code .zshenv} always, {@code .zprofile}/
-     * {@code .zlogin} only for a LOGIN shell, and {@code .zshrc} only for an INTERACTIVE one — so a
-     * shell that is NEITHER (a bare {@code /bin/zsh} reading a script off a non-tty stdin, no
-     * {@code -l}, no {@code -i}) reads only {@code .zshenv} and stops. Before this fix, that shell
-     * never reached {@code scrub.zsh} at all: the decoy secret below would survive untouched. This
-     * test injects that decoy directly into the process environment (not via a sourced dotfile,
-     * since the whole point of the gap is that {@code .zshenv} is normally close to empty) so the
-     * test does not depend on any real {@code ~/.zshrc} content existing on the host.
-     */
-    @Test
-    void scrubRunsInAShellThatIsNeitherLoginNorInteractive(@TempDir Path tmp) throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-        Set<String> allowed = MemberEnvAllowList.derive(List.of());
-        Path zdotdir = EnvAllowListScrub.generate(tmp, allowed);
-
-        Map<String, String> cleanParent = new HashMap<>(Map.of(
-                "HOME", System.getProperty("user.home"),
-                "PATH", "/usr/bin:/bin",
-                "SHELL", "/bin/zsh",
-                "USER", System.getProperty("user.name", "nobody"),
-                "TMPDIR", tmp.toString()));
-        cleanParent.put("FLEETD_TEST_DECOY_SECRET", "x"); // not on any allow-list; must be blanked
-
-        List<String> neither = List.of(); // no -l, no -i; stdin is a pipe (never a tty) either way
-        Set<String> baseline = exportedNamesFromCleanParent(cleanParent, null, neither);
-        Set<String> scrubbed = exportedNamesFromCleanParent(cleanParent, zdotdir, neither);
-
-        Set<String> expected = new TreeSet<>();
-        for (String name : baseline) {
-            if (MemberEnvAllowList.keeps(allowed, name)) {
-                expected.add(name);
-            }
-        }
-        assertTrue(baseline.contains("FLEETD_TEST_DECOY_SECRET"),
-                "sanity: the decoy must actually reach the un-scrubbed baseline, or this test proves "
-                        + "nothing");
-        expected.add("ZDOTDIR"); // the harness set it and it is infrastructure, so it must survive
-        expected.add(SCRUB_SENTINEL_NAME); // set by the new .zshenv guard once scrubbed
-        assertEquals(expected, scrubbed,
-                "a pane shell that is NEITHER login nor interactive must still be scrubbed — its "
-                        + "surviving exported names must EQUAL baseline ∩ allow-list, plus the "
-                        + "sentinel the guard sets once it has run. FLEETD_TEST_DECOY_SECRET surviving "
-                        + "here means the gap is still open.");
-    }
-
-    /**
-     * fleetd #388 invariants 3 and 4, which a name-set equality cannot show: a member's own tooling
-     * forks plain, non-login, non-interactive zsh processes for a single command (the same shape as
-     * the pane shell itself), and such a child must (a) keep whatever its parent deliberately set
-     * for it, never (b) re-run the scrub and blank it, and never (c) overwrite the pane's own
-     * {@code scrub-report.txt} with a description of itself instead of the pane. All three can only
-     * be shown by actually running a child process from within the scrubbed pane shell.
-     *
-     * <p>The pane and the child both report presence via {@code ${NAME:+present}} — empty when a
-     * name is unset OR blanked (exported empty), {@code present} when it is set and non-empty. No
-     * value is ever printed, only these two shapes and the literal word {@code set}/{@code unset}
-     * for the sentinel.
-     */
-    @Test
-    void neitherShellChildKeepsParentVariablesAndReceiptStillDescribesThePane(@TempDir Path tmp) throws Exception {
-        assumeTrue(Files.isExecutable(ZSH), "/bin/zsh not present — nothing to prove here");
-        Set<String> allowed = MemberEnvAllowList.derive(List.of());
-        Path zdotdir = EnvAllowListScrub.generate(tmp, allowed);
-
-        Map<String, String> paneEnv = new HashMap<>(Map.of(
-                "HOME", System.getProperty("user.home"),
-                "PATH", "/usr/bin:/bin",
-                "SHELL", "/bin/zsh",
-                "USER", System.getProperty("user.name", "nobody"),
-                "TMPDIR", tmp.toString()));
-        paneEnv.put("FLEETD_TEST_DECOY_SECRET", "x"); // not allow-listed; the pane must blank it
-        paneEnv.put("ZDOTDIR", zdotdir.toAbsolutePath().toString());
-
-        // The pane's own script reports what IT sees, then forks a plain non-login, non-interactive
-        // child — the shape a member's own tooling uses — carrying a variable the "parent" (this
-        // pane) deliberately set for it, the way git sets GIT_DIR for a hook.
-        String outerScript = """
-                print -r -- "PANE_SENTINEL=${%1$s:+set}"
-                print -r -- "PANE_DECOY=${FLEETD_TEST_DECOY_SECRET:+present}"
-                FLEETD_TEST_TOOL_VAR=keep /bin/zsh <<'CHILD'
-                print -r -- "CHILD_LOGIN=$([[ -o login ]] && echo yes || echo no)"
-                print -r -- "CHILD_INTERACTIVE=$([[ -o interactive ]] && echo yes || echo no)"
-                print -r -- "CHILD_TOOL_VAR=${FLEETD_TEST_TOOL_VAR:+present}"
-                print -r -- "CHILD_DECOY=${FLEETD_TEST_DECOY_SECRET:+present}"
-                print -r -- "CHILD_SENTINEL=${%1$s:+set}"
-                CHILD
-                exit
-                """.formatted(SCRUB_SENTINEL_NAME);
-
-        ProcessBuilder pb = new ProcessBuilder("/bin/zsh"); // no -l, no -i: the pane's own shape
-        pb.environment().clear();
-        pb.environment().putAll(paneEnv);
-        pb.redirectError(ProcessBuilder.Redirect.DISCARD);
-        Process zsh = pb.start();
-        zsh.getOutputStream().write(outerScript.getBytes(StandardCharsets.UTF_8));
-        zsh.getOutputStream().flush();
-        zsh.getOutputStream().close();
-        String stdout = new String(zsh.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
-        assertTrue(zsh.waitFor(60, java.util.concurrent.TimeUnit.SECONDS),
-                "the pane+child probe did not exit within 60s");
-        assertTrue(zsh.exitValue() == 0, "probe zsh exited non-zero: " + stdout);
-
-        Map<String, String> reported = new HashMap<>();
-        for (String line : stdout.split("\n")) {
-            int eq = line.indexOf('=');
-            if (eq > 0) {
-                reported.put(line.substring(0, eq).trim(), line.substring(eq + 1).trim());
-            }
-        }
-
-        assertEquals("set", reported.get("PANE_SENTINEL"),
-                "the pane itself is neither login nor interactive, so the .zshenv guard must have "
-                        + "run the scrub and exported the sentinel");
-        assertEquals("", reported.get("PANE_DECOY"),
-                "the pane must blank a non-allow-listed name — invariant 1");
-        assertEquals("no", reported.get("CHILD_LOGIN"), "sanity: the child must also be non-login");
-        assertEquals("no", reported.get("CHILD_INTERACTIVE"), "sanity: the child must also be non-interactive");
-        assertEquals("present", reported.get("CHILD_TOOL_VAR"),
-                "invariant 3: a variable the pane deliberately set for its child must survive — a "
-                        + "child that re-ran the scrub would have blanked it");
-        assertEquals("", reported.get("CHILD_DECOY"),
-                "a name already blanked by the pane must stay blanked in the child, never resurrected");
-        assertEquals("set", reported.get("CHILD_SENTINEL"),
-                "the child must inherit the sentinel from the pane's environment, or it would re-scrub");
-
-        EnvAllowListScrub.ScrubReport report = EnvAllowListScrub.readReport(zdotdir);
-        assertNotNull(report, "the pane's own scrub pass must leave a report behind");
-        assertTrue(report.blanked().stream().noneMatch(n -> n.startsWith("FLEETD_TEST_TOOL_VAR")),
-                "invariant 4: the receipt must still describe the PANE, not the child — a child that "
-                        + "re-ran the scrub would have rewritten this file to list its own "
-                        + "FLEETD_TEST_TOOL_VAR as blanked");
-    }
-
     /**
      * Run {@code /bin/zsh -l -i} from a clean parent and return the NAMES it has exported by prompt
      * time. With {@code zdotdir} non-null, {@code ZDOTDIR} points at a generated scrub directory, so

fleetd/src/test/java/dev/ltms/fleet/member/HerdrPeerLauncherAllowListWiringTest.java

@@ -23,7 +23,6 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
@@ -371,161 +370,6 @@ class HerdrPeerLauncherAllowListWiringTest {
                 "expected the pre-existing 'scrub blanks them' INFO unchanged, got: " + messages);
     }
 
-    /**
-     * fleetd #341: {@code unprotectedGapLogged} guarded TWO WARN branches that name DIFFERENT env
-     * var names — the allow-list branch ({@code keptByDerivedList}, below) and the deny-by-default
-     * / non-zsh-fallback branch ({@link HerdrPeerLauncher#warnGapUnprotected}). {@code
-     * memberCredentials} is a live, re-read-per-spawn supplier, so the policy can change between
-     * two spawns on the same launcher instance — a config reload needs no restart. Spawn 1 runs
-     * under {@code deny-by-default} with a gap of {@code SPAWN_ONE_UNCOVERED_TOKEN}, which trips
-     * the (before this fix) SHARED one-shot flag. The policy is then reloaded to {@code
-     * allow-list}; spawn 2's gap is {@code FLEETD_WORKER_TOKEN} instead — the test profile's own
-     * {@code tokenEnv}, which the derived allow-list keeps even though it is on neither {@code
-     * known:} nor {@code allow:}, so it is genuinely unprotected and deserves its own WARN. Before
-     * this fix that WARN never fires, because the shared flag was already {@code true} — the
-     * operator is never told {@code FLEETD_WORKER_TOKEN} reaches every member pane unblocked. Real
-     * path: two real {@link HerdrPeerLauncher#spawn} calls on ONE launcher instance, with mutable
-     * {@code memberCredentials}/host-env suppliers standing in for a live config reload between
-     * spawns.
-     */
-    @Test
-    void aDifferentUnprotectedGapOnALaterSpawnIsNotSuppressedByAnEarlierSpawnsWarn() {
-        FakeHerdr herdr = new FakeHerdr();
-        AtomicReference<FleetConfig.MemberCredentials> credsState = new AtomicReference<>(
-                new FleetConfig.MemberCredentials(null, List.of(), List.of(), null)); // deny-by-default
-        AtomicReference<Set<String>> hostEnvState =
-                new AtomicReference<>(Set.of("SPAWN_ONE_UNCOVERED_TOKEN"));
-        WiringLauncher launcher = new WiringLauncher(herdr, credsState::get, "/bin/zsh", hostEnvState::get);
-
-        Logger logger = (Logger) LoggerFactory.getLogger(HerdrPeerLauncher.class);
-        Level original = logger.getLevel();
-        logger.setLevel(Level.WARN);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            // Spawn 1: deny-by-default, gap = {SPAWN_ONE_UNCOVERED_TOKEN} — the effectiveAllowed ==
-            // null branch, via warnGapUnprotected.
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-
-            // Live policy reload to allow-list, with a DIFFERENT gap name.
-            credsState.set(new FleetConfig.MemberCredentials(
-                    FleetConfig.MemberCredentials.POLICY_ALLOW_LIST, List.of(), List.of(), null));
-            hostEnvState.set(Set.of("FLEETD_WORKER_TOKEN"));
-            // Spawn 2: allow-list, gap = {FLEETD_WORKER_TOKEN} — kept by the derived allow-list
-            // (the profile's own tokenEnv), so it is the effectiveAllowed != null / keptByDerivedList
-            // branch, at the SAME log line HerdrPeerLauncher:1819 guards with the shared flag.
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-        } finally {
-            logger.detachAppender(appender);
-            logger.setLevel(original);
-        }
-
-        List<String> messages = appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
-        assertTrue(messages.stream().anyMatch(
-                        m -> m.contains("UNBLOCKED") && m.contains("SPAWN_ONE_UNCOVERED_TOKEN")),
-                "spawn 1's deny-by-default gap must still warn — got: " + messages);
-        assertTrue(messages.stream().anyMatch(
-                        m -> m.contains("UNBLOCKED") && m.contains("FLEETD_WORKER_TOKEN")),
-                "spawn 2's gap names a DIFFERENT env var than spawn 1 (FLEETD_WORKER_TOKEN, not "
-                        + "SPAWN_ONE_UNCOVERED_TOKEN) — it must still be warned about even though a "
-                        + "flag already fired once for spawn 1's unrelated name. Before fleetd #341's "
-                        + "fix this WARN never fires because unprotectedGapLogged was already true. "
-                        + "Got: " + messages);
-    }
-
-    /**
-     * fleetd #341 follow-up: the OTHER half of the guard's contract. The set exists to report every
-     * distinct name, but it must still report each one only ONCE — the noise control is the reason
-     * a guard is here at all, and the ticket named it as invariant 1. Two spawns, same policy, same
-     * gap name: exactly one WARN mentioning it.
-     *
-     * <p>Measured before this test existed: replacing {@code .filter(unprotectedGapNamesWarned::add)}
-     * with a filter that adds and always returns {@code true} — so every name is logged on every
-     * spawn — left all 1358 tests green. The fix was correct and nothing held it there. That is the
-     * "a test on the seam does not prove the caller" shape: the {@code Set} behaves, and nothing
-     * proved this class used it as a guard rather than as a record.
-     */
-    @Test
-    void theSameUnprotectedNameIsWarnedAboutOnlyOnceAcrossSpawns() {
-        FakeHerdr herdr = new FakeHerdr();
-        AtomicReference<FleetConfig.MemberCredentials> credsState = new AtomicReference<>(
-                new FleetConfig.MemberCredentials(null, List.of(), List.of(), null)); // deny-by-default
-        AtomicReference<Set<String>> hostEnvState =
-                new AtomicReference<>(Set.of("REPEATED_UNCOVERED_TOKEN"));
-        WiringLauncher launcher = new WiringLauncher(herdr, credsState::get, "/bin/zsh", hostEnvState::get);
-
-        Logger logger = (Logger) LoggerFactory.getLogger(HerdrPeerLauncher.class);
-        Level original = logger.getLevel();
-        logger.setLevel(Level.WARN);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-            // Same policy, same gap, second spawn. Nothing new to tell the operator.
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-        } finally {
-            logger.detachAppender(appender);
-            logger.setLevel(original);
-        }
-
-        List<String> messages = appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
-        long mentioning = messages.stream()
-                .filter(m -> m.contains("REPEATED_UNCOVERED_TOKEN"))
-                .count();
-        assertEquals(1, mentioning,
-                "one unchanged unprotected name across two spawns must produce exactly one WARN — "
-                        + "the set is a guard, not just a record. Got: " + messages);
-    }
-
-    /**
-     * fleetd #341 follow-up: the reverse policy order. The original defect was found going
-     * deny-by-default then allow-list, and a guard that is fixed in one direction is not
-     * necessarily fixed in the other — "ask which states still OPEN the gate". Here spawn 1 runs
-     * under {@code allow-list} (the {@code keptByDerivedList} branch) and spawn 2 under
-     * {@code deny-by-default} ({@link HerdrPeerLauncher#warnGapUnprotected}), with a different name
-     * each time. Both must be reported.
-     */
-    @Test
-    void anAllowListWarnDoesNotSuppressALaterDenyByDefaultWarnForADifferentName() {
-        FakeHerdr herdr = new FakeHerdr();
-        AtomicReference<FleetConfig.MemberCredentials> credsState = new AtomicReference<>(
-                new FleetConfig.MemberCredentials(
-                        FleetConfig.MemberCredentials.POLICY_ALLOW_LIST, List.of(), List.of(), null));
-        AtomicReference<Set<String>> hostEnvState =
-                new AtomicReference<>(Set.of("FLEETD_WORKER_TOKEN"));
-        WiringLauncher launcher = new WiringLauncher(herdr, credsState::get, "/bin/zsh", hostEnvState::get);
-
-        Logger logger = (Logger) LoggerFactory.getLogger(HerdrPeerLauncher.class);
-        Level original = logger.getLevel();
-        logger.setLevel(Level.WARN);
-        ListAppender<ILoggingEvent> appender = new ListAppender<>();
-        appender.start();
-        logger.addAppender(appender);
-        try {
-            // Spawn 1: allow-list, gap kept by the derived list — the keptByDerivedList WARN.
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-
-            // Live reload the OTHER way: back to deny-by-default, with a different name.
-            credsState.set(new FleetConfig.MemberCredentials(null, List.of(), List.of(), null));
-            hostEnvState.set(Set.of("LATER_UNCOVERED_TOKEN"));
-            launcher.spawn(new SpawnRequest("test", null, null, null, null, MemberRole.DEV));
-        } finally {
-            logger.detachAppender(appender);
-            logger.setLevel(original);
-        }
-
-        List<String> messages = appender.list.stream().map(ILoggingEvent::getFormattedMessage).toList();
-        assertTrue(messages.stream().anyMatch(
-                        m -> m.contains("UNBLOCKED") && m.contains("FLEETD_WORKER_TOKEN")),
-                "spawn 1's allow-list gap must warn — got: " + messages);
-        assertTrue(messages.stream().anyMatch(
-                        m -> m.contains("UNBLOCKED") && m.contains("LATER_UNCOVERED_TOKEN")),
-                "spawn 2's deny-by-default gap names a different variable and must still be warned "
-                        + "about, even though an allow-list WARN already fired. Got: " + messages);
-    }
-
     /**
      * fleetd #185 stage 2: with {@code memberHerdrSocket:} configured, member panes run under a
      * different OS user — {@link HerdrPeerLauncher#hostEnvNames} describes fleetd's own process, not