@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/test/unit/subagent-wait.test.ts

@@ -3,10 +3,12 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
+import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { WAIT_TOOL_ENABLED_ENV, resolveWaitToolConfig, waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
-import type { SubagentState } from "../../src/shared/types.ts";
+import { recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
+import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
 
-function writeStatus(asyncRoot: string, runId: string, state: string, extra: object = {}): void {
+function writeStatus(asyncRoot: string, runId: string, state: AsyncStatus["state"], extra: object = {}): void {
 	const dir = path.join(asyncRoot, runId);
 	fs.mkdirSync(dir, { recursive: true });
 	// Use a recent timestamp so the stale-run reconciler doesn't mark a live
@@ -20,11 +22,12 @@ function writeStatus(asyncRoot: string, runId: string, state: string, extra: obj
 			state,
 			startedAt: nowMs,
 			lastUpdate: nowMs,
-			steps: [{ agent: "builder", status: state }],
+			steps: [{ agent: "worker", status: state }],
 			...extra,
 		}),
 		"utf-8",
 	);
+	updateActiveRunIndex(dir, state);
 }
 
 function makeState(sessionId: string | null): SubagentState {
@@ -147,7 +150,7 @@ describe("subagent_wait tool", () => {
 				sessionId: "sess-1",
 				pid: 999999,
 				steps: [{
-					agent: "builder",
+					agent: "worker",
 					status: "running",
 					currentTool: "edit",
 					currentPath: "src/render.ts",
@@ -164,7 +167,7 @@ describe("subagent_wait tool", () => {
 			assert.equal(result.isError, undefined);
 			assert.equal(updates.length, 1);
 			assert.match(updates[0]!, /Waiting .* for 1 async run/);
-			assert.match(updates[0]!.split("\n")[0]!, /builder: edit .*src\/render\.ts/);
+			assert.match(updates[0]!.split("\n")[0]!, /worker: edit .*src\/render\.ts/);
 			assert.match(updates[0]!, /run-live/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
@@ -188,6 +191,138 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("tells blocking callers to revive resumable failed runs before replacing them", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-revive-first-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const sessionFile = path.join(root, "worker-session.jsonl");
+			fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-revive", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => writeStatus(asyncRoot, "run-revive", "failed", {
+					sessionId: "sess-1",
+					steps: [{ agent: "worker", status: "failed", sessionFile }],
+				}),
+			}));
+
+			assert.equal(result.isError, undefined);
+			const text = textOf(result);
+			assert.match(text, /1 failed/);
+			assert.match(text, /Resume-first/);
+			assert.match(text, /subagent\(\{ action: "resume", id: "run-revive", message:/);
+			assert.match(text, /before reporting failure or launching a replacement/);
+			assert.match(text, /only if revive fails or the user explicitly asks/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("surfaces terminal completion payloads from the result file in details.completions", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-file-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-a", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => {
+					writeStatus(asyncRoot, "run-a", "complete", { sessionId: "sess-1" });
+					fs.writeFileSync(path.join(resultsDir, "run-a.json"), JSON.stringify({
+						id: "run-a",
+						runId: "run-a",
+						sessionId: "sess-1",
+						agent: "workflow",
+						mode: "workflow",
+						state: "complete",
+						success: true,
+						results: [{
+							agent: "reviewer",
+							runId: "a1b2c3d4",
+							success: true,
+							outputState: "present",
+							output: "full output text stays out of details",
+							artifactPaths: {
+								outputPath: "/tmp/a1b2c3d4_reviewer_0_output.md",
+								metadataPath: "/tmp/a1b2c3d4_reviewer_0_meta.json",
+							},
+						}],
+					}), "utf-8");
+				},
+			}));
+
+			assert.equal(result.isError, undefined);
+			const completions = result.details.completions;
+			assert.equal(completions?.length, 1);
+			assert.equal(completions![0]!.runId, "run-a");
+			assert.equal(completions![0]!.mode, "workflow");
+			assert.equal(completions![0]!.success, true);
+			const child = completions![0]!.results?.[0];
+			assert.equal(child?.agent, "reviewer");
+			assert.equal(child?.runId, "a1b2c3d4");
+			assert.equal(child?.artifactPaths?.metadataPath, "/tmp/a1b2c3d4_reviewer_0_meta.json");
+			assert.equal("output" in (child ?? {}), false);
+			// The result file is the watcher's to consume; the wait must not delete it.
+			assert.equal(fs.existsSync(path.join(resultsDir, "run-a.json")), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("reports malformed terminal result files as actionable errors", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-malformed-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-bad", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => {
+					writeStatus(asyncRoot, "run-bad", "complete", { sessionId: "sess-1" });
+					fs.writeFileSync(path.join(resultsDir, "run-bad.json"), "{not json", "utf-8");
+				},
+			}));
+
+			assert.equal(result.isError, true);
+			assert.match(textOf(result), /Failed to read subagent result/);
+			assert.match(textOf(result), /run-bad\.json/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("surfaces completions from the watcher record when the result file is already consumed", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-completions-record-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-b", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => {
+					writeStatus(asyncRoot, "run-b", "complete", { sessionId: "sess-1" });
+					// Simulates the watcher: payload recorded, file consumed and deleted.
+					recordWaitCompletion(state, "run-b", {
+						agent: "worker",
+						mode: "single",
+						state: "complete",
+						success: true,
+						results: [{ agent: "worker", success: true, outputState: "present" }],
+					}, Date.now(), 60_000);
+				},
+			}));
+
+			assert.equal(result.isError, undefined);
+			const completions = result.details.completions;
+			assert.equal(completions?.length, 1);
+			assert.equal(completions![0]!.runId, "run-b");
+			assert.equal(completions![0]!.results?.[0]?.agent, "worker");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("wakes when a run needs attention, not only on completion", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-attn-"));
 		try {
@@ -249,7 +384,7 @@ describe("subagent_wait tool", () => {
 			writeStatus(asyncRoot, "run-step-blocked", "running", {
 				sessionId: "sess-1",
 				pid: 999999,
-				steps: [{ agent: "builder", status: "running", activityState: "needs_attention" }],
+				steps: [{ agent: "worker", status: "running", activityState: "needs_attention" }],
 			});
 
 			let polls = 0;
@@ -343,7 +478,7 @@ describe("subagent_wait tool", () => {
 					cwd: root,
 					sessionId: "sess-1",
 					updatedAt: 1,
-					children: [{ agent: "commentator", index: 0, status: "detached", updatedAt: 1 }],
+					children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
 				}],
 				["foreground-other", {
 					runId: "foreground-other",
@@ -351,7 +486,7 @@ describe("subagent_wait tool", () => {
 					cwd: root,
 					sessionId: "sess-2",
 					updatedAt: 1,
-					children: [{ agent: "builder", index: 0, status: "detached", updatedAt: 1 }],
+					children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
 				}],
 			]);
 			let polls = 0;
@@ -359,7 +494,7 @@ describe("subagent_wait tool", () => {
 				sleep: async () => {
 					polls += 1;
 					state.foregroundRuns!.get("foreground-alpha")!.children[0] = {
-						agent: "commentator",
+						agent: "reviewer",
 						index: 0,
 						status: "completed",
 						finalOutput: "Recovered review",
@@ -427,7 +562,7 @@ describe("subagent_wait tool", () => {
 				cwd: root,
 				sessionId: "sess-1",
 				updatedAt: 1,
-				children: [{ agent: "builder", index: 0, status: "detached", updatedAt: 1 }],
+				children: [{ agent: "worker", index: 0, status: "detached", updatedAt: 1 }],
 			}]]);
 			const handlers = new Map<string, Array<(data: unknown) => void>>();
 			const events = {
@@ -480,14 +615,14 @@ describe("subagent_wait tool", () => {
 				cwd: root,
 				sessionId: "sess-1",
 				updatedAt: ts,
-				children: [{ agent: "builder", index: 0, status: "detached", transcriptPath, updatedAt: ts }],
+				children: [{ agent: "worker", index: 0, status: "detached", transcriptPath, updatedAt: ts }],
 			}]]);
 			const updates: string[] = [];
 			const result = await waitForSubagents({ id: "foreground-live" }, undefined, baseDeps(root, state, {
 				onUpdate: (update) => updates.push(textOf(update)),
 				sleep: async () => {
 					state.foregroundRuns!.get("foreground-live")!.children[0] = {
-						agent: "builder",
+						agent: "worker",
 						index: 0,
 						status: "completed",
 						finalOutput: "Implemented the renderer fix.",
@@ -500,7 +635,7 @@ describe("subagent_wait tool", () => {
 			assert.equal(result.isError, undefined);
 			assert.equal(updates.length, 1);
 			assert.match(updates[0]!, /Waiting for detached foreground run "foreground-live"/);
-			assert.match(updates[0]!, /builder · working after supervisor handoff/);
+			assert.match(updates[0]!, /worker · working after supervisor handoff/);
 			assert.match(updates[0]!, /current: edit: \{ path: src\/render\.ts \}/);
 			assert.match(updates[0]!, /assistant: I found the relevant renderer path\./);
 			assert.doesNotMatch(updates[0]!, /large delegated task/);
@@ -520,7 +655,7 @@ describe("subagent_wait tool", () => {
 					cwd: root,
 					sessionId: "sess-1",
 					updatedAt: 1,
-					children: [{ agent: "commentator", index: 0, status: "detached", updatedAt: 1 }],
+					children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
 				}]]);
 				const result = await waitForSubagents({ id: "foreground-still", timeoutMs: 5000 }, undefined, baseDeps(root, state, {
 					sleep: async () => {
@@ -549,7 +684,7 @@ describe("subagent_wait tool", () => {
 				cwd: root,
 				sessionId: "sess-1",
 				updatedAt: 1,
-				children: [{ agent: "commentator", index: 0, status: "detached", updatedAt: 1 }],
+				children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
 			}]]);
 
 			const result = await waitForSubagents({ id: "shared" }, undefined, baseDeps(root, state));

package/dist/extensions/pi-subagents/test/unit/task-intent.test.ts

@@ -4,18 +4,18 @@ import { classifyTaskMutationIntent, expectsImplementationMutation, taskMayMutat
 
 describe("classifyTaskMutationIntent", () => {
 	it("keeps write imperatives despite investigative wording", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Inspect the failure and implement the fix").kind, "implementation");
-		assert.equal(classifyTaskMutationIntent("builder", "Research the current code path and patch the bug").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failure and implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Research the current code path and patch the bug").kind, "implementation");
 	});
 
 	it("does not broaden the shared completion-guard classifier for role-only path patches", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Patch src/auth.ts").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Patch src/auth.ts").kind, "unknown");
 	});
 
 	it("treats scoped no-edit constraints as constraints, not task intent", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Do not modify tests; implement the fix").kind, "implementation");
-		assert.equal(classifyTaskMutationIntent("builder", "Fix the bug. Do not edit files outside src/.").kind, "implementation");
-		assert.equal(classifyTaskMutationIntent("builder", "Must not touch the production database; implement the fix locally").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests; implement the fix").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Fix the bug. Do not edit files outside src/.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Must not touch the production database; implement the fix locally").kind, "implementation");
 	});
 
 	it("stops the prohibition object before a following implementation clause", () => {
@@ -28,42 +28,81 @@ describe("classifyTaskMutationIntent", () => {
 			"Do not modify tests – implement the fix",
 			"Do not modify tests — implement the fix",
 		]) {
-			assert.equal(classifyTaskMutationIntent("builder", task).kind, "implementation", task);
+			assert.equal(classifyTaskMutationIntent("worker", task).kind, "implementation", task);
 		}
-		assert.equal(classifyTaskMutationIntent("builder", "Do not modify tests and fixtures").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify tests and fixtures").kind, "read-only");
 	});
 
 	it("lets blanket no-edit prohibitions win over write verbs", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Implement this. Do not edit files.").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("builder", "Do not edit files. Tell me how to fix the bug.").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("builder", "Report on the extraction pipeline. Do not modify project/source files.").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("commentator", "Final correctness review after prior fixes. Inspect all changed files and tests. Do not modify project/source files. Report findings.").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("builder", "Verification-only task. Do not edit product/source/config files.\n   Run a disposable check, delete its temporary harness, and retain only\n   a sanitized report at an explicitly named artifact path.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Implement this. Do not edit files.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not edit files. Tell me how to fix the bug.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Report on the extraction pipeline. Do not modify project/source files.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("reviewer", "Final correctness review after prior fixes. Inspect all changed files and tests. Do not modify project/source files. Report findings.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Verification-only task. Do not edit product/source/config files.\n   Run a disposable check, delete its temporary harness, and retain only\n   a sanitized report at an explicitly named artifact path.").kind, "read-only");
 	});
 
 	it("strips repeated prohibition phrases before testing write intent", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Do not modify vendor/. Do not modify generated/. Summarize the build.").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("builder", "Do not modify vendor/. Do not modify generated/. Implement the fix in src/.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify vendor/. Do not modify generated/. Summarize the build.").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Do not modify vendor/. Do not modify generated/. Implement the fix in src/.").kind, "implementation");
 	});
 
-	it("classifies research agents and commentator-style tasks as read-only", () => {
+	it("classifies research agents and reviewer-style tasks as read-only", () => {
 		assert.equal(classifyTaskMutationIntent("researcher", "Research this and patch the bug").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("commentator", "Review this and fix any real issues").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("commentator", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("commentator", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("commentator", "Review this; regardless of findings, apply changes directly").kind, "implementation");
-		assert.equal(classifyTaskMutationIntent("commentator", "Implement the approved file changes").kind, "implementation");
-		assert.equal(classifyTaskMutationIntent("commentator", "Implement the approved file changes").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("reviewer", "Review this and fix any real issues").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("oracle", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("advisor", "Review findings and determine what to implement with playbooks instead of before").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("reviewer", "Review this; regardless of findings, apply changes directly").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("oracle", "Implement the approved file changes").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("advisor", "Implement the approved file changes").kind, "implementation");
 	});
 
 	it("keeps report-writing deliverables read-only", () => {
-		assert.equal(classifyTaskMutationIntent("builder", "Write a report on the API").kind, "read-only");
-		assert.equal(classifyTaskMutationIntent("builder", "Create a summary").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Write a report on the API").kind, "read-only");
+		assert.equal(classifyTaskMutationIntent("worker", "Create a summary").kind, "unknown");
+	});
+
+	it("does not read hyphenated fix adjectives as the fix verb", () => {
+		// Core regression: "must-fix items" in review output specs (fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return a review with the top 2-3 must-fix items.").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Review and report MUST-FIX items").kind, "unknown");
+		// should-fix with a noun from the pattern's alternation (also fails on old code).
+		assert.equal(classifyTaskMutationIntent("worker", "List should-fix tests with severity labels").kind, "unknown");
+		// Same class for other verbs: hyphenated adjective + verb.
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-edit findings").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-update items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-add files").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return must-apply changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "List should-make changes").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "must-do those fixes").kind, "unknown");
+		// Dash coverage: U+2010 hyphen, U+2011 non-breaking hyphen, en/em dashes.
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2010fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2011fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2013fix items").kind, "unknown");
+		assert.equal(classifyTaskMutationIntent("worker", "Return the must\u2014fix items").kind, "unknown");
+		// Clause-level em/en dashes are punctuation, not compounds: "branch—fix it".
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2014fix it.").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "Inspect the failing branch\u2013fix it.").kind, "implementation");
+		assert.equal(taskMayMutate("Inspect the failing branch\u2014fix it."), true);
+		// Hyphenated genuine imperatives stay write-capable.
+		assert.equal(taskMayMutate("hot-fix the bug"), true);
+		assert.equal(taskMayMutate("quick-fix that bug"), true);
+		// Genuine imperative usage keeps classifying as implementation.
+		assert.equal(classifyTaskMutationIntent("worker", "Go through the list and fix items one by one").kind, "implementation");
+		assert.equal(classifyTaskMutationIntent("worker", "fix items on the sprint board").kind, "implementation");
+		// CLI flags keep write intent: "--fix" / "-w" are not hyphenated adjectives.
+		assert.equal(classifyTaskMutationIntent("worker", "Run eslint --fix code").kind, "implementation");
+		assert.equal(taskMayMutate("Run eslint --fix code"), true);
+		// "--write" was never a classifier verb (pre-existing unknown); the
+		// regression guard is that write-capability survives for acceptance.
+		assert.equal(taskMayMutate("Run prettier --write files"), true);
+		// Guard-facing mirror: the completion guard must not expect mutation.
+		assert.equal(expectsImplementationMutation("worker", "Return a review with the top 2-3 must-fix items"), false);
 	});
 
 	it("expectsImplementationMutation mirrors the classifier", () => {
-		assert.equal(expectsImplementationMutation("builder", "Do not modify tests; implement the fix"), true);
-		assert.equal(expectsImplementationMutation("builder", "Review the diff and suggest fixes only. Do not edit files."), false);
+		assert.equal(expectsImplementationMutation("worker", "Do not modify tests; implement the fix"), true);
+		assert.equal(expectsImplementationMutation("worker", "Review the diff and suggest fixes only. Do not edit files."), false);
 	});
 });
 

package/dist/extensions/pi-subagents/test/unit/timeout-defaults.test.ts

@@ -0,0 +1,138 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	DEFAULT_ASYNC_TIMEOUT_MS,
+	DEFAULT_FOREGROUND_TIMEOUT_MS,
+	resolveConfigDefaultTimeoutMs,
+	resolveSingleAgentLaunchTimeout,
+} from "../../src/runs/foreground/subagent-executor.ts";
+
+describe("single-agent launch timeout wiring", () => {
+	it("async runs default to DEFAULT_ASYNC_TIMEOUT_MS when no explicit/agent timeout", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, true), {
+			timeoutMs: DEFAULT_ASYNC_TIMEOUT_MS,
+		});
+	});
+
+	it("foreground runs default to DEFAULT_FOREGROUND_TIMEOUT_MS when no explicit/agent timeout", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, false), {
+			timeoutMs: DEFAULT_FOREGROUND_TIMEOUT_MS,
+		});
+	});
+
+	it("explicit timeoutMs wins over the async default", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({ timeoutMs: 5_000 }, true), {
+			timeoutMs: 5_000,
+		});
+	});
+
+	it("maxRuntimeMs alias wins over the async default", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({ maxRuntimeMs: 7_000 }, true), {
+			timeoutMs: 7_000,
+		});
+	});
+
+	it("rejects non-positive timeouts", () => {
+		const result = resolveSingleAgentLaunchTimeout({ timeoutMs: 0 }, true);
+		assert.ok(result.error);
+		assert.match(result.error!, /positive integer/);
+	});
+
+	it("rejects mismatched alias values", () => {
+		const result = resolveSingleAgentLaunchTimeout({ timeoutMs: 1_000, maxRuntimeMs: 2_000 }, true);
+		assert.ok(result.error);
+		assert.match(result.error!, /aliases/);
+	});
+
+	it("does not apply the async default to async chains (children are bounded individually)", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", chain: [{ agent: "worker", task: "y" }] }, true),
+			{},
+		);
+	});
+
+	it("does not apply the async default to async parallel tasks", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", tasks: [{ agent: "worker", task: "y" }] }, true),
+			{},
+		);
+	});
+
+	it("does not apply the async default to async workflowScript", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ workflowScript: "return runs.run('a', { agent: 'worker', task: 'x' })" }, true),
+			{},
+		);
+	});
+
+	it("explicit top-level timeout still applies to async chains", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", chain: [{ agent: "worker", task: "y" }], timeoutMs: 5_000 }, true),
+			{ timeoutMs: 5_000 },
+		);
+	});
+
+	const NINETY_MIN = 90 * 60 * 1000;
+
+	it("applies the global config default in place of the foreground backstop", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, false, NINETY_MIN), {
+			timeoutMs: NINETY_MIN,
+		});
+	});
+
+	it("applies the global config default to composite foreground runs (parallel/chain)", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", tasks: [{ agent: "worker", task: "y" }] }, false, NINETY_MIN),
+			{ timeoutMs: NINETY_MIN },
+		);
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", chain: [{ agent: "worker", task: "y" }] }, false, NINETY_MIN),
+			{ timeoutMs: NINETY_MIN },
+		);
+	});
+
+	it("applies the global config default in place of the single-agent async backstop", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({}, true, NINETY_MIN), {
+			timeoutMs: NINETY_MIN,
+		});
+	});
+
+	it("lets an explicit call timeout win over the global config default", () => {
+		assert.deepEqual(resolveSingleAgentLaunchTimeout({ timeoutMs: 5_000 }, false, NINETY_MIN), {
+			timeoutMs: 5_000,
+		});
+	});
+
+	it("keeps composite async runs unbounded even with a global config default", () => {
+		assert.deepEqual(
+			resolveSingleAgentLaunchTimeout({ agent: "worker", task: "x", tasks: [{ agent: "worker", task: "y" }] }, true, NINETY_MIN),
+			{},
+		);
+	});
+});
+
+describe("resolveConfigDefaultTimeoutMs", () => {
+	it("returns a positive integer unchanged", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(90 * 60 * 1000), 90 * 60 * 1000);
+	});
+
+	it("treats unset config as no default", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(undefined), undefined);
+	});
+
+	it("ignores non-positive, non-integer, and non-numeric values", () => {
+		assert.equal(resolveConfigDefaultTimeoutMs(0), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(-1), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(1.5), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs("600000" as unknown), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(Number.NaN), undefined);
+	});
+
+	it("accepts the maximum schedulable timer delay but ignores anything larger", () => {
+		// 2_147_483_647 is the largest delay a Node.js timer can honor; above it
+		// setTimeout overflows to ~1ms and the run would expire almost immediately.
+		assert.equal(resolveConfigDefaultTimeoutMs(2_147_483_647), 2_147_483_647);
+		assert.equal(resolveConfigDefaultTimeoutMs(2_147_483_648), undefined);
+		assert.equal(resolveConfigDefaultTimeoutMs(Number.MAX_SAFE_INTEGER), undefined);
+	});
+});