Point parent wakes at the send_input target field

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -209,7 +209,9 @@ Three distinct concepts (do not conflate them):
 
 The **`spawn_agent`** tool starts a fleet agent on a separate inference source (tier/profile resolved from settings) and returns immediately with an `agent_id`; **`wait_agents`** collects reports later. Declared fan-out is unlimited: excess dispatches enqueue rather than fail. `run()` is admitted by `src/subagent/admission.ts` (default burst window of 8 is race-avoidance so a 429 freeze can fire before a herd — not a declared-spawn cap). Occupancy is the whole first `run()`, including `wait_agents`. Nested children of an already-admitted parent bypass **capacity** so a nested orchestrator cannot deadlock while holding a slot; they still wait on a provider 429 pause. Drain is FIFO among currently admissible jobs (a paused provider is skipped, not head-of-line for every provider). Resume and followup inference re-enter the same queue. Queued workers report wait/list status `queued` (live, not failed). Lowering capacity never cancels in-flight work. Retryable provider 429s freeze new admits via the shared retry remapper in `createCorbitsRetryPolicy`; `quota_exhausted` does not freeze. `list_agents` remains mailbox-scoped. The dispatch brief separates durable `context`, actionable `prompt`, and optional `goals` (checklist seeds for the _child's_ own `manage_tasks` list). Implement/review dispatches (and their default directors) fail closed without non-empty `success_criteria`. The child returns a structured report (`Summary` / `Findings` / `Blockers` / `Paths`) plus a tools-used footer. Parent and child never share a `manage_tasks` list.
 
-Workers ask the spawning parent with **`ask_director`** (not the human). That parks a question while the worker stays `running`. **`wait_agents`** returns `awaiting_director` with a question payload — that is not terminal. The parent answers with **`send_input`**, then **`wait_agents`** again. The TUI runner publishes an authoritative snapshot of currently pending top-level questions on each store notification, including empty snapshots before fleet-count updates. During synchronous session rotation, a runner-owned barrier suppresses both publications before delivery-generation invalidation, transcript clearing, and worker cancellation; successful reset reconciles a fresh snapshot before resuming asynchronous backend rebuild. The bridge drops resolved, cancelled, replaced, terminal, and removed asks and delivers each session/question identity once while pending. A coalesced wake starts only when the parent is not processing and every operator gate is closed, including parent-idle fleet holds where the shell stays busy. Worker gates do not manufacture parent processing. Replies target the worker session ID through `send_input`, never its shared catalog ID. Synthetic wakes use `SessionPort.deliver` through queued-delivery's idle-send path without entering the user follow-up queue or composer `/feedback` capture. Escalate to the human with **`ask_operator`** only when the parent cannot resolve it.
+Workers ask the spawning parent with **`ask_director`** (not the human). That parks a question while the worker stays `running`. **`wait_agents`** returns `awaiting_director` with a question payload — that is not terminal. The parent answers with **`send_input`**, then **`wait_agents`** again. Escalate to the human with **`ask_operator`** only when the parent cannot resolve it.
+
+When the parent TUI is not blocked in `wait_agents`, the runner publishes an authoritative snapshot of currently pending top-level questions on each store notification, including empty snapshots before fleet-count updates. During synchronous session rotation, a runner-owned barrier suppresses both publications before delivery-generation invalidation, transcript clearing, and worker cancellation; successful reset reconciles a fresh snapshot before resuming asynchronous backend rebuild. The bridge drops resolved, cancelled, replaced, terminal, and removed asks and delivers each session/question identity once while pending. A coalesced wake starts only when the parent is not processing and every operator gate is closed, including parent-idle fleet holds where the shell stays busy. Worker gates do not manufacture parent processing. Replies use `send_input`'s `target` field with the worker session ID, never its shared catalog ID. Synthetic wakes use `SessionPort.deliver` through queued-delivery's idle-send path without entering the user follow-up queue or composer `/feedback` capture.
 
 When profiles exist (local `.agents/agents/` and/or enabled **`kind: "agent"`** plugins, including **data-only** markdown plugins with no `index.ts`), the chat model also receives **`search_agents`** — a lexical index over profile id, description, and role text so the model can discover ids before calling `spawn_agent(agent=...)`. Results include each match's full loaded system prompt / body so the parent can inspect plugin or Claude marketplace agents without `read_file` on paths outside the session cwd (path-escape blocks those roots by design; writes remain blocked). `spawn_agent` and `search_agents` are core tools on the primary session.
 

docs/TUI.md

@@ -224,8 +224,8 @@ An `ask_director` lane stays live and reads as waiting on the director, not stal
 The runner snapshots currently pending root-worker questions, dropping resolved,
 cancelled, replaced, terminal, or removed asks before delivery. It sends one
 coalesced wake when the parent is not processing and all operator gates are closed,
-even while live workers hold the shell busy. Replies use `send_input` with the
-worker's session ID, not its shared catalog ID. Each session/question identity is
+even while live workers hold the shell busy. Replies use `send_input`'s `target`
+field with the worker's session ID, not its shared catalog ID. Each session/question identity is
 delivered once while pending; the strip never re-delivers it. Synthetic wakes use
 the idle delivery path, bypassing composer `/feedback` capture and leaving queued
 user follow-ups untouched.

src/subagent/fleet-report.ask-wake.test.ts

@@ -77,7 +77,7 @@ describe("pendingAskWakeText", () => {
     expect(text).toContain("Which port?");
     expect(text).toContain("q1");
     expect(text).toContain("send_input");
-    expect(text).toContain("targeting agent_id a1");
+    expect(text).toContain("using target a1");
     expect(text.toLowerCase()).toContain("worker");
   });
 });

src/subagent/fleet-report.ts

@@ -165,7 +165,7 @@ export function pendingAskWakeText(wake: PendingAskWake): string {
     "",
     wake.question,
     "",
-    `The worker — not the operator — raised this. Answer it with send_input (soft) targeting agent_id ${wake.sessionId}; do not relay to the operator unless it genuinely needs them.`,
+    `The worker — not the operator — raised this. Answer it with send_input (soft) using target ${wake.sessionId}; do not relay to the operator unless it genuinely needs them.`,
   ].join("\n");
 }
 

src/tui/runner/wiring.ask-wake.test.ts

@@ -301,7 +301,7 @@ test("same catalog workers answer by session, reconcile one resolution and repla
         ask("session-two", "replacement-question");
         bridge.handle({ type: "inference.done", data: {} });
         expect(sends).toHaveLength(1);
-        expect(sends[0]).toContain("targeting agent_id session-two");
+        expect(sends[0]).toContain("using target session-two");
         expect(sends[0]).toContain("replacement-question");
         expect(sends[0]).not.toContain("question-session-two");
         expect(sends[0]).not.toContain("question-session-one");

src/tui/runner/wiring.ts

@@ -64,7 +64,7 @@ export function createFleetWakePublisher(
     // Reconcile even an empty snapshot before a fleet drop can settle the parent.
     const asks = pendingAskSnapshot(lanes, (id) => sessions.peekAsk(id));
     emitter.emit("event", { type: "agent-ask", asks });
-    const fleet = liveFleetCount(sessions.list());
+    const fleet = liveFleetCount(lanes);
     if (fleet !== lastLiveFleet) {
       lastLiveFleet = fleet;
       emitter.emit("event", { type: "fleet", running: fleet });