@selesai/code 0.9.11 → 0.9.12

package/dist/extensions/pi-subagents/test/unit/capacity-resilient-json.test.ts

@@ -0,0 +1,155 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createCapacityResilientJsonWriter } from "../../src/shared/capacity-resilient-json.ts";
+
+type TimerTask = { callback: () => void; delayMs: number };
+
+function createTimers() {
+	const tasks: TimerTask[] = [];
+	return {
+		timerApi: {
+			setTimeout(callback: () => void, delayMs: number): object {
+				const timer = { callback, delayMs };
+				tasks.push(timer);
+				return timer;
+			},
+			clearTimeout(timer: unknown): void {
+				const index = tasks.indexOf(timer as TimerTask);
+				if (index >= 0) tasks.splice(index, 1);
+			},
+		},
+		runNext(): void {
+			const timer = tasks.shift();
+			if (timer) timer.callback();
+		},
+		pendingCount: () => tasks.length,
+	};
+}
+
+function capacityError(code: string): NodeJS.ErrnoException {
+	return Object.assign(new Error(code), { code });
+}
+
+describe("createCapacityResilientJsonWriter", () => {
+	it("retains only the latest payload and retries after capacity recovers", () => {
+		const timers = createTimers();
+		const writes: object[] = [];
+		let available = false;
+		const writer = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			retryDelayMs: 25,
+			write: (_filePath, payload) => {
+				if (!available) throw capacityError("ENOSPC");
+				writes.push(payload);
+			},
+		});
+
+		writer.write("status.json", { state: "running" });
+		writer.write("status.json", { state: "complete" });
+		assert.equal(writer.pendingCount(), 1);
+		assert.equal(timers.pendingCount(), 1);
+		available = true;
+		timers.runNext();
+
+		assert.deepEqual(writes, [{ state: "complete" }]);
+		assert.equal(writer.pendingCount(), 0);
+		assert.equal(timers.pendingCount(), 0);
+	});
+
+	it("handles every storage-capacity code without escaping the retry timer", () => {
+		for (const code of ["ENOSPC", "EDQUOT", "EMFILE", "ENFILE"]) {
+			const timers = createTimers();
+			let attempts = 0;
+			let available = false;
+			const writer = createCapacityResilientJsonWriter({
+				timerApi: timers.timerApi,
+				write: () => {
+					attempts += 1;
+					if (!available) throw capacityError(code);
+				},
+			});
+			writer.write("status.json", { state: "running" });
+			assert.doesNotThrow(() => timers.runNext());
+			assert.equal(attempts, 2);
+			available = true;
+			timers.runNext();
+			assert.equal(writer.pendingCount(), 0);
+		}
+	});
+
+	it("preserves synchronous throwing for non-capacity failures", () => {
+		const writer = createCapacityResilientJsonWriter({ write: () => { throw new Error("invalid path"); } });
+		assert.throws(() => writer.write("status.json", {}), /invalid path/);
+	});
+
+	it("does not let error callbacks escape a retry timer", () => {
+		const timers = createTimers();
+		const writer = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			onError: () => { throw new Error("reporting failed"); },
+			write: (filePath) => {
+				if (filePath === "status.json") throw capacityError("ENOSPC");
+			},
+		});
+		writer.write("status.json", { state: "running" });
+		assert.doesNotThrow(() => timers.runNext());
+		assert.equal(writer.pendingCount(), 1);
+		writer.dispose();
+	});
+
+	it("notifies only after a write succeeds, including a deferred retry", () => {
+		const timers = createTimers();
+		const successfulPayloads: object[] = [];
+		let available = false;
+		const writer = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			onSuccess: (_filePath, payload) => successfulPayloads.push(payload),
+			write: () => { if (!available) throw capacityError("ENOSPC"); },
+		});
+		writer.write("status.json", { state: "running" });
+		assert.deepEqual(successfulPayloads, []);
+		available = true;
+		timers.runNext();
+		assert.deepEqual(successfulPayloads, [{ state: "running" }]);
+	});
+
+	it("orders deferred index work after authoritative status recovery", () => {
+		const timers = createTimers();
+		let statusAvailable = false;
+		let indexUpdates = 0;
+		const indexWriter = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			write: () => { indexUpdates += 1; },
+		});
+		const statusWriter = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			onSuccess: () => indexWriter.write("run", { state: "complete" }),
+			write: () => { if (!statusAvailable) throw capacityError("ENOSPC"); },
+		});
+		statusWriter.write("status", { state: "complete" });
+		assert.equal(indexUpdates, 0);
+		statusAvailable = true;
+		timers.runNext();
+		assert.equal(indexUpdates, 1);
+		statusWriter.dispose();
+		indexWriter.dispose();
+	});
+
+	it("reports non-capacity failures from a retry without throwing from the timer", () => {
+		const timers = createTimers();
+		const errors: unknown[] = [];
+		let attempts = 0;
+		const writer = createCapacityResilientJsonWriter({
+			timerApi: timers.timerApi,
+			onError: (error) => errors.push(error),
+			write: () => {
+				if (attempts++ === 0) throw capacityError("ENOSPC");
+				throw new Error("permission denied");
+			},
+		});
+		assert.doesNotThrow(() => writer.write("status.json", { state: "running" }));
+		assert.doesNotThrow(() => timers.runNext());
+		assert.equal(errors.length, 1);
+		assert.match(String(errors[0]), /permission denied/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/compaction-resume.test.ts

@@ -32,7 +32,7 @@ describe("async compaction resume", () => {
 			renders = 0;
 			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
 			const cleared = widgets.filter(([key, value]) => value === undefined).map(([key]) => key).sort();
-			if (JSON.stringify(cleared) !== JSON.stringify(["subagent-async"])) throw new Error(JSON.stringify(widgets));
+			if (JSON.stringify(cleared) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
 			widgets.length = 0;
 			events.emit("subagent:async-complete", { id: "running", sessionId: "compact-session", agent: "worker", success: true, summary: "done" });
 			events.emit("subagent:async-started", { id: "running-2", pid: 2, sessionId: "compact-session", mode: "single", agent: "worker", asyncDir: path.join(os.tmpdir(), "pi-compaction-test-running-2") });
@@ -41,7 +41,7 @@ describe("async compaction resume", () => {
 			if (widgets.length !== 0) throw new Error("widgets restored inside compaction hook");
 			handlers.get("agent_start")();
 			const restored = widgets.filter(([_, value]) => value !== undefined).map(([key]) => key).sort();
-			if (JSON.stringify(restored) !== JSON.stringify(["subagent-async"])) throw new Error(JSON.stringify(widgets));
+			if (JSON.stringify(restored) !== JSON.stringify(["subagent-async", "subagent-fleet-status"])) throw new Error(JSON.stringify(widgets));
 			if (sent.length !== 1 || sent[0].options?.triggerTurn !== true || sent[0].message?.customType !== "subagent-compaction-resume") throw new Error(JSON.stringify(sent));
 
 			sent.length = 0;

package/dist/extensions/pi-subagents/test/unit/completion-dedupe.test.ts

@@ -10,6 +10,13 @@ describe("buildCompletionKey", () => {
 		assert.notEqual(first, second);
 	});
 
+	it("treats paused and complete payloads as distinct completions", () => {
+		const paused = buildCompletionKey({ id: "run-123", sessionId: "session-a", state: "paused" }, "fallback");
+		const complete = buildCompletionKey({ id: "run-123", sessionId: "session-a", state: "complete" }, "fallback");
+		assert.equal(paused, "session:session-a:id:run-123:state:paused");
+		assert.notEqual(paused, complete);
+	});
+
 	it("builds deterministic fallback key when id is missing", () => {
 		const first = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");
 		const second = buildCompletionKey({ agent: "reviewer", timestamp: 123, taskIndex: 1, totalTasks: 2, success: true }, "x");

package/dist/extensions/pi-subagents/test/unit/completion-guard.test.ts

@@ -7,6 +7,7 @@ import {
 	evaluateCompletionMutationGuard,
 	expectsImplementationMutation,
 	hasMutationToolCall,
+	validateImplementationToolContract,
 } from "../../src/runs/shared/completion-guard.ts";
 import { isMutatingTool } from "../../src/runs/shared/long-running-guard.ts";
 
@@ -39,6 +40,7 @@ test("implementation task with no mutation triggers the completion guard", () =>
 			expectedMutation: true,
 			attemptedMutation: false,
 			triggered: true,
+			blocked: false,
 		});
 	}
 });
@@ -102,6 +104,7 @@ test("implementation challenges may complete with explicit no-change reports", (
 			expectedMutation: true,
 			attemptedMutation: false,
 			triggered: false,
+			blocked: false,
 		});
 	}
 });
@@ -203,6 +206,7 @@ test("revived implementation tasks that mention implementation challenge remain
 			expectedMutation: true,
 			attemptedMutation: false,
 			triggered: true,
+			blocked: false,
 		}, followUp);
 	}
 });
@@ -249,6 +253,7 @@ test("declared read-only builtin tools suppress implementation-word false positi
 		expectedMutation: false,
 		attemptedMutation: false,
 		triggered: false,
+		blocked: false,
 	});
 });
 
@@ -263,6 +268,7 @@ test("hyphenated fix adjectives in review tasks do not trigger the completion gu
 		expectedMutation: false,
 		attemptedMutation: false,
 		triggered: false,
+		blocked: false,
 	});
 	assert.equal(
 		expectsImplementationMutation("worker", "Return a review with the top 2-3 must-fix items."),
@@ -283,6 +289,7 @@ test("read-only issue drafting tasks do not trigger on suggested fix wording", (
 		expectedMutation: false,
 		attemptedMutation: false,
 		triggered: false,
+		blocked: false,
 	});
 	assert.equal(expectsImplementationMutation("worker", task), false);
 	assert.equal(
@@ -318,9 +325,66 @@ test("worker with mutating-capable tools still triggers when no mutation is obse
 		expectedMutation: true,
 		attemptedMutation: false,
 		triggered: true,
+		blocked: false,
 	});
 });
 
+test("missing child tools block mutation effects instead of triggering no-edit blame", () => {
+	const result = evaluateCompletionMutationGuard({
+		agent: "worker",
+		task: "Implement the requested source fix",
+		messages: [assistantText("I cannot edit because tools are missing.")],
+		tools: ["read", "fixture_search"],
+		toolAvailabilityError: "Agent 'worker' requested unavailable child tools: fixture_search.",
+	});
+
+	assert.deepEqual(result, {
+		expectedMutation: true,
+		attemptedMutation: false,
+		triggered: false,
+		blocked: true,
+		message: "Agent 'worker' requested unavailable child tools: fixture_search.",
+	});
+});
+
+test("implementation tool contract rejects read-only worker launches", () => {
+	assert.match(
+		validateImplementationToolContract({
+			agent: "worker",
+			task: "Implement the requested source fix",
+			tools: ["read", "grep", "find", "ls", "contact_supervisor"],
+		}) ?? "",
+		/no mutation-capable tools/,
+	);
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Review only and return findings",
+		tools: ["read", "grep", "find", "ls"],
+	}), undefined);
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Implement the requested source fix",
+		tools: ["read", "edit"],
+	}), undefined);
+	assert.match(
+		validateImplementationToolContract({
+			agent: "worker",
+			task: "Implement the requested source fix",
+			tools: ["read", "structured_output"],
+		}) ?? "",
+		/no mutation-capable tools/,
+	);
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Implement the requested source fix",
+		tools: ["read", "/tmp/mutation-tools.ts"],
+	}), undefined);
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Implement the requested source fix",
+	}), undefined);
+});
+
 test("oracle review tasks with bash available do not require mutation", () => {
 	const task = "Review prep findings and determine what to implement with playbooks instead of before.";
 	const result = evaluateCompletionMutationGuard({
@@ -334,6 +398,7 @@ test("oracle review tasks with bash available do not require mutation", () => {
 		expectedMutation: false,
 		attemptedMutation: false,
 		triggered: false,
+		blocked: false,
 	});
 });
 
@@ -567,5 +632,63 @@ test("implementation task with Cursor edit thinking does not trigger", () => {
 		expectedMutation: true,
 		attemptedMutation: true,
 		triggered: false,
+		blocked: false,
 	});
 });
+
+test("writer-role tasks with unknown implementation wording reject read-only launch tools", () => {
+	for (const task of [
+		"Address issue #1371 end-to-end: land the fix with tests.",
+		"Resolve backlog item #1371. Land the change and open a PR.",
+		"Work issue #1371. Ship the feature, run the test suite, and report back.",
+	]) {
+		assert.match(validateImplementationToolContract({
+			agent: "worker",
+			task,
+			tools: ["read", "grep", "find", "ls", "contact_supervisor"],
+			requestedTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+		}), /no mutation-capable tools/, task);
+	}
+});
+
+test("configured extensions do not rescue clamped-away builtin mutation tools", () => {
+	assert.match(validateImplementationToolContract({
+		agent: "worker",
+		task: "Fix the lane-owned workflowScript launch so writer children get mutation tools.",
+		tools: ["read", "grep", "find", "ls", "contact_supervisor"],
+		configuredExtensions: ["/tmp/provider.ts"],
+		requestedTools: ["read", "grep", "find", "ls", "bash", "edit", "write", "contact_supervisor"],
+	}), /no mutation-capable tools/);
+});
+
+test("read-only agents and pure extension workers keep their launch contracts", () => {
+	assert.equal(validateImplementationToolContract({
+		agent: "reviewer",
+		task: "Review the diff and return findings only.",
+		tools: ["read", "grep", "find", "ls", "contact_supervisor"],
+		acceptanceRole: "read-only",
+	}), undefined);
+
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Implement the requested source fix.",
+		tools: ["read", "grep", "find", "ls", "contact_supervisor"],
+		configuredExtensions: ["/tmp/mutation-extension.ts"],
+		requestedTools: ["read", "grep", "find", "ls", "contact_supervisor"],
+	}), undefined);
+
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Task",
+		tools: ["read"],
+		requestedTools: ["read"],
+	}), undefined);
+
+	assert.equal(validateImplementationToolContract({
+		agent: "worker",
+		task: "Summarize the fix",
+		tools: ["read"],
+		requestedTools: ["read"],
+		completionGuard: false,
+	}), undefined);
+});

package/dist/extensions/pi-subagents/test/unit/completion-replay.test.ts

@@ -7,6 +7,7 @@ import { describe, it } from "node:test";
 import { cleanupCompletionReplay, completionArchivePath, completionReplayPath, readCompletionArchive, readCompletionReplay, writeCompletionReplay, writeCompletionArchive } from "../../src/runs/background/completion-replay.ts";
 import { utf8Tail } from "../../src/shared/utf8.ts";
 import { collectWaitCompletions, recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
+import { writeAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import type { AsyncRunSummary } from "../../src/runs/background/async-status.ts";
 import type { SubagentState } from "../../src/shared/types.ts";
 
@@ -40,24 +41,99 @@ describe("completion replay", () => {
 				mode: "single",
 				state: "complete",
 				success: true,
-				results: [{ agent: "worker", success: true, outputState: "present", output: "finished output" }],
+				results: [{ agent: "worker", success: true, outputState: "present", output: "finished output", contextOverflow: true }],
 			}, now, 60_000, { resultsDir, sessionId: "session-a" });
 
 			const replay = readCompletionReplay(resultsDir, "run-a", { sessionId: "session-a", now: now + 1 });
 			assert.equal(replay?.version, 1);
 			assert.equal(replay?.completion.archivePath, replay?.archivePath);
-			assert.equal(readCompletionArchive(replay!.archivePath)?.entries[0]?.text, "[worker]\nfinished output");
+			assert.deepEqual(readCompletionArchive(replay!.archivePath)?.entries[0], {
+				agent: "worker",
+				resultIndex: 0,
+				source: "result-tail",
+				text: "finished output",
+			});
 
 			const terminal = [{ id: "run-a", sessionId: "session-a" }] as AsyncRunSummary[];
 			const completions = collectWaitCompletions(terminal, makeState(), resultsDir);
 			assert.equal(completions?.[0]?.runId, "run-a");
 			assert.equal(completions?.[0]?.results?.[0]?.agent, "worker");
+			assert.equal(completions?.[0]?.results?.[0]?.contextOverflow, true);
 			assert.equal(completions?.[0]?.archivePath, replay?.archivePath);
 		} finally {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
 
+	it("surfaces pending completions when the direct session index is temporarily inaccessible", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-index-denied-"));
+		const originalReadFileSync = fsCjs.readFileSync;
+		try {
+			const publicPath = path.join(resultsDir, "run-pending.json");
+			fs.mkdirSync(publicPath, { recursive: true });
+			writeAsyncResultFile(publicPath, {
+				id: "run-pending",
+				runId: "run-pending",
+				sessionId: "session-a",
+				agent: "worker",
+				success: true,
+				results: [{ agent: "worker", success: true, outputState: "present" }],
+			});
+			fsCjs.readFileSync = ((file, ...args) => {
+				if (String(file).includes(`${path.sep}result-index${path.sep}`)) {
+					const error = new Error("permission denied") as NodeJS.ErrnoException;
+					error.code = "EACCES";
+					throw error;
+				}
+				return originalReadFileSync(file, ...args);
+			}) as typeof fsCjs.readFileSync;
+			syncBuiltinESMExports();
+
+			const terminal = [{ id: "run-pending", sessionId: "session-a" }] as AsyncRunSummary[];
+			const completions = collectWaitCompletions(terminal, makeState(), resultsDir);
+			assert.equal(completions?.[0]?.runId, "run-pending");
+			assert.equal(completions?.[0]?.results?.[0]?.agent, "worker");
+		} finally {
+			fsCjs.readFileSync = originalReadFileSync;
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("surfaces malformed pending payload errors when the direct session index is inaccessible", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-index-denied-malformed-"));
+		const originalReadFileSync = fsCjs.readFileSync;
+		try {
+			const publicPath = path.join(resultsDir, "run-pending.json");
+			fs.mkdirSync(publicPath, { recursive: true });
+			writeAsyncResultFile(publicPath, {
+				id: "run-pending",
+				runId: "run-pending",
+				sessionId: "session-a",
+				success: true,
+			});
+			fs.rmSync(publicPath, { recursive: true, force: true });
+			const pendingDir = path.join(resultsDir, "result-pending", encodeURIComponent("session-a"));
+			fs.writeFileSync(path.join(pendingDir, "run-pending.json"), "{", "utf-8");
+			fsCjs.readFileSync = ((file, ...args) => {
+				if (String(file).includes(`${path.sep}result-index${path.sep}`)) {
+					const error = new Error("permission denied") as NodeJS.ErrnoException;
+					error.code = "EACCES";
+					throw error;
+				}
+				return originalReadFileSync(file, ...args);
+			}) as typeof fsCjs.readFileSync;
+			syncBuiltinESMExports();
+
+			const terminal = [{ id: "run-pending", sessionId: "session-a" }] as AsyncRunSummary[];
+			assert.throws(() => collectWaitCompletions(terminal, makeState(), resultsDir), /Failed to read/);
+		} finally {
+			fsCjs.readFileSync = originalReadFileSync;
+			syncBuiltinESMExports();
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
 	it("keeps UTF-8 tails valid at multibyte boundaries", () => {
 		const bounded = utf8Tail(`start-${"é".repeat(10)}-tail`, 9);
 		assert.equal(bounded.truncated, true);
@@ -213,9 +289,11 @@ describe("completion replay", () => {
 				],
 			}, Date.now());
 			const archive = readCompletionArchive(archivePath);
-			assert.deepEqual(archive?.entries[0], { agent: "saved", source: "output-artifact", path: savedOutput });
+			assert.deepEqual(archive?.entries[0], { agent: "saved", resultIndex: 0, source: "output-artifact", path: savedOutput });
 			const fallback = archive?.entries[1];
 			assert.equal(fallback?.source, "result-tail");
+			assert.equal(fallback?.agent, "fallback");
+			assert.equal(fallback?.resultIndex, 1);
 			assert.equal(fallback?.truncated, true);
 			assert.ok(Buffer.byteLength(fallback?.text ?? "", "utf-8") <= 64 * 1024);
 			assert.match(fallback?.text ?? "", /-tail$/);