Include interrupted stop reason on in-flight wait results

interrupt_agent flipped wait to interrupted while the run was still in flight, so wait JSON omitted stop_reason. Skywalker classifies interrupted-incomplete only on that field.

Author: TheGreatAxios

docs/TELEMETRY.md

@@ -111,8 +111,8 @@ a truthy value (`1`, `true`, …) to restore per-call spans for debugging.
 worker ending during an active parent turn carries that turn's `parent_trace_id`.
 Pre-progress operator aborts settle with `status=cancelled` and
 `stop_reason=cancelled` even when the worker promise rejects. An interrupt that
-keeps a worker resumable settles with `status=interrupted` and the same
-`stop_reason=cancelled`; terminal events never report a still-running status.
+keeps a worker resumable settles with `status=interrupted` and
+`stop_reason=interrupted`; terminal events never report a still-running status.
 
 A deterministic synthetic fixture captures 10 parent generations, 80 parent
 tool spans, and 4 worker start/end pairs. The comparable former shape is 98

src/subagent/agent-fleet.test.ts

@@ -999,10 +999,15 @@ describe("interrupt_agent unblocks wait_agents", () => {
 
     const waited = await waiting;
     expect(waited.timed_out).toBe(false);
-    const results = waited.results as { agent_id: string; status: string }[];
-    expect(results).toEqual([{ agent_id: id, status: "interrupted" }]);
+    const results = waited.results as {
+      agent_id: string;
+      status: string;
+      stop_reason?: string;
+    }[];
+    expect(results).toEqual([{ agent_id: id, status: "interrupted", stop_reason: "interrupted" }]);
     expect(deps.sessions.get(id)?.lifecycleStatus).toBe("interrupted");
     expect(deps.sessions.get(id)?.status).toBe("running");
+    expect(deps.sessions.get(id)?.stopReason).toBe("interrupted");
   });
 
   test("an interrupted run result terminalizes a still-running fleet record", async () => {
@@ -1135,8 +1140,12 @@ describe("interrupt_agent unblocks wait_agents", () => {
 
     const waited = await callTool(wait, { targets: [id], timeout_ms: 5000 });
     expect(waited.timed_out).toBe(false);
-    const results = waited.results as { agent_id: string; status: string }[];
-    expect(results).toEqual([{ agent_id: id, status: "interrupted" }]);
+    const results = waited.results as {
+      agent_id: string;
+      status: string;
+      stop_reason?: string;
+    }[];
+    expect(results).toEqual([{ agent_id: id, status: "interrupted", stop_reason: "interrupted" }]);
     expect(deps.fleetRecords.peek(id)?.status).toBe("interrupted");
     expect(deps.fleetRecords.peek(id)?.collected).toBe(true);
 

src/subagent/agent-fleet.ts

@@ -337,6 +337,10 @@ class FleetMailbox {
       overlay.tombstoned !== true && session !== undefined && sessionWait === status
         ? session
         : undefined;
+    const stopReason =
+      overlay.tombstoned !== true && !isLiveWaitStatus(status)
+        ? (payload?.stopReason ?? session?.stopReason)
+        : payload?.stopReason;
     const ask = status === "awaiting_director" ? this.sessions.peekAsk(id) : undefined;
     return {
       status,
@@ -345,7 +349,7 @@ class FleetMailbox {
       ...(overlay.hint !== undefined ? { hint: overlay.hint } : {}),
       ...(payload?.report !== undefined ? { report: payload.report } : {}),
       ...(payload?.error !== undefined && status === "failed" ? { error: payload.error } : {}),
-      ...(payload?.stopReason !== undefined ? { stopReason: payload.stopReason } : {}),
+      ...(stopReason !== undefined ? { stopReason } : {}),
       ...(overlay.providerFailure === true ? { providerFailure: true } : {}),
       ...(ask !== undefined ? { question: ask.question, questionId: ask.questionId } : {}),
       ...(status === "awaiting_director" && session !== undefined
@@ -466,7 +470,8 @@ export const waitAgentsToolDefinition: ToolDefinition = {
     `clamped to a ${MAX_WAIT_TIMEOUT_MS}ms max. A timeout or parent-turn abort is NOT an error and never touches ` +
     `the workers — they keep running and remain waitable. Live wait status includes "queued" (waiting for a burst ` +
     `slot), "running", and "awaiting_director". interrupt_agent and close_agent unblock this wait immediately with ` +
-    `status "interrupted". awaiting_director is not terminal: re-wait while still pending re-delivers the same question. ` +
+    `status "interrupted". Terminal JSON includes stop_reason when the session recorded one ` +
+    `(interrupted, cancelled, incomplete-report, and similar). awaiting_director is not terminal: re-wait while still pending re-delivers the same question. ` +
     `Answer with send_input (soft). Do not call this in a tight zero-progress loop: a timeout means the targets are still ` +
     `queued, running, or awaiting a director answer, not "try again right away" — do other work, reply to the operator, or change the brief. Calling again with the ` +
     `same targets is a real timed wait, not a spin, but wastes turns if nothing has changed.`,

src/subagent/session-store.test.ts

@@ -299,6 +299,15 @@ describe("terminal stop reasons", () => {
     store.cancel(bare.id);
     expect(store.get(bare.id)?.stopReason).toBe("cancelled");
   });
+
+  test("interruptOne records stopReason interrupted", () => {
+    const store = createSubAgentSessionStore();
+    const session = store.start({ description: "d", agentId: "a", brief: "b" });
+    store.markRunning(session.id);
+    store.registerInterrupt(session.id, () => {});
+    expect(store.interruptOne(session.id).ok).toBe(true);
+    expect(store.get(session.id)?.stopReason).toBe("interrupted");
+  });
 });
 
 describe("CL-6943 reusable worker sessions", () => {

src/subagent/session-store.ts

@@ -1382,6 +1382,7 @@ export function createSubAgentSessionStore(
               ...(s.report !== undefined ? { report: s.report } : {}),
             };
             s.finishedAt = s.finishedAt ?? now();
+            s.stopReason = "interrupted";
           });
           pruneRetained();
           return { ok: true };
@@ -1396,6 +1397,7 @@ export function createSubAgentSessionStore(
           ...(s.report !== undefined ? { report: s.report } : {}),
         };
         s.finishedAt = s.finishedAt ?? now();
+        s.stopReason = "interrupted";
       });
       pruneRetained();
       return { ok: true };