@selesai/code 0.8.6 → 0.8.7

package/dist/extensions/pi-subagents/test/unit/pi-coding-agent-dir.test.ts

@@ -214,6 +214,7 @@ Package skill content.
 	it("resolves configured artifact directory preferences", () => {
 		const sessionFile = path.join(agentDir, "sessions", "session-1", "session.jsonl");
 
+		// Selesai fork default: project-scoped .pi-subagents artifacts.
 		assert.equal(getArtifactsDir(sessionFile, cwd), getProjectArtifactsDir(cwd));
 		assert.equal(getArtifactsDir(sessionFile, cwd, "project"), getProjectArtifactsDir(cwd));
 		assert.equal(getArtifactsDir(sessionFile, cwd, "session"), path.join(path.dirname(sessionFile), "subagent-artifacts"));
@@ -241,6 +242,39 @@ Package skill content.
 		assert.throws(() => updateConfig((config) => config), /config\.fleetKeybindings\.pageUp entries must be non-empty strings/);
 	});
 
+	it("loads and validates the foreground detach shortcut", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ foregroundDetachShortcut: "ctrl+b" }));
+		assert.equal(loadConfig().foregroundDetachShortcut, "ctrl+b");
+
+		writeFile(configPath, JSON.stringify({ foregroundDetachShortcut: "banana" }));
+		assert.throws(() => updateConfig((config) => config), /config\.foregroundDetachShortcut must be a valid keybinding string/);
+	});
+
+	it("loads and validates main-window renderer density config", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { horizontalSpacing: 0, compactResultMaxLines: 4 } }));
+		assert.deepEqual(loadConfig().mainWindowRenderer, { horizontalSpacing: 0, compactResultMaxLines: 4 });
+
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { horizontalSpacing: -1 } }));
+		assert.throws(() => updateConfig((config) => config), /config\.mainWindowRenderer\.horizontalSpacing must be an integer from 0 to 4/);
+
+		writeFile(configPath, JSON.stringify({ mainWindowRenderer: { compactResultMaxLines: 0 } }));
+		assert.throws(() => updateConfig((config) => config), /config\.mainWindowRenderer\.compactResultMaxLines must be a positive integer/);
+	});
+
+	it("loads and validates experimental Orca progress-tab config", () => {
+		const configPath = path.join(agentDir, "extensions", "subagent", "config.json");
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: true } }));
+		assert.deepEqual(loadConfig().orcaProgressTabs, { enabled: true });
+
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: "yes" } }));
+		assert.throws(() => updateConfig((config) => config), /config\.orcaProgressTabs\.enabled must be a boolean/);
+
+		writeFile(configPath, JSON.stringify({ orcaProgressTabs: { enabled: true, focus: true } }));
+		assert.throws(() => updateConfig((config) => config), /config\.orcaProgressTabs\.focus is not supported/);
+	});
+
 	it("hardens and redacts existing run history while recording", () => {
 		const historyPath = path.join(agentDir, "run-history.jsonl");
 		fs.mkdirSync(agentDir, { recursive: true, mode: 0o755 });

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -5,7 +5,12 @@ import { normalizePublicSubagentExecution } from "../../src/extension/public-exe
 describe("public subagent execution normalization", () => {
 	it("accepts all four execution modes, management, and direct-field schedules", () => {
 		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
-		assert.deepEqual(normalizePublicSubagentExecution({ agent: "worker", task: "work" }), { ok: true, params: { agent: "worker", task: "work" } });
+		const single = normalizePublicSubagentExecution({ agent: "worker", task: "work" });
+		assert.equal(single.ok, true);
+		if (single.ok) {
+			assert.equal(typeof (single.params as { workflowScript?: unknown }).workflowScript, "string");
+			assert.match((single.params as { workflowScript: string }).workflowScript, /runs\.run\("main", \{"agent":"worker","task":"work","output":true\}\)/);
+		}
 		assert.deepEqual(normalizePublicSubagentExecution({ tasks: [{ agent: "worker" }] }), { ok: true, params: { tasks: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ chain: [{ agent: "worker" }] }), { ok: true, params: { chain: [{ agent: "worker" }] } });
 		assert.deepEqual(normalizePublicSubagentExecution({ action: " list " }), { ok: true, params: { action: "list" } });

package/dist/extensions/pi-subagents/test/unit/render-helpers.test.ts

@@ -80,6 +80,50 @@ test("multiline rendering omits two-column graphemes at one-column width", () =>
 	}
 });
 
+test("running single-subagent cards show the configured detach shortcut", () => {
+	const running = {
+		...result("reviewer", ""),
+		progress: { status: "running", index: 0, agent: "reviewer", toolCount: 0, tokens: 0, durationMs: 0 },
+	};
+	const toolResult = {
+		content: [{ type: "text", text: "running" }],
+		details: { mode: "single", results: [running] },
+	};
+
+	const configured = componentText(renderSubagentResult(
+		toolResult as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.match(configured, /Ctrl\+B to run in background/);
+
+	const unconfigured = componentText(renderSubagentResult(toolResult as never, { expanded: false }, theme as any));
+	assert.doesNotMatch(unconfigured, /run in background/);
+
+	const alreadyBackground = componentText(renderSubagentResult(
+		{ ...toolResult, details: { ...toolResult.details, asyncId: "async-123" } } as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.doesNotMatch(alreadyBackground, /run in background/);
+
+	const pendingBackground = componentText(renderSubagentResult(
+		{ ...toolResult, details: { ...toolResult.details, background: true } } as never,
+		{ expanded: false },
+		theme as any,
+		undefined,
+		undefined,
+		"ctrl+b",
+	));
+	assert.doesNotMatch(pendingBackground, /run in background/);
+});
+
 test("compact chain rendering uses workflow graph spans for dynamic fanout results", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],
@@ -238,3 +282,51 @@ test("static sequential and static parallel chain rendering keep existing labels
 	assert.match(parallel, /Agent 2\/2: auditor/);
 	assert.match(parallel, /Step 3: writer/);
 });
+
+test("main-window renderer config removes compact result indentation without changing status glyphs", () => {
+	const component = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [result("scout", "a"), { ...result("reviewer", ""), exitCode: 1, error: "failed" }],
+		},
+	}, { expanded: false }, theme as any, undefined, { horizontalSpacing: 0 });
+
+	const text = componentText(component);
+	assert.match(text, /^✗ parallel/m);
+	assert.match(text, /^✓ Agent 1\/2: scout/m);
+	assert.match(text, /^✗ Agent 2\/2: reviewer/m);
+	assert.match(text, /^⎿  Error: failed/m);
+});
+
+test("main-window renderer config caps only collapsed rich result rows", () => {
+	const rendered = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [
+				result("scout", "a"),
+				result("reviewer", "b"),
+				result("writer", "c"),
+			],
+		},
+	}, { expanded: false }, theme as any, undefined, { compactResultMaxLines: 3 }).render(120);
+
+	assert.equal(rendered.length, 3);
+	assert.match(rendered[2]!, /rows hidden/);
+
+	const expanded = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [
+				result("scout", "a"),
+				result("reviewer", "b"),
+				result("writer", "c"),
+			],
+		},
+	}, { expanded: true }, theme as any, undefined, { compactResultMaxLines: 3 }).render(120);
+
+	assert.ok(expanded.length > 3);
+	assert.doesNotMatch(expanded.join("\n"), /rows hidden/);
+});

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/);