@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/pi-subagents/test/unit/result-files.test.ts

@@ -0,0 +1,175 @@
+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 { describe, it } from "node:test";
+import { cleanupResultIndexes, removeResultIndex, resultCandidateFilesForSession, resultFilesForSession, resultPayloadPathForIndexedRun, resultPayloadPathForSessionRun, writeAsyncResultFile, writePendingAsyncResultFile, writeResultIndexForData } from "../../src/runs/background/result-files.ts";
+
+function pendingPath(resultsDir: string, sessionId: string, runId: string): string {
+	return path.join(resultsDir, "result-pending", encodeURIComponent(sessionId), `${encodeURIComponent(runId)}.json`);
+}
+
+describe("result file indexes", () => {
+	it("removes orphan index entries without deleting flat result files", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-index-"));
+		try {
+			writeAsyncResultFile(path.join(resultsDir, "kept.json"), { id: "kept", runId: "kept", sessionId: "session-a", success: true });
+			writeAsyncResultFile(path.join(resultsDir, "missing.json"), { id: "missing", runId: "missing", sessionId: "session-a", toolCallId: "call-missing", success: true });
+			fs.rmSync(path.join(resultsDir, "missing.json"));
+			fs.writeFileSync(path.join(resultsDir, "unindexed.json"), JSON.stringify({ id: "unindexed", sessionId: "session-a" }), "utf-8");
+
+			assert.equal(cleanupResultIndexes(resultsDir, Date.now() + 86_400_001, 86_400_000), 2);
+
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["kept.json"]);
+			assert.equal(fs.existsSync(path.join(resultsDir, "kept.json")), true);
+			assert.equal(fs.existsSync(path.join(resultsDir, "unindexed.json")), true);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("promotes an indexed pending result payload", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-pending-payload-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const resultPath = path.join(resultsDir, "late.json");
+			fs.mkdirSync(resultPath, { recursive: true });
+
+			assert.deepEqual(writeAsyncResultFile(resultPath, { id: "late", runId: "late", sessionId: "session-a", success: true }), { state: "pending" });
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "late")), true);
+			fs.rmSync(resultPath, { recursive: true, force: true });
+
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["late.json"]);
+			assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf-8")).success, true);
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "late")), false);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("writes an indexed pending result without publishing it", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-pending-only-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const resultPath = path.join(resultsDir, "pending-only.json");
+			fs.mkdirSync(resultPath, { recursive: true });
+
+			writePendingAsyncResultFile(resultPath, { id: "pending-only", runId: "pending-only", sessionId: "session-a", success: true });
+
+			assert.equal(fs.statSync(resultPath).isDirectory(), true);
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), []);
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, "session-a"), ["pending-only.json"]);
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, "session-a", "pending-only"), pendingPath(resultsDir, "session-a", "pending-only"));
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "pending-only"), pendingPath(resultsDir, "session-a", "pending-only"));
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps a legacy valid index while the result payload is not visible yet", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-legacy-late-payload-"));
+		try {
+			const resultPath = path.join(resultsDir, "late.json");
+			writeResultIndexForData(resultPath, { id: "late", runId: "late", sessionId: "session-a", success: true });
+
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), []);
+
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "late", runId: "late", sessionId: "session-a", success: true }), "utf-8");
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["late.json"]);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps an unindexed pending result recoverable when its session index cannot be written", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-index-failure-"));
+		try {
+			fs.writeFileSync(path.join(resultsDir, "result-index"), "not a directory", "utf-8");
+			const resultPath = path.join(resultsDir, "blocked.json");
+
+			assert.throws(() => writeAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", sessionId: "session-a", success: true }));
+			assert.equal(fs.existsSync(resultPath), false);
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "blocked")), true);
+			assert.equal(resultPayloadPathForSessionRun(resultsDir, "session-a", "blocked"), pendingPath(resultsDir, "session-a", "blocked"));
+			assert.equal(resultPayloadPathForIndexedRun(resultsDir, "blocked"), pendingPath(resultsDir, "session-a", "blocked"));
+			assert.deepEqual(resultCandidateFilesForSession(resultsDir, "session-a"), ["blocked.json"]);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("does not commit a result payload without a session id", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-no-session-"));
+		try {
+			const resultPath = path.join(resultsDir, "blocked.json");
+
+			assert.throws(() => writeAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", success: true }), /sessionId/);
+			assert.equal(fs.existsSync(resultPath), false);
+		} finally {
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("prefers pending payload over an older public result", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-pending-wins-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const resultPath = path.join(resultsDir, "blocked.json");
+			writeAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", sessionId: "session-a", success: false });
+			fs.rmSync(resultPath, { force: true });
+			fs.mkdirSync(resultPath, { recursive: true });
+
+			assert.deepEqual(writeAsyncResultFile(resultPath, { id: "blocked", runId: "blocked", sessionId: "session-a", success: true }), { state: "pending" });
+			fs.rmSync(resultPath, { recursive: true, force: true });
+			fs.writeFileSync(resultPath, JSON.stringify({ id: "blocked", runId: "blocked", sessionId: "session-a", success: false }), "utf-8");
+
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["blocked.json"]);
+			assert.equal(JSON.parse(fs.readFileSync(resultPath, "utf-8")).success, true);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("removes pending payloads with result indexes", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-pending-cleanup-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			const resultPath = path.join(resultsDir, "pending-cleanup.json");
+			fs.mkdirSync(resultPath, { recursive: true });
+			writeAsyncResultFile(resultPath, { id: "pending-cleanup", runId: "pending-cleanup", sessionId: "session-a", success: true });
+
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "pending-cleanup")), true);
+			removeResultIndex(resultsDir, "session-a", "pending-cleanup");
+			assert.equal(fs.existsSync(pendingPath(resultsDir, "session-a", "pending-cleanup")), false);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+
+	it("commits a result payload when only an optional index fails", () => {
+		const resultsDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-files-optional-index-"));
+		const originalError = console.error;
+		try {
+			console.error = () => {};
+			fs.mkdirSync(path.join(resultsDir, "result-index"), { recursive: true });
+			fs.writeFileSync(path.join(resultsDir, "result-index", "tool-calls"), "not a directory", "utf-8");
+			const resultPath = path.join(resultsDir, "kept.json");
+
+			writeAsyncResultFile(resultPath, { id: "kept", runId: "kept", sessionId: "session-a", toolCallId: "call-a", success: true });
+
+			assert.equal(fs.existsSync(resultPath), true);
+			assert.deepEqual(resultFilesForSession(resultsDir, "session-a"), ["kept.json"]);
+		} finally {
+			console.error = originalError;
+			fs.rmSync(resultsDir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/retained-children.test.ts

@@ -3,55 +3,165 @@ 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 { listRetainedChildren } from "../../src/runs/background/retained-children.ts";
+import { formatRetainedChildren, listRetainedChildren } from "../../src/runs/background/retained-children.ts";
+import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 
-function writeRetainedRun(root: string, index: number, sessionId = "parent-a", parentWorkflowRunId: string | null = "workflow-a"): void {
+interface WriteRunOptions {
+	sessionId?: string;
+	parentWorkflowRunId?: string | null;
+	state?: "complete" | "failed" | "paused" | "stopped";
+	stepStatus?: "complete" | "completed" | "failed" | "paused" | "stopped";
+	sessionFile?: "present" | "missing" | "omitted";
+	runner?: "external-cli";
+	recoveryDescriptor?: "present" | "missing" | "invalid";
+	recoverySourceRunId?: string;
+	recoveryAgent?: string;
+}
+
+function writeRetainedRun(root: string, index: number, options: WriteRunOptions = {}): void {
 	const runId = `child-${index}`;
 	const sessionFile = path.join(root, "sessions", `${runId}.jsonl`);
-	fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
-	fs.writeFileSync(sessionFile, "", "utf-8");
+	if (options.sessionFile !== "missing" && options.sessionFile !== "omitted") {
+		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+		fs.writeFileSync(sessionFile, "", "utf-8");
+	}
 	const asyncDir = path.join(root, "runs", runId);
 	fs.mkdirSync(asyncDir, { recursive: true });
+	const state = options.state ?? "complete";
+	const stepStatus = options.stepStatus ?? state;
 	fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
 		runId,
-		sessionId,
+		sessionId: options.sessionId ?? "parent-a",
 		mode: "single",
-		state: "complete",
+		state,
 		startedAt: index,
 		endedAt: 1_000 + index,
 		lastUpdate: 1_000 + index,
-		...(parentWorkflowRunId ? { parentWorkflowRunId } : {}),
+		cwd: root,
+		...(options.parentWorkflowRunId === null ? {} : { parentWorkflowRunId: options.parentWorkflowRunId ?? "workflow-a", workflowKey: `lane-${index}` }),
 		steps: [{
 			agent: "worker",
-			status: "complete",
+			status: stepStatus,
 			description: `  Task ${index}  with   spacing ${"x".repeat(140)}  `,
 			endedAt: 1_000 + index,
-			sessionFile,
+			...(options.runner === "external-cli" ? { runner: { type: "external-cli", command: "codex", args: [], promptDelivery: "stdin", capabilities: { stop: true, steer: false, resume: false, structuredOutput: false, toolEvents: false } } } : {}),
+			...(options.sessionFile === "omitted" ? {} : { sessionFile }),
 			tokens: { input: index, output: index + 1, total: index * 2 + 1 },
 		}],
 	}), "utf-8");
+	if (options.recoveryDescriptor === "invalid") {
+		fs.writeFileSync(path.join(asyncDir, "recovery-descriptor.json"), JSON.stringify({
+			version: 2,
+			sourceRunId: runId,
+			agent: "worker",
+			cwd: root,
+			systemPromptMode: "replace",
+			outputMode: "inline",
+		}), "utf-8");
+	} else if (options.recoveryDescriptor !== "missing") {
+		fs.writeFileSync(path.join(asyncDir, "recovery-descriptor.json"), JSON.stringify({
+			version: 1,
+			runFanoutBudget: createRunFanoutBudget(runId, 64),
+			sourceRunId: options.recoverySourceRunId ?? runId,
+			agent: options.recoveryAgent ?? "worker",
+			cwd: root,
+			systemPromptMode: "replace",
+			inheritProjectContext: false,
+			inheritSkills: false,
+			outputMode: "inline",
+			maxSubagentDepth: 2,
+			share: false,
+		}), "utf-8");
+	}
 }
 
 describe("retained child roster", () => {
-	it("returns only the newest 10 completed workflow children owned by the parent session", () => {
+	it("returns terminal workflow children newest first and formats a 10-row roster", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-retained-children-"));
 		try {
 			for (let index = 0; index < 12; index++) writeRetainedRun(root, index);
-			writeRetainedRun(root, 50, "parent-b");
-			writeRetainedRun(root, 51, "parent-a", null);
+			writeRetainedRun(root, 50, { sessionId: "parent-b" });
+			writeRetainedRun(root, 51, { parentWorkflowRunId: null });
+			writeRetainedRun(root, 52, { parentWorkflowRunId: "workflow-failed", state: "failed" });
 
 			const children = listRetainedChildren(path.join(root, "runs"), "parent-a");
+			const formatted = formatRetainedChildren(children);
 
-			assert.equal(children.length, 10);
-			assert.deepEqual(children.map((child) => child.runId), Array.from({ length: 10 }, (_, offset) => `child-${11 - offset}`));
+			assert.equal(children.length, 13);
+			assert.deepEqual(children.map((child) => child.runId), ["child-52", ...Array.from({ length: 12 }, (_, offset) => `child-${11 - offset}`)]);
+			assert.equal(formatted.match(/^- child-/gm)?.length, 10);
+			assert.doesNotMatch(formatted, /^- child-2 /m);
 			assert.equal(children[0]?.agent, "worker");
-			assert.equal(children[0]?.completedAt, 1_011);
+			assert.equal(children[0]?.completedAt, 1_052);
+			assert.equal(children[0]?.state, "failed");
+			assert.equal(children[0]?.parentRunId, "workflow-failed");
+			assert.equal(children[0]?.workflowKey, "lane-52");
 			assert.ok((children[0]?.taskSummary.length ?? 0) <= 120);
-			assert.equal(children[0]?.taskSummary.startsWith("Task 11 with spacing"), true);
-			assert.deepEqual(children[0]?.tokenTotals, { input: 11, output: 12, total: 23 });
+			assert.equal(children[0]?.taskSummary.startsWith("Task 52 with spacing"), true);
+			assert.deepEqual(children[0]?.tokenTotals, { input: 52, output: 53, total: 105 });
+			assert.equal(children[0]?.resumability.state, "resumable");
+			assert.match(formatted, /resumability: resumable\n  session: .*child-52\.jsonl\n  resume: subagent\(\{ action: "resume", id: "child-52", message: "\.\.\." \}\)/);
 			assert.equal(children.some((child) => child.runId === "child-50" || child.runId === "child-51"), false);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
+
+	it("keeps an older resumable child visible behind ten newer non-resumable children", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-retained-children-"));
+		try {
+			writeRetainedRun(root, 0);
+			for (let index = 1; index <= 10; index++) writeRetainedRun(root, index, { recoveryDescriptor: "missing" });
+
+			const children = listRetainedChildren(path.join(root, "runs"), "parent-a");
+			const formatted = formatRetainedChildren(children);
+
+			assert.equal(children.length, 11);
+			assert.deepEqual(children.map((child) => child.runId), Array.from({ length: 11 }, (_, offset) => `child-${10 - offset}`));
+			assert.equal(formatted.match(/^- child-/gm)?.length, 10);
+			assert.match(formatted, /resume: subagent\(\{ action: "resume", id: "child-0"/);
+			assert.doesNotMatch(formatted, /No resumable retained child is listed/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps non-resumable retained children visible with exact reasons", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-retained-children-"));
+		try {
+			writeRetainedRun(root, 1, { sessionFile: "omitted" });
+			writeRetainedRun(root, 2, { sessionFile: "missing" });
+			writeRetainedRun(root, 3, { state: "stopped", stepStatus: "stopped" });
+			writeRetainedRun(root, 4, { runner: "external-cli" });
+			writeRetainedRun(root, 5, { recoveryDescriptor: "missing" });
+			writeRetainedRun(root, 6, { recoveryDescriptor: "invalid" });
+			writeRetainedRun(root, 7, { recoverySourceRunId: "other-run" });
+			writeRetainedRun(root, 8, { recoveryAgent: "reviewer" });
+
+			const children = listRetainedChildren(path.join(root, "runs"), "parent-a");
+			const formatted = formatRetainedChildren(children);
+
+			assert.deepEqual(children.map((child) => [child.runId, child.resumability]), [
+				["child-8", { state: "not-resumable", reason: "recovery descriptor belongs to agent reviewer" }],
+				["child-7", { state: "not-resumable", reason: "recovery descriptor belongs to run other-run" }],
+				["child-6", { state: "not-resumable", reason: `invalid recovery descriptor: Invalid async recovery descriptor '${path.join(root, "runs", "child-6", "recovery-descriptor.json")}': version must be 1.` }],
+				["child-5", { state: "not-resumable", reason: "missing recovery descriptor" }],
+				["child-4", { state: "not-resumable", reason: "external CLI runner" }],
+				["child-3", { state: "not-resumable", reason: "stopped run" }],
+				["child-2", { state: "not-resumable", reason: `persisted session file is missing: ${path.join(root, "sessions", "child-2.jsonl")}` }],
+				["child-1", { state: "not-resumable", reason: "no persisted session file" }],
+			]);
+			assert.match(formatted, /resumability: not resumable \(recovery descriptor belongs to agent reviewer\)/);
+			assert.match(formatted, /resumability: not resumable \(recovery descriptor belongs to run other-run\)/);
+			assert.match(formatted, /resumability: not resumable \(invalid recovery descriptor:/);
+			assert.match(formatted, /resumability: not resumable \(missing recovery descriptor\)/);
+			assert.match(formatted, /resumability: not resumable \(external CLI runner\)/);
+			assert.match(formatted, /resumability: not resumable \(stopped run\)/);
+			assert.match(formatted, /resumability: not resumable \(no persisted session file\)/);
+			assert.doesNotMatch(formatted, /resume: subagent/);
+			assert.match(formatted, /No resumable retained child is listed\. Launch a same-role fallback challenge and label it as fallback\./);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
 });

package/dist/extensions/pi-subagents/test/unit/run-id-resolver.test.ts

@@ -4,6 +4,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import type { SubagentState } from "../../src/shared/types.ts";
+import { releaseActiveRunIndex, updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { resultFilePath, writeAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import { resolveSubagentRunId } from "../../src/runs/background/run-id-resolver.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 
@@ -139,6 +141,48 @@ describe("subagent run id resolver", () => {
 		}
 	});
 
+	it("does not resolve unindexed result files by prefix", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-id-result-prefix-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(resultsDir, { recursive: true });
+			fs.writeFileSync(path.join(resultsDir, "legacy-run.json"), JSON.stringify({ id: "legacy-run", sessionId: "session-a", success: true }), "utf-8");
+
+			const exact = resolveSubagentRunId("legacy-run", { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(exact?.kind, "async");
+			assert.equal(exact?.id, "legacy-run");
+			assert.equal(resolveSubagentRunId("legacy", { asyncDirRoot: asyncRoot, resultsDir }), undefined);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("resolves workflow tool-call ids through active and result indexes", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-resolver-tool-call-index-"));
+		try {
+			const asyncRoot = path.join(root, "async");
+			const resultsDir = path.join(root, "results");
+			const activeDir = path.join(asyncRoot, "workflow-active");
+			fs.mkdirSync(activeDir, { recursive: true });
+			fs.writeFileSync(path.join(activeDir, "status.json"), JSON.stringify({ runId: "workflow-active", toolCallId: "call-active", state: "running", mode: "workflow", startedAt: 1, lastUpdate: 1, steps: [] }), "utf-8");
+			updateActiveRunIndex(activeDir, "running", "call-active");
+
+			const active = resolveSubagentRunId("call-active", { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(active?.kind, "async");
+			assert.equal(active?.id, "workflow-active");
+			releaseActiveRunIndex(activeDir);
+			assert.equal(resolveSubagentRunId("call-active", { asyncDirRoot: asyncRoot, resultsDir }), undefined);
+
+			writeAsyncResultFile(resultFilePath(resultsDir, "workflow-done"), { id: "workflow-done", runId: "workflow-done", toolCallId: "call-done", sessionId: "session-a", state: "complete", success: true });
+			const done = resolveSubagentRunId("call-done", { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(done?.kind, "async");
+			assert.equal(done?.id, "workflow-done");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("rejects unsafe nested id tokens before lookup", () => {
 		assert.throws(() => resolveSubagentRunId("../run"), /safe id token/);
 		assert.throws(() => resolveSubagentRunId("a/b"), /safe id token/);