Keep a close overlay over a later completed stamp

A close or interrupt wait overlay must stay interrupted until collected,
even if a followup later stamps the session completed.

send_input interrupt does not set that overlay, so a happy-path followup
wait still collects done.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -228,7 +228,7 @@ Every director package carries a required `tier: SubagentTier` field (`src/agent
 Enforcement is runtime code at the existing tool-mount point, not prompt wording — this is the fix for four prior mechanisms (`writePaths`, `report.requiredSections`, a `--config` comment, the thrash matcher) that were documented-as-enforced while enforcing nothing:
 
 - **Mount-time gate — live today, and fails closed.** `spawn_agent` resolves the caller's tier at dispatch time — a closed director's `DirectorPackage.tier` — and forwards it as `RunSubAgentParams.orchestratorTier`. `runSubAgent` (`src/subagent/run.ts`) then calls `assertTierMayMountFleetVerb(tier, toolName)` (`src/subagent/authority.ts`) before installing fleet verbs, treating a **missing** `orchestratorTier` as `"leaf"` — deny, not skip. This is the case that matters most: a project-local or plugin `AgentProfile` with `orchestrator: true` is outside the closed director set and is **not** trusted with fleet verbs just because `orchestrator: true` is set — there is no profile-level opt-in today, so `spawn_agent` rejects a profile-sourced orchestrator before starting a session. `FLEET_VERBS` in `authority.ts` names the live verbs (`spawn_agent`, `wait_agents`, `list_agents`, `send_input`, `interrupt_agent`, `close_agent`, `resume_agent`, `read_agent_trace`, `search_agents`) so every mount site inherits the same gate. `list_agents` is the non-blocking mailbox-scoped list of this install's own `spawn_agent` workers (same scope as `wait_agents`); nested orchestrators may mount it. Fleet discovery (`search_agents`) remains Tier 1 only.
-- **Subtree authority — wired for addressing verbs.** `assertCanTargetAgent(actor, targetId, nodes)` implements the "root owns its tree; a child manages only its own descendants" rule over the `{id, parentSessionId}` shape `SubAgentSessionStore` already tracks. Production call sites: `read_agent_trace`, `wait_agents` explicit targets, `send_input`, `interrupt_agent`, `close_agent`, and `resume_agent`. Nested mounts pass `{actorId, tier, getNodes}` from `run.ts`; a missing `actorId` fails closed. Tier-1 primary omits authority and stays unrestricted. `spawn_agent` records `parentSessionId` on nested workers so `close_agent`'s descendant walk can see them. `wait_agents` with omitted targets waits only on that caller's per-install wait mailbox over the shared session store, not every running session. Wait JSON is a projection of stored lifecycle plus mailbox membership/pin/collected/interrupt override — not a second terminal store. `list_agents` reports that same mailbox without blocking. `interrupt_agent` stamps the session `interrupted`; wait JSON projects that stored lifecycle and does not write a mailbox overlay. `send_input` with `interrupt:true` leaves wait live (`running`/`queued`) until the followup settles; `interrupt_agent` and `close_agent` still set the mailbox interrupt overlay. `close_agent` terminalizes the wait mailbox before teardown. Operator cancel (`cancel` / `cancelAll`) projects wait status `interrupted`.
+- **Subtree authority — wired for addressing verbs.** `assertCanTargetAgent(actor, targetId, nodes)` implements the "root owns its tree; a child manages only its own descendants" rule over the `{id, parentSessionId}` shape `SubAgentSessionStore` already tracks. Production call sites: `read_agent_trace`, `wait_agents` explicit targets, `send_input`, `interrupt_agent`, `close_agent`, and `resume_agent`. Nested mounts pass `{actorId, tier, getNodes}` from `run.ts`; a missing `actorId` fails closed. Tier-1 primary omits authority and stays unrestricted. `spawn_agent` records `parentSessionId` on nested workers so `close_agent`'s descendant walk can see them. `wait_agents` with omitted targets waits only on that caller's per-install wait mailbox over the shared session store, not every running session. Wait JSON is a projection of stored lifecycle plus mailbox membership/pin/collected/interrupt override — not a second terminal store. `list_agents` reports that same mailbox without blocking. `interrupt_agent` stamps the session `interrupted` and, with `close_agent`, writes the mailbox interrupt overlay; `send_input` with `interrupt:true` does not. `send_input` with `interrupt:true` leaves wait live (`running`/`queued`) until the followup settles. `close_agent` terminalizes the wait mailbox before teardown. Operator cancel (`cancel` / `cancelAll`) projects wait status `interrupted`.
 - **Leaf `ask_director` (CL-6945).** Tier 3 leaves mount `ask_director` (not `ask_operator`). The worker evaluates caps, then awaits a session-store port; a missing port returns an error and does not suspend. `wait_agents` projects `awaiting_director` with `question` / `question_id` / `description` — this is wait JSON only, not a `WorkerLifecycle` state. Re-wait while still pending re-delivers the same question. Soft `send_input` answers the pending ask (it does not deliver a steer inbound). Interrupt / settle / close cancel the ask, including descendants. A worker blocked in `ask_director` is not stall-salvaged.
 - `spawn_agent` + `wait_agents` is the only spawn path. The tier check still gates which packages may mount any fleet verb.
 

src/subagent/agent-fleet.test.ts

@@ -1105,7 +1105,7 @@ describe("interrupt_agent unblocks wait_agents", () => {
   test("close_agent overlay survives a send_input followup completing in the close window", async () => {
     const gate = deferred<RunSubAgentResult>();
     const followupGate = deferred<string>();
-    const closeHold = deferred<void>();
+    const closeHold = deferred<undefined>();
     const deps = makeDeps(async (params) => {
       params.onAgentReady?.({
         close: async () => closeHold.promise,
@@ -1151,10 +1151,90 @@ describe("interrupt_agent unblocks wait_agents", () => {
     expect(results[0]!.status).toBe("interrupted");
     expect(deps.fleetRecords.peek(id)?.status).toBe("interrupted");
 
-    closeHold.resolve();
+    closeHold.resolve(undefined);
     await closing;
   });
 
+  test("close overlay without in-flight wait stays interrupted after followup complete", async () => {
+    const gate = deferred<RunSubAgentResult>();
+    const followupGate = deferred<string>();
+    const closeHold = deferred<undefined>();
+    const deps = makeDeps(async (params) => {
+      params.onAgentReady?.({
+        close: async () => closeHold.promise,
+        interrupt: () => {},
+        followup: async () => followupGate.promise,
+        deliver: () => {},
+      });
+      return gate.promise;
+    });
+    const spawn = createSpawnAgentTool(deps);
+    const wait = createWaitAgentsTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const list = createListAgentsTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const sendInput = createSendInputTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const close = createCloseAgentTool({
+      sessions: deps.sessions,
+      fleetRecords: deps.fleetRecords,
+    });
+    const spawned = await callTool(spawn, {
+      description: "looping",
+      prompt: "do it",
+      intent: "explore",
+    });
+    const id = spawned.agent_id as string;
+
+    await callTool(sendInput, { target: id, message: "stop that", interrupt: true });
+    if (close.kind !== "full") throw new Error("expected full tool");
+    const closing = close.handler(
+      { id: "close-held-then-followup", name: "close_agent", arguments: { target: id } },
+      new AbortController().signal,
+    );
+
+    followupGate.resolve("followup after close overlay");
+    await new Promise<void>((resolve) => {
+      const done = (): boolean => deps.sessions.get(id)?.lifecycle.state === "completed";
+      if (done()) {
+        resolve();
+        return;
+      }
+      const unsub = deps.sessions.subscribe(() => {
+        if (done()) {
+          unsub();
+          resolve();
+        }
+      });
+      if (done()) {
+        unsub();
+        resolve();
+      }
+    });
+
+    expect(deps.fleetRecords.peek(id)?.status).toBe("interrupted");
+    const listed = await callTool(list, {});
+    const entry = (listed.agents as { agent_id: string; status: string }[]).find(
+      (a) => a.agent_id === id,
+    );
+    expect(entry?.status).toBe("interrupted");
+
+    const waited = await callTool(wait, { targets: [id], timeout_ms: 5000 });
+    expect(waited.timed_out).toBe(false);
+    const results = waited.results as { status: string }[];
+    expect(results[0]!.status).toBe("interrupted");
+
+    closeHold.resolve(undefined);
+    await closing;
+    gate.resolve({ report: "original interrupted", interrupted: true } as RunSubAgentResult);
+  });
+
   test("completeAfterInterrupt does not clear a close overlay", () => {
     const sessions = createSubAgentSessionStore();
     const fleetRecords = createFleetMailbox(sessions);

src/subagent/agent-fleet.ts

@@ -326,13 +326,13 @@ class FleetMailbox {
   private projectedStatus(id: string, overlay: FleetOverlay): WaitJSONStatus {
     if (overlay.frozenStatus !== undefined) return overlay.frozenStatus;
     if (this.sessions.hasPendingAsk(id)) return "awaiting_director";
+    if (overlay.forceInterrupted === true) return "interrupted";
     const live = this.sessionWaitStatus(id);
     if (live !== undefined && !isLiveWaitStatus(live)) {
       overlay.lastWaitStatus = live;
       return live;
     }
     if (overlay.forceQueued === true) return "queued";
-    if (overlay.forceInterrupted === true) return "interrupted";
     if (live !== undefined) {
       overlay.lastWaitStatus = live;
       return live;