@selesai/code 0.9.11 → 0.9.12

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

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import { describe, it } from "node:test";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
 import { writeAsyncResultFile } from "../../src/runs/background/result-files.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 import { WAIT_TOOL_ENABLED_ENV, resolveWaitToolConfig, waitForSubagents, type SubagentWaitDeps } from "../../src/runs/background/subagent-wait.ts";
 import { recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 import type { AsyncStatus, SubagentState } from "../../src/shared/types.ts";
@@ -31,6 +32,23 @@ function writeStatus(asyncRoot: string, runId: string, state: AsyncStatus["state
 	updateActiveRunIndex(dir, state);
 }
 
+function writeRecoveryDescriptor(asyncRoot: string, runId: string, agent: string, sessionFile: string, cwd: string): void {
+	fs.writeFileSync(path.join(asyncRoot, runId, "recovery-descriptor.json"), JSON.stringify({
+		version: 1,
+		sourceRunId: runId,
+		agent,
+		sessionFile,
+		cwd,
+		systemPromptMode: "append",
+		outputMode: "inline",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		maxSubagentDepth: 0,
+		share: false,
+		runFanoutBudget: createRunFanoutBudget(runId, 64),
+	}), "utf-8");
+}
+
 function makeState(sessionId: string | null): SubagentState {
 	return {
 		baseCwd: "",
@@ -200,6 +218,7 @@ describe("subagent_wait tool", () => {
 			fs.writeFileSync(sessionFile, "{}\n", "utf-8");
 			const state = makeState("sess-1");
 			writeStatus(asyncRoot, "run-revive", "running", { sessionId: "sess-1", pid: 999999 });
+			writeRecoveryDescriptor(asyncRoot, "run-revive", "worker", sessionFile, root);
 			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
 				sleep: async () => writeStatus(asyncRoot, "run-revive", "failed", {
 					sessionId: "sess-1",
@@ -219,6 +238,52 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("does not advertise resume-first when the recovery descriptor is missing", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-no-recovery-descriptor-"));
+		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-no-descriptor", "running", { sessionId: "sess-1", pid: 999999 });
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => writeStatus(asyncRoot, "run-no-descriptor", "failed", {
+					sessionId: "sess-1",
+					steps: [{ agent: "worker", status: "failed", sessionFile }],
+				}),
+			}));
+
+			assert.equal(result.isError, undefined);
+			assert.doesNotMatch(textOf(result), /Resume-first/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("uses the single-child run session fallback with a matching recovery descriptor", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-run-session-fallback-"));
+		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-session-fallback", "running", { sessionId: "sess-1", pid: 999999 });
+			writeRecoveryDescriptor(asyncRoot, "run-session-fallback", "worker", sessionFile, root);
+			const result = await waitForSubagents({ all: true }, undefined, baseDeps(root, state, {
+				sleep: async () => writeStatus(asyncRoot, "run-session-fallback", "failed", {
+					sessionId: "sess-1",
+					sessionFile,
+					steps: [{ agent: "worker", status: "failed" }],
+				}),
+			}));
+
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /Resume-first/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("tells blocking callers to reply and wait for intercom-detached failed runs", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-intercom-detach-"));
 		try {
@@ -419,6 +484,84 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("can keep blocking through idle attention when stopOnAttention is false", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-tolerant-attn-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-a", "running", { sessionId: "sess-1", pid: 999999 });
+
+			let polls = 0;
+			const sleep = async () => {
+				polls += 1;
+				if (polls === 1) {
+					writeStatus(asyncRoot, "run-a", "running", { sessionId: "sess-1", pid: 999999, activityState: "needs_attention" });
+				}
+				if (polls === 2) writeStatus(asyncRoot, "run-a", "complete", { sessionId: "sess-1" });
+			};
+
+			const result = await waitForSubagents({ all: true, stopOnAttention: false }, undefined, baseDeps(root, state, { sleep }));
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /1 complete/);
+			assert.equal(polls, 2, "tolerant wait should not return on idle attention");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("still stops tolerant waits for supervisor attention", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-tolerant-supervisor-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-a", "running", { sessionId: "sess-1", pid: 999999 });
+
+			let polls = 0;
+			const sleep = async () => {
+				polls += 1;
+				writeStatus(asyncRoot, "run-a", "running", {
+					sessionId: "sess-1",
+					pid: 999999,
+					activityState: "needs_attention",
+					currentTool: "contact_supervisor",
+				});
+			};
+
+			const result = await waitForSubagents({ all: true, stopOnAttention: false }, undefined, baseDeps(root, state, { sleep }));
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /Reply to any pending supervisor request/);
+			assert.match(textOf(result), /run-a/);
+			assert.equal(polls, 1);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("returns an error for internal auto-drain on supervisor attention", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-drain-supervisor-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const state = makeState("sess-1");
+			writeStatus(asyncRoot, "run-a", "running", { sessionId: "sess-1", pid: 999999 });
+
+			const result = await waitForSubagents({ all: true, stopOnAttention: false }, undefined, baseDeps(root, state, {
+				failOnAttention: true,
+				sleep: async () => writeStatus(asyncRoot, "run-a", "running", {
+					sessionId: "sess-1",
+					pid: 999999,
+					activityState: "needs_attention",
+					currentTool: "contact_supervisor",
+				}),
+			}));
+
+			assert.equal(result.isError, true);
+			assert.match(textOf(result), /Reply to any pending supervisor request/);
+			assert.match(textOf(result), /run-a/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("reports runs that already need attention before waiting starts", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-initial-attn-"));
 		try {
@@ -602,6 +745,7 @@ describe("subagent_wait tool", () => {
 						index: 0,
 						status: "detached",
 						activityState: "needs_attention",
+						currentTool: "contact_supervisor",
 						updatedAt: 2,
 					};
 				},
@@ -618,6 +762,45 @@ describe("subagent_wait tool", () => {
 		}
 	});
 
+	it("keeps waiting after a resolved supervisor reply even if idle needs_attention remains", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-foreground-idle-attn-"));
+		try {
+			const state = makeState("sess-1");
+			state.foregroundRuns = new Map([["foreground-working", {
+				runId: "foreground-working",
+				mode: "single",
+				cwd: root,
+				sessionId: "sess-1",
+				updatedAt: 1,
+				children: [{
+					agent: "worker",
+					index: 0,
+					status: "detached",
+					activityState: "needs_attention",
+					updatedAt: 1,
+				}],
+			}]]);
+			let polls = 0;
+			const result = await waitForSubagents({ id: "foreground-working", timeoutMs: 30_000 }, undefined, baseDeps(root, state, {
+				sleep: async () => {
+					polls += 1;
+					state.foregroundRuns!.get("foreground-working")!.children[0] = {
+						agent: "worker",
+						index: 0,
+						status: "completed",
+						updatedAt: 2,
+					};
+				},
+			}));
+
+			assert.equal(result.isError, undefined);
+			assert.match(textOf(result), /done/i);
+			assert.equal(polls, 1);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("wakes a remembered foreground wait on a repeated supervisor request event", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-foreground-supervisor-"));
 		try {
@@ -651,6 +834,7 @@ describe("subagent_wait tool", () => {
 			setTimeout(() => {
 				const child = state.foregroundRuns!.get("foreground-repeated")!.children[0]!;
 				child.activityState = "needs_attention";
+				child.currentTool = "contact_supervisor";
 				events.emit("pi-intercom:detach-request", { runId: "foreground-repeated", childIndex: 0 });
 			}, 15);
 
@@ -743,9 +927,9 @@ describe("subagent_wait tool", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-wait-cross-kind-"));
 		try {
 			const state = makeState("sess-1");
-			writeStatus(path.join(root, "runs"), "shared-async", "running", { sessionId: "sess-1", pid: 999999 });
-			state.foregroundRuns = new Map([["shared-foreground", {
-				runId: "shared-foreground",
+			writeStatus(path.join(root, "runs"), "shared-x-async", "running", { sessionId: "sess-1", pid: 999999 });
+			state.foregroundRuns = new Map([["shared-x-foreground", {
+				runId: "shared-x-foreground",
 				mode: "single",
 				cwd: root,
 				sessionId: "sess-1",
@@ -753,11 +937,11 @@ describe("subagent_wait tool", () => {
 				children: [{ agent: "reviewer", index: 0, status: "detached", updatedAt: 1 }],
 			}]]);
 
-			const result = await waitForSubagents({ id: "shared" }, undefined, baseDeps(root, state));
+			const result = await waitForSubagents({ id: "shared-x" }, undefined, baseDeps(root, state));
 			assert.equal(result.isError, true);
-			assert.match(textOf(result), /Ambiguous subagent run id prefix "shared"/);
-			assert.match(textOf(result), /shared-async/);
-			assert.match(textOf(result), /shared-foreground/);
+			assert.match(textOf(result), /Ambiguous subagent run id prefix "shared-x"/);
+			assert.match(textOf(result), /shared-x-async/);
+			assert.match(textOf(result), /shared-x-foreground/);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -768,15 +952,15 @@ describe("subagent_wait tool", () => {
 		try {
 			const asyncRoot = path.join(root, "runs");
 			const state = makeState("sess-1");
-			writeStatus(asyncRoot, "run-al", "running", { sessionId: "sess-2", pid: 999999 });
-			writeStatus(asyncRoot, "run-alpha", "running", { sessionId: "sess-1", pid: 999998 });
+			writeStatus(asyncRoot, "run-alph", "running", { sessionId: "sess-2", pid: 999999 });
+			writeStatus(asyncRoot, "run-alpha-current", "running", { sessionId: "sess-1", pid: 999998 });
 
-			const result = await waitForSubagents({ id: "run-al" }, undefined, baseDeps(root, state, {
-				sleep: async () => writeStatus(asyncRoot, "run-alpha", "complete", { sessionId: "sess-1" }),
+			const result = await waitForSubagents({ id: "run-alph" }, undefined, baseDeps(root, state, {
+				sleep: async () => writeStatus(asyncRoot, "run-alpha-current", "complete", { sessionId: "sess-1" }),
 			}));
 
 			assert.equal(result.isError, undefined);
-			assert.match(textOf(result), /run "run-al".*done/is);
+			assert.match(textOf(result), /run "run-alph".*done/is);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -856,9 +1040,9 @@ describe("subagent_wait tool", () => {
 				if (polls === 1) writeStatus(asyncRoot, "run-alpha", "complete", { sessionId: "sess-1" });
 			};
 
-			const result = await waitForSubagents({ id: "run-al" }, undefined, baseDeps(root, state, { sleep }));
+			const result = await waitForSubagents({ id: "run-alph" }, undefined, baseDeps(root, state, { sleep }));
 			assert.equal(result.isError, undefined);
-			assert.match(textOf(result), /run "run-al".*done/is);
+			assert.match(textOf(result), /run "run-alph".*done/is);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -869,13 +1053,14 @@ describe("subagent_wait tool", () => {
 		try {
 			const asyncRoot = path.join(root, "runs");
 			const state = makeState("sess-1");
-			writeStatus(asyncRoot, "run", "running", { sessionId: "sess-1", pid: 999999 });
-			writeStatus(asyncRoot, "run-alpha", "running", { sessionId: "sess-1", pid: 999998 });
+			writeStatus(asyncRoot, "prefix-aa-1", "running", { sessionId: "sess-1", pid: 999999 });
+			writeStatus(asyncRoot, "prefix-aa-2", "running", { sessionId: "sess-1", pid: 999998 });
+			writeStatus(asyncRoot, "run", "running", { sessionId: "sess-1", pid: 999997 });
 
-			const ambiguous = await waitForSubagents({ id: "ru" }, undefined, baseDeps(root, state));
+			const ambiguous = await waitForSubagents({ id: "prefix-aa" }, undefined, baseDeps(root, state));
 			assert.equal(ambiguous.isError, true);
-			assert.match(textOf(ambiguous), /Ambiguous subagent run id prefix "ru"/);
-			assert.match(textOf(ambiguous), /run-alpha/);
+			assert.match(textOf(ambiguous), /Ambiguous subagent run id prefix "prefix-aa"/);
+			assert.match(textOf(ambiguous), /prefix-aa-2/);
 
 			let polls = 0;
 			const exact = await waitForSubagents({ id: "run" }, undefined, baseDeps(root, state, {

package/dist/extensions/pi-subagents/test/unit/temp-paths.test.ts

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
+import { spawnSync } from "node:child_process";
 import { describe, it } from "node:test";
 import {
 	ASYNC_DIR,
@@ -53,6 +56,28 @@ describe("resolveTempScopeId", () => {
 });
 
 describe("shared temp paths", () => {
+	it("uses the explicit temp root before shared paths resolve", () => {
+		const fixture = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-temp-override-"));
+		const override = path.join(fixture, "async state");
+		const isolatedHome = path.join(fixture, "home");
+		try {
+			const moduleUrl = new URL("../../src/shared/types.ts", import.meta.url).href;
+			const script = `import { ASYNC_DIR, RESULTS_DIR, TEMP_ROOT_DIR } from ${JSON.stringify(moduleUrl)}; console.log(JSON.stringify({ ASYNC_DIR, RESULTS_DIR, TEMP_ROOT_DIR }));`;
+			const result = spawnSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "--eval", script], {
+				encoding: "utf-8",
+				env: { ...process.env, HOME: isolatedHome, USERPROFILE: isolatedHome, SELESAI_SUBAGENTS_TEMP_ROOT: override },
+			});
+			assert.equal(result.status, 0, result.stderr);
+			assert.deepEqual(JSON.parse(result.stdout.trim()), {
+				ASYNC_DIR: path.join(override, "async-subagent-runs"),
+				RESULTS_DIR: path.join(override, "async-subagent-results"),
+				TEMP_ROOT_DIR: override,
+			});
+		} finally {
+			fs.rmSync(fixture, { recursive: true, force: true });
+		}
+	});
+
 	it("anchors shared temp directories under one scoped root", () => {
 		assert.equal(path.dirname(RESULTS_DIR), TEMP_ROOT_DIR);
 		assert.equal(path.dirname(ASYNC_DIR), TEMP_ROOT_DIR);

package/dist/extensions/pi-subagents/test/unit/thinking-ceiling.test.ts

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { discoverAgents } from "../../src/agents/agents.ts";
+import { assertThinkingWithinCeiling, compareThinkingLevels, intersectThinkingCeilings, parseThinkingLevel } from "../../src/shared/thinking-ceiling.ts";
+
+let home = "";
+let project = "";
+const previousHome = process.env.HOME;
+const previousUserProfile = process.env.USERPROFILE;
+const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+
+function writeJson(filePath: string, value: unknown): void {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value), "utf-8");
+}
+
+describe("thinking ceilings", () => {
+	beforeEach(() => {
+		home = fs.mkdtempSync(path.join(os.tmpdir(), "pi-thinking-ceiling-home-"));
+		project = fs.mkdtempSync(path.join(os.tmpdir(), "pi-thinking-ceiling-project-"));
+		process.env.HOME = home;
+		process.env.USERPROFILE = home;
+		delete process.env.SELESAI_CODING_AGENT_DIR;
+	});
+
+	afterEach(() => {
+		if (previousHome === undefined) delete process.env.HOME; else process.env.HOME = previousHome;
+		if (previousUserProfile === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = previousUserProfile;
+		if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR; else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+		fs.rmSync(home, { recursive: true, force: true });
+		fs.rmSync(project, { recursive: true, force: true });
+	});
+
+	it("orders every supported level and rejects malformed ceilings", () => {
+		const levels = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+		for (let index = 0; index < levels.length; index++) {
+			assert.equal(parseThinkingLevel(levels[index]), levels[index]);
+			if (index > 0) assert.ok(compareThinkingLevels(levels[index - 1], levels[index]) < 0);
+		}
+		assert.throws(() => parseThinkingLevel("turbo"), /expected one of/);
+	});
+
+	it("intersects inherited ceilings and validates concrete model suffixes", () => {
+		assert.equal(intersectThinkingCeilings("xhigh", "high"), "high");
+		assert.equal(intersectThinkingCeilings("low", "xhigh"), "low");
+		assert.doesNotThrow(() => assertThinkingWithinCeiling({ model: "test/model:xhigh", ceiling: "xhigh", agent: "worker" }));
+		assert.throws(
+			() => assertThinkingWithinCeiling({ model: "test/model:max", ceiling: "xhigh", agent: "worker", runId: "run-1" }),
+			/Thinking level 'max'.*maximum 'xhigh'.*worker.*run-1/,
+		);
+		assert.doesNotThrow(() => assertThinkingWithinCeiling({ model: "test/model", configThinking: false, ceiling: "off" }));
+	});
+
+	it("loads maxThinking with project precedence and attaches it to discovered agents", () => {
+		writeJson(path.join(home, ".selesai", "agent", "settings.json"), { subagents: { maxThinking: "max" } });
+		fs.mkdirSync(path.join(project, ".selesai"), { recursive: true });
+		writeJson(path.join(project, ".selesai", "settings.json"), { subagents: { maxThinking: "xhigh" } });
+		const discovered = discoverAgents(project, "both");
+		assert.equal(discovered.maxThinking, "xhigh");
+		assert.equal(discovered.agents.find((agent) => agent.name === "worker")?.maxThinking, "xhigh");
+	});
+
+	it("fails closed for invalid maxThinking settings", () => {
+		const settingsPath = path.join(home, ".selesai", "agent", "settings.json");
+		for (const value of ["", "turbo", 42, false]) {
+			writeJson(settingsPath, { subagents: { maxThinking: value } });
+			assert.throws(() => discoverAgents(project, "both"), (error: unknown) => error instanceof Error && error.message.includes(settingsPath) && error.message.includes("maxThinking"));
+		}
+	});
+});