Require fleetRecords on interrupt and tighten fleet wait coverage

Author: TheGreatAxios

src/subagent/agent-fleet.test.ts

@@ -174,7 +174,7 @@ describe("spawn_agent + wait_agents", () => {
     expect(secondResults[0]!.report).toBe("finished");
   });
 
-  test("wait_agents with no targets waits on all currently running spawned agents", async () => {
+  test("wait_agents with no targets waits on all uncollected agents in this fleet", async () => {
     const gates = [deferred<RunSubAgentResult>(), deferred<RunSubAgentResult>()];
     let callIndex = 0;
     const deps = makeDeps(async () => gates[callIndex++]!.promise);
@@ -462,6 +462,64 @@ describe("wait_agents caller scope", () => {
     expect(finishedResults.every((r) => r.status === "done")).toBe(true);
   });
 
+  test("mode=all with one interrupted target stays blocked until siblings finish", async () => {
+    const gates = [deferred<RunSubAgentResult>(), deferred<RunSubAgentResult>()];
+    let callIndex = 0;
+    const deps = makeDeps(async (params) => {
+      params.onAgentReady?.({
+        close: async () => {},
+        interrupt: () => {},
+        followup: async () => "",
+      });
+      return gates[callIndex++]!.promise;
+    });
+    const spawn = createSpawnAgentTool(deps);
+    const wait = createWaitAgentsTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const interrupt = createInterruptAgentTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+
+    const first = await callTool(spawn, {
+      description: "a",
+      prompt: "do it",
+      intent: "explore",
+    });
+    const second = await callTool(spawn, {
+      description: "b",
+      prompt: "do it",
+      intent: "explore",
+    });
+    const ids = [first.agent_id as string, second.agent_id as string];
+
+    // Interrupt one of N while mode=all is in flight: interrupted is terminal
+    // for that target, but mode=all must not complete as "all done" while a
+    // sibling is still running.
+    if (interrupt.kind !== "full") throw new Error("expected full tool");
+    await interrupt.handler(
+      { id: "int-1", name: "interrupt_agent", arguments: { target: ids[0]! } },
+      new AbortController().signal,
+    );
+
+    const partial = await callTool(wait, { targets: ids, mode: "all", timeout_ms: 50 });
+    expect(partial.timed_out).toBe(true);
+    const partialResults = partial.results as { agent_id: string; status: string }[];
+    expect(partialResults.find((r) => r.agent_id === ids[0]!)?.status).toBe("interrupted");
+    expect(partialResults.find((r) => r.agent_id === ids[1]!)?.status).toBe("running");
+
+    gates[1]!.resolve({ report: "b done" });
+    const finished = await callTool(wait, { targets: ids, mode: "all", timeout_ms: 5000 });
+    expect(finished.timed_out).toBe(false);
+    const finishedResults = finished.results as { agent_id: string; status: string }[];
+    expect(finishedResults.find((r) => r.agent_id === ids[0]!)?.status).toBe("interrupted");
+    expect(finishedResults.find((r) => r.agent_id === ids[1]!)?.status).toBe("done");
+    // Leave the interrupted gate unresolved — interrupt unblocked the wait
+    // without the run settling.
+  });
+
   test("aborting the wait returns without cancelling workers", async () => {
     const gate = deferred<RunSubAgentResult>();
     const deps = makeDeps(async () => gate.promise);

src/subagent/agent-fleet.ts

@@ -151,10 +151,6 @@ class FleetRecords {
     this.notify();
   }
 
-  ids(): string[] {
-    return [...this.records.keys()];
-  }
-
   /** Running plus terminal-but-not-yet-handed-to-a-waiter. */
   uncollectedIds(): string[] {
     return [...this.records.entries()]

src/subagent/authority.ts

@@ -109,14 +109,9 @@ function isDescendant(
 }
 
 /**
- * SEAM, NOT YET A LIVE GATE: this function has no production call site today.
- * No verb in this codebase currently lets one live agent target another
- * (`task` only spawns; it never addresses an existing session), so the
- * subtree rule below is exercised only by authority.test.ts — it is not
- * enforced at runtime yet. It exists now so future verbs that make one
- * agent addressable by another can call it from day one instead of
- * inventing their own check. Until one of those wires a call site here, do
- * not describe this rule as enforced; only assertTierMayMountFleetVerb is.
+ * Live gate for `read_agent_trace` (and any future verb that addresses an
+ * existing session). Callers that only spawn (`task`, `spawn_agent`) never
+ * reach this check.
  *
  * Authority rule (root owns its tree; a child manages only its own
  * descendants): throws unless `actor` is Tier 1, or `targetId` is `actor.id`

src/subagent/lifecycle-tools.test.ts

@@ -6,6 +6,7 @@ import {
   createInterruptAgentTool,
   createFollowupTaskTool,
 } from "./lifecycle-tools.js";
+import { createFleetRecords } from "./agent-fleet.js";
 import { createSubAgentSessionStore } from "./session-store.js";
 
 async function callTool(
@@ -135,7 +136,10 @@ describe("interrupt_agent / followup_task", () => {
       return `Applying fix given ${history.length} prior turns of context.`;
     });
 
-    const interruptAgent = createInterruptAgentTool({ sessions });
+    const interruptAgent = createInterruptAgentTool({
+      sessions,
+      fleetRecords: createFleetRecords(),
+    });
     const followupTask = createFollowupTaskTool({ sessions });
 
     const interruptResult = await callTool(interruptAgent, { target: worker.id });
@@ -219,7 +223,10 @@ describe("interrupt_agent / followup_task", () => {
     });
     sessions.registerFollowup(worker.id, async () => "resumed cleanly");
 
-    const interruptAgent = createInterruptAgentTool({ sessions });
+    const interruptAgent = createInterruptAgentTool({
+      sessions,
+      fleetRecords: createFleetRecords(),
+    });
     const followupTask = createFollowupTaskTool({ sessions });
 
     await callTool(interruptAgent, { target: worker.id });
@@ -239,7 +246,10 @@ describe("interrupt_agent / followup_task", () => {
     const notRunning = sessions.start({ description: "d", agentId: "a", brief: "b" });
     sessions.complete(notRunning.id, "## Summary\nDone.");
 
-    const interruptAgent = createInterruptAgentTool({ sessions });
+    const interruptAgent = createInterruptAgentTool({
+      sessions,
+      fleetRecords: createFleetRecords(),
+    });
     const followupTask = createFollowupTaskTool({ sessions });
 
     if (interruptAgent.kind !== "full") throw new Error("expected full tool");

src/subagent/lifecycle-tools.ts

@@ -87,10 +87,15 @@ function descendantsClosingOrder(
 
 export interface LifecycleToolDeps {
   sessions: SubAgentSessionStore;
-  /** When set, interrupt_agent terminalizes this wait mailbox immediately. */
+  /** Optional for close/resume/followup; interrupt requires it (see InterruptAgentToolDeps). */
   fleetRecords?: FleetRecordsHandle;
 }
 
+/** interrupt_agent always terminalizes the wait mailbox — no silent skip. */
+export type InterruptAgentToolDeps = LifecycleToolDeps & {
+  fleetRecords: FleetRecordsHandle;
+};
+
 export function createCloseAgentTool(deps: LifecycleToolDeps): AgentTool {
   return tool({
     definition: closeAgentToolDefinition,
@@ -173,7 +178,7 @@ export const interruptAgentToolDefinition: ToolDefinition = {
   },
 };
 
-export function createInterruptAgentTool(deps: LifecycleToolDeps): AgentTool {
+export function createInterruptAgentTool(deps: InterruptAgentToolDeps): AgentTool {
   return tool({
     definition: interruptAgentToolDefinition,
     handler: async (call, _signal): Promise<ToolResult> => {
@@ -194,7 +199,7 @@ export function createInterruptAgentTool(deps: LifecycleToolDeps): AgentTool {
       }
       // Wait mailbox is separate from the TUI strip — flip it here so
       // wait_agents does not stay blocked on a still-"running" record.
-      deps.fleetRecords?.interrupt(target);
+      deps.fleetRecords.interrupt(target);
       return lifecycleResult(
         call.id,
         JSON.stringify({ agent_id: target, status: "interrupted" satisfies AgentLifecycleStatus }),

src/subagent/run-authority.test.ts

@@ -167,3 +167,49 @@ describe("runSubAgent search_agents mount gate (CL-7051, Tier-1 only)", () => {
     expect(searchAgentsMounts).toBe(1);
   });
 });
+
+describe("runSubAgent passes parentSessionId into spawn_agent mount", () => {
+  test("nested orchestrator fleetDeps.parentSessionId equals params.id", async () => {
+    const cwd = await tmpCwd();
+    let capturedParentSessionId: string | undefined;
+    let spawnMounts = 0;
+
+    await withMockedModuleDuring(
+      import.meta.resolve("./agent-fleet.js"),
+      (real: typeof import("./agent-fleet.js")) => ({
+        ...real,
+        createSpawnAgentTool: (deps: Parameters<typeof real.createSpawnAgentTool>[0]) => {
+          spawnMounts++;
+          capturedParentSessionId = deps.parentSessionId;
+          return real.createSpawnAgentTool(deps);
+        },
+      }),
+      async () => {
+        const { runSubAgent: run } = await import("./run.js");
+        try {
+          await run({
+            ...baseParams(cwd, join(cwd, ".ctx")),
+            id: "greybeard-session",
+            orchestrator: true,
+            orchestratorTier: "nested-orchestrator",
+            nestedDispatch: {
+              permissionGate: testPermissionGate,
+              getWorkdirBase: () => join(cwd, ".ctx"),
+              provider: {
+                providerName: "test",
+                baseURL: "http://localhost",
+                model: "test-model",
+              },
+              profiles: [{ id: "intern", systemPromptRole: "You are intern." }],
+            },
+          });
+        } catch {
+          // Inference/agent construction may fail; mount decisions run first.
+        }
+      },
+    );
+
+    expect(spawnMounts).toBe(1);
+    expect(capturedParentSessionId).toBe("greybeard-session");
+  });
+});