Stop aborting long task and shell runs at eleven minutes

Author: TheGreatAxios

CHANGELOG.md

@@ -17,13 +17,23 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 - **Requested `run_shell` timeouts are no longer capped at 10 minutes.** The 15s
   default when timeout is omitted is unchanged. `shell.maxTimeoutMs` still
-  clamps the command when set. The tool-execution watchdog follows a longer
-  requested `run_shell` timeout instead of aborting at 11 minutes;
-  `tools.timeoutMs` / `tools.maxTimeoutMs` still bound other tools only.
-  Capability evals accept `--concurrency <n>` (env `CORBITS_EVAL_CONCURRENCY`,
+  clamps the command when set.
+
+- Capability evals accept `--concurrency <n>` (env `CORBITS_EVAL_CONCURRENCY`,
   default 1); overlapping `httpFixture` cells isolate `EVAL_HTTP_URL` so
   parallel web-bait runs do not share a process.env origin.
 
+### TUI
+
+- **Tool `run()` no longer has an implicit 11-minute wall-clock abort.** The
+  outer watchdog arms only when Settings set `tools.timeoutMs` /
+  `tools.maxTimeoutMs`, or when `run_shell` passes a positive `timeout`
+  (requested plus slack, so this layer cannot beat shell-guard). Unset
+  settings leave `task` and other tools unbounded; parent cancel, maxTurns,
+  and eval `--agent-timeout-ms` still bound the run. `tools.maxTimeoutMs`
+  still clamps non-shell tools when set and does not cap a longer requested
+  `run_shell`.
+
 ## [0.2.99] - 2026-08-21
 
 Skywalker is the primary orchestrator over a closed director fleet: product write tools stay off the primary, and you cannot spawn Skywalker as a task leaf. Workers are not done until they return the four-heading report. First-party action skills ship as slashes; eval runners require an explicit provider/model pair; the style skill no longer refuses non-git folders.

src/subagent/index.test.ts

@@ -792,6 +792,10 @@ describe("sub-agent stop helpers", () => {
     expect(resolveSubAgentDeadlineMs(45_000, 660_000)).toBe(45_000);
   });
 
+  test("resolveSubAgentDeadlineMs keeps an explicit deadline when the outer watchdog is omitted", () => {
+    expect(resolveSubAgentDeadlineMs(18_000_000, undefined)).toBe(18_000_000);
+  });
+
   test("resolveSubAgentDeadlineMs skips arming when outer watchdog is at or below the margin", () => {
     expect(resolveSubAgentDeadlineMs(5_000, 5_000)).toBeUndefined();
     expect(resolveSubAgentDeadlineMs(5_000, SUBAGENT_DEADLINE_MARGIN_MS)).toBeUndefined();

src/subagent/stop-policy.ts

@@ -32,15 +32,20 @@ export const SUBAGENT_DEADLINE_MARGIN_MS = 30_000;
  * maxTurns + operator cancel are the primary bounds; callers pass deadlineMs
  * only when they want an extra wall-clock stop.
  *
+ * When the outer watchdog is omitted (undefined), the requested deadline is
+ * kept — an absent settings timeout must not clamp a 5-hour (or any) explicit
+ * deadline down to a hidden default.
+ *
  * Returns undefined (do not arm) when the outer watchdog is at or below the
  * salvage margin — an internal deadline would otherwise race or exceed outer
  * and leave no room to return a salvage report.
  */
 export function resolveSubAgentDeadlineMs(
   requestedMs: number,
-  outerWatchdogMs: number,
+  outerWatchdogMs: number | undefined,
 ): number | undefined {
   const requested = Math.max(1, Math.floor(requestedMs));
+  if (outerWatchdogMs === undefined) return requested;
   if (outerWatchdogMs <= SUBAGENT_DEADLINE_MARGIN_MS) return undefined;
   // Ceiling must never exceed outer − margin (and stays ≥ 1 once outer > margin).
   const ceiling = Math.max(1, outerWatchdogMs - SUBAGENT_DEADLINE_MARGIN_MS);

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

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test";
 import type { AgentTool } from "@intx/agent";
 import { createDynamicToolRunner } from "./dynamic-tool-runner.js";
 import {
-  DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
   MAX_TOOL_EXECUTION_TIMEOUT_MS,
   RUN_SHELL_WATCHDOG_SLACK_MS,
   getToolApprovalBudget,
@@ -34,35 +33,59 @@ describe("tool execution watchdog", () => {
     expect(resolveToolExecutionTimeoutMs({ defaultMs: 9_999_999, maxMs: 100 })).toBe(100);
   });
 
-  test("run_shell requested timeout above 660s is not scheduled at the 11-minute default", () => {
-    const requested = 5_400_000;
+  test("task with no settings timeout is unbounded", () => {
+    expect(
+      resolveToolExecutionTimeoutMs(undefined, { id: "1", name: "task", arguments: {} }),
+    ).toBeUndefined();
+  });
+
+  test("omitted config does not arm a default watchdog", () => {
+    expect(resolveToolExecutionTimeoutMs(undefined)).toBeUndefined();
+    expect(resolveToolExecutionTimeoutMs({})).toBeUndefined();
+    expect(resolveToolExecutionTimeoutMs({ waitForApproval: true })).toBeUndefined();
+  });
+
+  test("settings timeout without max clamps to MAX_TOOL_EXECUTION_TIMEOUT_MS", () => {
+    expect(resolveToolExecutionTimeoutMs({ defaultMs: 9_999_999 })).toBe(
+      MAX_TOOL_EXECUTION_TIMEOUT_MS,
+    );
+  });
+
+  test("run_shell requested 5-hour timeout is not clamped", () => {
+    const requested = 18_000_000;
     const call = { id: "1", name: "run_shell", arguments: { timeout: requested } };
     const ms = resolveToolExecutionTimeoutMs(undefined, call);
     expect(ms).toBe(requested + RUN_SHELL_WATCHDOG_SLACK_MS);
-    expect(ms).toBeGreaterThan(DEFAULT_TOOL_EXECUTION_TIMEOUT_MS);
     expect(ms).toBeGreaterThan(MAX_TOOL_EXECUTION_TIMEOUT_MS);
   });
 
   test("tools.maxTimeoutMs does not cap a longer requested run_shell timeout", () => {
-    const requested = 5_400_000;
+    const requested = 18_000_000;
     const call = { id: "1", name: "run_shell", arguments: { timeout: requested } };
-    const ms = resolveToolExecutionTimeoutMs(
-      { defaultMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, maxMs: 100_000 },
-      call,
-    );
+    const ms = resolveToolExecutionTimeoutMs({ defaultMs: 660_000, maxMs: 100_000 }, call);
     expect(ms).toBe(requested + RUN_SHELL_WATCHDOG_SLACK_MS);
   });
 
-  test("omitted run_shell timeout keeps the default outer budget (shell-guard still 15s)", () => {
+  test("omitted run_shell timeout is unbounded (shell-guard still 15s)", () => {
     expect(
       resolveToolExecutionTimeoutMs(undefined, { id: "1", name: "run_shell", arguments: {} }),
-    ).toBe(DEFAULT_TOOL_EXECUTION_TIMEOUT_MS);
+    ).toBeUndefined();
+    expect(
+      resolveToolExecutionTimeoutMs(undefined, {
+        id: "1",
+        name: "run_shell",
+        arguments: { timeout: 0 },
+      }),
+    ).toBeUndefined();
+  });
+
+  test("omitted run_shell timeout still honors settings default", () => {
     expect(
       resolveToolExecutionTimeoutMs(
-        { maxMs: 100_000 },
-        { id: "1", name: "run_shell", arguments: { timeout: 0 } },
+        { defaultMs: 60_000, maxMs: 100_000 },
+        { id: "1", name: "run_shell", arguments: {} },
       ),
-    ).toBe(DEFAULT_TOOL_EXECUTION_TIMEOUT_MS);
+    ).toBe(60_000);
   });
 
   test("non-shell tools still honor tools.maxTimeoutMs", () => {
@@ -195,6 +218,47 @@ describe("tool execution watchdog", () => {
     expect(afterAbort.content).toBe("hang aborted");
   });
 
+  test("undefined timeout lets a 50ms tool complete", async () => {
+    const result = await runWithToolExecutionWatchdog(
+      { id: "unbounded", name: "task", arguments: {} },
+      new AbortController().signal,
+      undefined,
+      async () => {
+        await new Promise((r) => setTimeout(r, 50));
+        return { callId: "unbounded", content: "ok" };
+      },
+      { salvageGraceMs: TEST_SALVAGE_GRACE_MS, waitForApproval: true },
+    );
+    expect(result.isError).not.toBe(true);
+    expect(result.content).toBe("ok");
+  });
+
+  test("undefined timeout still surfaces parent abort", async () => {
+    const parent = new AbortController();
+    const pending = runWithToolExecutionWatchdog(
+      { id: "unbounded-hang", name: "task", arguments: {} },
+      parent.signal,
+      undefined,
+      async () => {
+        await new Promise(() => {});
+        return { callId: "unbounded-hang", content: "ok" };
+      },
+      { salvageGraceMs: TEST_SALVAGE_GRACE_MS, waitForApproval: true },
+    );
+    parent.abort();
+    const afterAbort = await Promise.race([
+      pending,
+      new Promise<never>((_, reject) =>
+        setTimeout(
+          () => reject(new Error("watchdog did not settle after parent abort + grace")),
+          TEST_SALVAGE_GRACE_MS + 500,
+        ),
+      ),
+    ]);
+    expect(afterAbort.isError).toBe(true);
+    expect(afterAbort.content).toBe("task aborted");
+  });
+
   test("isUsableToolExecuteResult rejects errors and empty bodies", () => {
     expect(isUsableToolExecuteResult({ callId: "1", content: "ok" })).toBe(true);
     expect(isUsableToolExecuteResult({ callId: "1", content: "  " })).toBe(false);

src/tui/tool-execution-watchdog.ts

@@ -15,12 +15,8 @@ export type ToolWatchdogConfig = {
   waitForApproval?: boolean;
 };
 
-// Outer budget for tools that have no per-call timeout. run_shell with a longer
-// requested timeout is resolved separately (see resolveToolExecutionTimeoutMs)
-// so this default — and MAX_TOOL_EXECUTION_TIMEOUT_MS / tools.maxTimeoutMs —
-// cannot abort it first. Omitting run_shell timeout still defaults to 15s
-// inside shell-guard.
-export const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 660_000;
+// Cap applied when Settings set tools.timeoutMs without tools.maxTimeoutMs.
+// Not an implicit default — omitted settings leave the watchdog unarmed.
 export const MAX_TOOL_EXECUTION_TIMEOUT_MS = 1_800_000;
 
 /**
@@ -46,16 +42,26 @@ export const MAX_TOOL_APPROVAL_PAUSE_MS = 1_800_000;
 
 const BUDGET_EXPIRED = Symbol("tool-execution-budget-expired");
 
+/**
+ * Wall-clock budget for one tool `run()`, or undefined to leave the timer unarmed.
+ * Parent cancel, maxTurns, and eval `--agent-timeout-ms` still bound the run.
+ *
+ * Arms only when Settings pass tools.timeoutMs / tools.maxTimeoutMs, or when
+ * run_shell passes a positive arguments.timeout (requested + slack so this
+ * layer cannot beat shell-guard). A requested run_shell timeout is not clamped
+ * to MAX_TOOL_EXECUTION_TIMEOUT_MS or tools.maxTimeoutMs.
+ */
 export function resolveToolExecutionTimeoutMs(
   config?: ToolWatchdogConfig,
   call?: ToolCall,
-): number {
+): number | undefined {
   if (call?.name === "run_shell") {
-    return resolveRunShellWatchdogTimeoutMs(config, call);
+    const requested = requestedRunShellTimeoutMs(call);
+    if (requested !== undefined) {
+      return requested + RUN_SHELL_WATCHDOG_SLACK_MS;
+    }
   }
-  const max = config?.maxMs ?? MAX_TOOL_EXECUTION_TIMEOUT_MS;
-  const raw = config?.defaultMs ?? DEFAULT_TOOL_EXECUTION_TIMEOUT_MS;
-  return Math.min(max, Math.max(1, Math.floor(raw)));
+  return resolveSettingsWatchdogTimeoutMs(config);
 }
 
 function requestedRunShellTimeoutMs(call: ToolCall): number | undefined {
@@ -66,22 +72,15 @@ function requestedRunShellTimeoutMs(call: ToolCall): number | undefined {
   return Math.floor(timeout);
 }
 
-/**
- * run_shell's watchdog floor is the requested command timeout (plus slack so
- * this outer timer cannot beat shell-guard). tools.maxTimeoutMs /
- * MAX_TOOL_EXECUTION_TIMEOUT_MS still bound other tools only — they must not
- * reimpose a cap when the operator/model passed a longer run_shell timeout.
- * Omitting timeout leaves the default outer budget (shell-guard still uses 15s).
- */
-function resolveRunShellWatchdogTimeoutMs(
+function resolveSettingsWatchdogTimeoutMs(
   config: ToolWatchdogConfig | undefined,
-  call: ToolCall,
-): number {
-  const raw = config?.defaultMs ?? DEFAULT_TOOL_EXECUTION_TIMEOUT_MS;
-  const floor = Math.max(1, Math.floor(raw));
-  const requested = requestedRunShellTimeoutMs(call);
-  if (requested === undefined) return floor;
-  return Math.max(floor, requested + RUN_SHELL_WATCHDOG_SLACK_MS);
+): number | undefined {
+  if (config === undefined || (config.defaultMs === undefined && config.maxMs === undefined)) {
+    return undefined;
+  }
+  const max = config.maxMs ?? MAX_TOOL_EXECUTION_TIMEOUT_MS;
+  const raw = config.defaultMs ?? max;
+  return Math.min(max, Math.max(1, Math.floor(raw)));
 }
 
 /** Default true: freeze tool budget while a permission prompt is open. */
@@ -122,6 +121,22 @@ export type PauseableTimeout = {
   resume: (token: PauseToken) => void;
 };
 
+/** Chain parent cancel without arming a run-duration timer. */
+function withParentAbort(signal: AbortSignal): PauseableTimeout {
+  const controller = new AbortController();
+  const onParentAbort = () => controller.abort();
+  signal.addEventListener("abort", onParentAbort, { once: true });
+  if (signal.aborted) controller.abort();
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      signal.removeEventListener("abort", onParentAbort);
+    },
+    pause: (): PauseToken => 0,
+    resume: (_token: PauseToken) => {},
+  };
+}
+
 /**
  * Like withTimeout, but the remaining budget freezes while paused (e.g. while
  * a permission prompt is open). Pause/resume are refcounted so nested pauses
@@ -322,8 +337,10 @@ export type ToolExecutionWatchdogOptions = {
 };
 
 /**
- * Runs `execute` under a wall-clock race against `parentSignal`, matching the
- * shell-guard search-tool pattern so non-abortable work still returns on time.
+ * Runs `execute` under a race against `parentSignal` and, when `timeoutMs` is
+ * set, a wall-clock budget. `undefined` timeout does not arm a timer — parent
+ * cancel and the approval-budget ALS still apply. Permission pause ceiling
+ * (`MAX_TOOL_APPROVAL_PAUSE_MS`) stays a stuck-prompt guard, not a run cap.
  *
  * When budget/parent abort wins the race, the signal is still aborted, but we
  * give the in-flight execute a short grace to return a usable non-error body
@@ -333,19 +350,22 @@ export type ToolExecutionWatchdogOptions = {
 export async function runWithToolExecutionWatchdog(
   call: ToolCall,
   parentSignal: AbortSignal,
-  timeoutMs: number,
+  timeoutMs: number | undefined,
   execute: (signal: AbortSignal) => Promise<ToolResult>,
   options: ToolExecutionWatchdogOptions,
 ): Promise<ToolResult> {
   const salvageGraceMs = options.salvageGraceMs ?? TOOL_EXECUTION_SALVAGE_GRACE_MS;
   const waitForApproval = options.waitForApproval;
-  const budget = waitForApproval
-    ? withPauseableTimeout(parentSignal, timeoutMs)
-    : {
-        ...withTimeout(parentSignal, timeoutMs),
-        pause: (): PauseToken => 0,
-        resume: (_token: PauseToken) => {},
-      };
+  const budget: PauseableTimeout =
+    timeoutMs === undefined
+      ? withParentAbort(parentSignal)
+      : waitForApproval
+        ? withPauseableTimeout(parentSignal, timeoutMs)
+        : {
+            ...withTimeout(parentSignal, timeoutMs),
+            pause: (): PauseToken => 0,
+            resume: (_token: PauseToken) => {},
+          };
   // Nested runs (task tool → child tool call) shadow the parent store: the
   // gate captures the innermost budget, so pause/resume must chain outward or
   // the parent `task` budget keeps ticking under the permission modal.
@@ -375,9 +395,10 @@ export async function runWithToolExecutionWatchdog(
         if (salvaged !== undefined) return salvaged;
         // Avoid unhandled rejection if execute later fails after we move on.
         void executePromise.catch(() => {});
-        const content = parentSignal.aborted
-          ? `${call.name} aborted`
-          : formatToolExecutionTimeoutMessage(call.name, timeoutMs);
+        const content =
+          timeoutMs !== undefined && !parentSignal.aborted
+            ? formatToolExecutionTimeoutMessage(call.name, timeoutMs)
+            : `${call.name} aborted`;
         return { callId: call.id, content, isError: true };
       }
 
@@ -392,6 +413,7 @@ export async function runWithToolExecutionWatchdog(
       if (
         budget.signal.aborted &&
         !parentSignal.aborted &&
+        timeoutMs !== undefined &&
         outcome.isError === true &&
         typeof outcome.content === "string" &&
         isAbortLikeToolError(outcome.content)