Keep worker director questions from dying under the tool watchdog

A configured tools.timeoutMs would abort ask_director, cancel the pending
ask, and turn a later send_input into a steer. The watchdog now skips
that tool the same way it skips wait_agents. Register and interrupt also
fail closed so a cancelled session cannot hang on a late question.

Author: TheGreatAxios

src/subagent/ask-director.test.ts

@@ -108,13 +108,17 @@ describe("evaluateAskDirector", () => {
     const state = createAskDirectorState();
     const controller = new AbortController();
     let cancelled = 0;
+    let rejectAnswer: ((reason: unknown) => void) | undefined;
     const port = {
       register: (): Promise<string> => {
         controller.abort();
-        return new Promise<string>(() => {});
+        return new Promise<string>((_resolve, reject) => {
+          rejectAnswer = reject;
+        });
       },
       cancel: () => {
         cancelled += 1;
+        rejectAnswer?.(new Error("ask_director aborted"));
       },
     };
     const message = await handleAskDirector({
@@ -129,6 +133,44 @@ describe("evaluateAskDirector", () => {
     expect(cancelled).toBeGreaterThan(0);
   });
 
+  test("abort after register does not leave an unhandled rejection", async () => {
+    const state = createAskDirectorState();
+    const controller = new AbortController();
+    const unhandled: unknown[] = [];
+    const onUnhandled = (reason: unknown) => {
+      unhandled.push(reason);
+    };
+    process.on("unhandledRejection", onUnhandled);
+    try {
+      let rejectAnswer: ((reason: unknown) => void) | undefined;
+      const port = {
+        register: (): Promise<string> => {
+          const answer = new Promise<string>((_resolve, reject) => {
+            rejectAnswer = reject;
+          });
+          controller.abort();
+          return answer;
+        },
+        cancel: () => {
+          rejectAnswer?.(new Error("ask_director aborted"));
+        },
+      };
+      const message = await handleAskDirector({
+        question: "which file?",
+        state,
+        port,
+        signal: controller.signal,
+      });
+      expect(message).toContain("cancelled");
+      expect(state.questions).toBe(0);
+      expect(state.pending).toBe(false);
+      await new Promise((r) => setTimeout(r, 0));
+      expect(unhandled).toEqual([]);
+    } finally {
+      process.off("unhandledRejection", onUnhandled);
+    }
+  });
+
   test("register throw does not consume a cap slot", async () => {
     const state = createAskDirectorState();
     const port = {

src/subagent/ask-director.ts

@@ -112,6 +112,11 @@ export async function handleAskDirector(args: {
       });
       if (args.signal.aborted) {
         onAbort();
+        try {
+          await answerP;
+        } catch {
+          // cancelAsk rejects this; await so it is not an unhandledRejection.
+        }
         return "Error: ask_director was cancelled.";
       }
       commitAskDirector(args.state);

src/subagent/session-store.test.ts

@@ -1135,6 +1135,66 @@ describe("pending ask_director", () => {
     expect(resolved).toBe("src/foo.ts");
   });
 
+  test("interrupt then late registerAsk returns false and leaves no pending ask", () => {
+    const store = createSubAgentSessionStore();
+    const session = store.start({
+      description: "d",
+      agentId: "a",
+      brief: "b",
+      retained: true,
+    });
+    store.markRunning(session.id);
+    store.registerInterrupt(session.id, () => {});
+    expect(store.interruptOne(session.id).ok).toBe(true);
+
+    expect(
+      store.registerAsk(session.id, {
+        question: "late?",
+        questionId: "ask-1",
+        resolve: () => {
+          throw new Error("should not resolve");
+        },
+        reject: () => {
+          throw new Error("should not reject");
+        },
+      }),
+    ).toBe(false);
+    expect(store.hasPendingAsk(session.id)).toBe(false);
+  });
+
+  test("interruptOne with missing handle does not cancel the pending ask", () => {
+    const store = createSubAgentSessionStore();
+    const session = store.start({
+      description: "d",
+      agentId: "a",
+      brief: "b",
+      retained: true,
+    });
+    store.markRunning(session.id);
+    let rejected: unknown;
+    let resolved: string | undefined;
+    store.registerAsk(session.id, {
+      question: "which file?",
+      questionId: "ask-1",
+      resolve: (answer) => {
+        resolved = answer;
+      },
+      reject: (reason) => {
+        rejected = reason;
+      },
+    });
+
+    expect(store.interruptOne(session.id)).toEqual({
+      ok: false,
+      status: "running",
+    });
+    expect(store.hasPendingAsk(session.id)).toBe(true);
+    expect(rejected).toBeUndefined();
+    expect(resolved).toBeUndefined();
+    expect(store.resolveAsk(session.id, "src/foo.ts")).toBe(true);
+    expect(resolved).toBe("src/foo.ts");
+  });
+
   test("complete and close cancel a pending ask", async () => {
     const store = createSubAgentSessionStore();
     const completed = store.start({ description: "c", agentId: "a", brief: "b" });

src/subagent/session-store.ts

@@ -1242,7 +1242,9 @@ export function createSubAgentSessionStore(
         reject: (reason: unknown) => void;
       },
     ): boolean {
-      if (!sessions.has(id)) return false;
+      const session = sessions.get(id);
+      if (session === undefined) return false;
+      if (session.lifecycle.state !== "running") return false;
       if (pendingAsks.has(id)) return false;
       pendingAsks.set(id, ask);
       mutate(id, () => {});
@@ -1278,11 +1280,11 @@ export function createSubAgentSessionStore(
       if (!isLiveStrip(session.lifecycle)) {
         return { ok: false, status: projectLifecycleStatus(session.lifecycle) };
       }
-      settleCancelsAsks(id, "session interrupted");
       const interrupt = interruptHandles.get(id);
       if (interrupt === undefined) {
         return { ok: false, status: projectLifecycleStatus(session.lifecycle) };
       }
+      settleCancelsAsks(id, "session interrupted");
       interrupt();
       mutate(id, (s) => {
         s.lifecycle = {

src/tui/tool-execution-watchdog.test.ts

@@ -64,6 +64,22 @@ describe("tool execution watchdog", () => {
     ).toBeUndefined();
   });
 
+  test("ask_director with no settings timeout is unbounded", () => {
+    expect(
+      resolveToolExecutionTimeoutMs(undefined, { id: "1", name: "ask_director", arguments: {} }),
+    ).toBeUndefined();
+  });
+
+  test("ask_director is exempt from the settings watchdog", () => {
+    // Awaiting the director can outlast settings.tools.timeoutMs; aborting
+    // would cancel the pending ask so later send_input steers instead of answering.
+    const call = { id: "1", name: "ask_director", arguments: {} };
+    expect(resolveToolExecutionTimeoutMs({ defaultMs: 660_000 }, call)).toBeUndefined();
+    expect(
+      resolveToolExecutionTimeoutMs({ defaultMs: 660_000, maxMs: 1_800_000 }, call),
+    ).toBeUndefined();
+  });
+
   test("wait_agents run outlasting the generic budget completes with its own report", async () => {
     const runner = createDynamicToolRunner(
       [
@@ -83,6 +99,24 @@ describe("tool execution watchdog", () => {
     expect(result.content).toContain("worker report");
   });
 
+  test("ask_director run outlasting the generic budget completes with its own answer", async () => {
+    const runner = createDynamicToolRunner(
+      [
+        stringTool("ask_director", async () => {
+          await new Promise((r) => setTimeout(r, 120));
+          return "src/foo.ts";
+        }),
+      ],
+      { defaultMs: 30 },
+    );
+    const result = await runner.run(
+      { id: "t", name: "ask_director", arguments: {} },
+      new AbortController().signal,
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content).toContain("src/foo.ts");
+  });
+
   test("omitted config does not arm a default watchdog", () => {
     expect(resolveToolExecutionTimeoutMs(undefined)).toBeUndefined();
     expect(resolveToolExecutionTimeoutMs({})).toBeUndefined();

src/tui/tool-execution-watchdog.ts

@@ -70,11 +70,13 @@ export const MAX_TOOL_APPROVAL_PAUSE_MS = 1_800_000;
  * layer cannot beat shell-guard). A requested run_shell timeout is not clamped
  * to MAX_TOOL_EXECUTION_TIMEOUT_MS or tools.maxTimeoutMs.
  *
- * spawn_agent returns immediately; wait_agents is the long block. Both are
- * exempt: wait_agents can outlast settings.tools.timeoutMs while workers
- * still run, and aborting collect would not stop those workers. spawn_agent
- * stays exempt so the generic per-tool budget cannot abort a dispatch that
- * should return at once (or a worker that carries its own bound).
+ * spawn_agent returns immediately; wait_agents and ask_director are the long
+ * blocks. All three are exempt: wait_agents can outlast settings.tools.timeoutMs
+ * while workers still run, and aborting collect would not stop those workers.
+ * spawn_agent stays exempt so the generic per-tool budget cannot abort a
+ * dispatch that should return at once (or a worker that carries its own bound).
+ * ask_director is a long block awaiting the director; aborting it cancels the
+ * pending ask so later send_input steers instead of answering.
  *
  * mcp__* tool calls are the opposite of exempt: they arm unconditionally (see
  * resolveMcpToolTimeoutMs) even when no Settings are configured, because an
@@ -85,7 +87,13 @@ export function resolveToolExecutionTimeoutMs(
   config?: ToolWatchdogConfig,
   call?: ToolCall,
 ): number | undefined {
-  if (call?.name === "spawn_agent" || call?.name === "wait_agents") return undefined;
+  if (
+    call?.name === "spawn_agent" ||
+    call?.name === "wait_agents" ||
+    call?.name === "ask_director"
+  ) {
+    return undefined;
+  }
   if (call?.name === "run_shell") {
     const requested = requestedRunShellTimeoutMs(call);
     if (requested !== undefined) {