@selesai/code 0.13.40 → 0.14.3

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

@@ -5,10 +5,12 @@ import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import { EXTERNAL_JOB_PROVIDER_REGISTRY_KEY, registerExternalJobProvider } from "../../src/api/external-job-provider.ts";
 import { updateActiveRunIndex } from "../../src/runs/background/active-run-index.ts";
+import { summarizeAsyncStatus } from "../../src/runs/background/async-status.ts";
+import { formatAsyncResultTranscript, formatAsyncRunTranscript } from "../../src/runs/background/fleet-view.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
 import { createNestedRoute, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 import { claimRunFanoutBatch, createRunFanoutBudget, writeRunFanoutBudgetDescriptor } from "../../src/runs/shared/run-fanout-budget.ts";
-import { TEMP_ROOT_DIR, type SubagentState } from "../../src/shared/types.ts";
+import { TEMP_ROOT_DIR, type AsyncStatus, type SubagentState } from "../../src/shared/types.ts";
 import { getArtifactPaths, getArtifactsDir } from "../../src/shared/artifacts.ts";
 
 function errno(code: string): NodeJS.ErrnoException {
@@ -23,6 +25,113 @@ function textContent(result: ReturnType<typeof inspectSubagentStatus>): string {
 }
 
 describe("async run status inspection", () => {
+	it("preserves short transcript ANSI escaping and the unindented binary placeholder", () => {
+		const text = formatAsyncResultTranscript({
+			id: "short-preview", state: "complete",
+			output: "\u001b[0m".repeat(4) + "a".repeat(24) + "\nPNG\0payload\nlatest context",
+		}, "/artifacts/result.json");
+		assert.equal(text, [
+			"Run: short-preview", "State: complete", "Artifacts:", "  Result: /artifacts/result.json",
+			"Result transcript tail:",
+			"  [U+001B][0m[U+001B][0m[U+001B][0m[U+001B][0maaaaaaaaaaaaaaaaaaaaaaaa",
+			"[binary content omitted for safe display]",
+			"  latest context",
+		].join("\n"));
+	});
+
+	it("bounds compact JSON session previews without changing short output or stored evidence", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-transcript-preview-"));
+		try {
+			const asyncDir = path.join(root, "runs", "preview");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			const sessionFile = path.join(root, "session.jsonl");
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "preview", mode: "single", state: "complete",
+				steps: [{ agent: "worker", status: "complete", sessionFile }],
+			}));
+			const inspect = () => textContent(inspectSubagentStatus({ id: "preview", view: "transcript", lines: 35 }, {
+				asyncDirRoot: path.join(root, "runs"), resultsDir: path.join(root, "results"), sessionRoots: [root],
+			}));
+			const record = (role: string, text: string) => JSON.stringify({ message: { role, content: [{ type: "text", text }] } });
+			fs.writeFileSync(sessionFile, record("assistant", "Short 世界 😀\nsecond line") + "\n");
+			assert.equal(inspect(), [
+				"Run: preview", "State: complete", "Mode: single", "Step: 0 (worker) | complete", "Artifacts:",
+				`  Session: ${sessionFile}`, `Session transcript tail from ${sessionFile}:`, "  assistant: Short 世界 😀", "  second line",
+			].join("\n"));
+			const payload = JSON.stringify({ output: "😀世界\n".repeat(8_000) });
+			const stored = [record("assistant", "before tool"), record("toolResult", payload), "{malformed", record("assistant", "latest context")].join("\n") + "\n";
+			fs.writeFileSync(sessionFile, stored);
+			const text = inspect();
+			const body = text.split(`Session transcript tail from ${sessionFile}:\n`)[1]!;
+			assert.ok(body.length < 3_000, `single-entry preview rendered ${body.length} characters`);
+			assert.ok(body.split("\n").every((line) => line.length <= 2002));
+			assert.match(body, /toolResult: \{"output":/);
+			assert.match(body, /… \[content omitted\]/);
+			assert.match(body, /before tool/);
+			assert.ok(body.endsWith("  assistant: latest context"));
+			assert.doesNotMatch(body, /[\uD800-\uDFFF]|\uFFFD|U\+D[89AB]/u);
+			assert.match(text, /State: complete/);
+			assert.ok(text.includes(`Session: ${sessionFile}`));
+			assert.match(text, /Warnings:\n  Skipped 1 malformed session tail line/);
+			assert.equal(fs.readFileSync(sessionFile, "utf8"), stored);
+		} finally { fs.rmSync(root, { recursive: true, force: true }); }
+	});
+
+	for (const source of ["output", "recent", "result", "nested"] as const) {
+		it(`bounds the aggregate rendered ${source} transcript, retaining newest context`, () => {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-transcript-body-budget-"));
+			const route = createNestedRoute(`preview-${source}-root`);
+			try {
+				const id = `preview-${source}`;
+				const asyncDir = path.join(root, "runs", id);
+				const resultsDir = path.join(root, "results");
+				if (source !== "nested") fs.mkdirSync(asyncDir, { recursive: true });
+				fs.mkdirSync(resultsDir);
+				// Escaping expands each unsafe code point, so budget the final rendered text.
+				const entries = Array.from({ length: 100 }, (_, i) => `entry-${i}: ${"世界😀\u202e".repeat(70)}`);
+				entries.push("huge: " + "😀".repeat(10_000), "latest context");
+				const sessionFile = path.join(root, "session.jsonl");
+				const outputPath = path.join(asyncDir, "output-0.log");
+				const resultPath = path.join(resultsDir, `${id}.json`);
+				let artifactPath = source === "output" ? outputPath : source === "result" ? resultPath : sessionFile;
+				if (source === "nested") {
+					fs.writeFileSync(sessionFile, entries.map((text) => JSON.stringify({ message: { role: "assistant", content: text } })).join("\n"));
+					writeNestedEvent(route, { type: "subagent.nested.updated", ts: 150, parentRunId: route.rootRunId, parentStepIndex: 0,
+						child: { id, parentRunId: route.rootRunId, parentStepIndex: 0, depth: 1, path: [{ runId: route.rootRunId, stepIndex: 0, agent: "orchestrator" }], state: "complete", mode: "single", agent: "worker", sessionFile, lastUpdate: 150 } });
+				} else if (source === "result") {
+					fs.writeFileSync(resultPath, JSON.stringify({ id, agent: "worker", state: "complete", output: entries.join("\n"), sessionFile }));
+				} else {
+					fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({ runId: id, mode: "single", state: "complete",
+						steps: [{ agent: "worker", status: "complete", sessionFile, ...(source === "recent" ? { recentOutput: entries } : {}) }] }));
+					if (source === "output") fs.writeFileSync(outputPath, entries.join("\n"));
+					else artifactPath = path.join(asyncDir, "status.json");
+				}
+				const stored = fs.readFileSync(artifactPath, "utf8");
+				const result = inspectSubagentStatus({ id, view: "transcript", lines: 500 }, {
+					asyncDirRoot: path.join(root, "runs"), resultsDir, sessionRoots: [root],
+				});
+				assert.equal(result.isError, undefined);
+				const text = textContent(result);
+				const body = text.split(/(?:Transcript tail from .*|Recent output from status\.json|Result transcript tail|Session transcript tail from .*):\n/)[1]!;
+				assert.ok(body !== undefined, text);
+				assert.ok(Buffer.byteLength(body) <= 32 * 1024, `${source} body rendered ${Buffer.byteLength(body)} bytes`);
+				assert.ok(body.split("\n").every((line) => line.length <= 2002));
+				assert.match(body, /earlier lines omitted/);
+				assert.match(body, /huge: .*… \[content omitted\]/);
+				assert.match(body, /entry-99:/);
+				assert.doesNotMatch(body, /entry-0:|[\uD800-\uDFFF\u202e]|\uFFFD/u);
+				assert.ok(body.endsWith("latest context"));
+				assert.match(text, /State: complete/);
+				assert.match(text, /Artifacts:/);
+				assert.ok(text.includes(source === "output" ? outputPath : source === "result" ? resultPath : sessionFile));
+				assert.equal(fs.readFileSync(artifactPath, "utf8"), stored);
+			} finally {
+				fs.rmSync(root, { recursive: true, force: true });
+				fs.rmSync(path.dirname(route.eventSink), { recursive: true, force: true });
+			}
+		});
+	}
+
 	it("inspects live foreground artifacts on demand with child selection, ownership and bounded tails", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-live-foreground-transcript-"));
 		try {
@@ -448,6 +557,71 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("renders an indexed async workflow child's owned transcript", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-child-transcript-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const parentDir = path.join(asyncRoot, "workflow-parent");
+			const childDir = path.join(asyncRoot, "workflow-child");
+			fs.mkdirSync(parentDir, { recursive: true });
+			fs.mkdirSync(childDir);
+			fs.writeFileSync(path.join(parentDir, "status.json"), JSON.stringify({
+				runId: "workflow-parent", sessionId: "trusted-session", mode: "workflow", state: "running", startedAt: 100,
+				steps: [{ agent: "worker", workflowKey: "build", status: "running", async: true, runId: "workflow-child" }],
+			}));
+			const writeChildStatus = (overrides: Record<string, unknown> = {}) => fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+				runId: "workflow-child", sessionId: "trusted-session", parentWorkflowRunId: "workflow-parent", workflowKey: "build",
+				mode: "single", state: "running", startedAt: 100,
+				steps: [{ agent: "worker", status: "running" }],
+				...overrides,
+			}));
+			writeChildStatus();
+			fs.writeFileSync(path.join(childDir, "output-0.log"), "CHILD_OWNED_TRANSCRIPT_SENTINEL\n");
+
+			const result = inspectSubagentStatus({ id: "workflow-parent", view: "transcript", index: 0 }, {
+				asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results"),
+			});
+			const text = textContent(result);
+			assert.match(text, /CHILD_OWNED_TRANSCRIPT_SENTINEL/);
+			assert.doesNotMatch(text, /\(no transcript lines available yet\)/);
+
+			const inspect = () => textContent(inspectSubagentStatus({ id: "workflow-parent", view: "transcript", index: 0 }, {
+				asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results"),
+			}));
+			for (const mismatch of [
+				{ runId: "mismatched-child" },
+				{ parentWorkflowRunId: "different-parent" },
+				{ workflowKey: "different-key" },
+				{ sessionId: "different-session" },
+			]) {
+				writeChildStatus(mismatch);
+				const refused = inspect();
+				assert.match(refused, /\(no transcript lines available yet\)/, JSON.stringify(mismatch));
+				assert.doesNotMatch(refused, /CHILD_OWNED_TRANSCRIPT_SENTINEL/, JSON.stringify(mismatch));
+			}
+
+			fs.unlinkSync(path.join(childDir, "status.json"));
+			assert.match(inspect(), /\(no transcript lines available yet\)/);
+
+			fs.writeFileSync(path.join(childDir, "status.json"), "{malformed");
+			const malformed = inspectSubagentStatus({ id: "workflow-parent", view: "transcript", index: 0 }, {
+				asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results"),
+			});
+			assert.equal(malformed.isError, true);
+			assert.match(textContent(malformed), /Failed to parse async status file .*workflow-child.*status\.json/);
+
+			fs.rmSync(path.join(childDir, "status.json"));
+			fs.mkdirSync(path.join(childDir, "status.json"));
+			const unreadable = inspectSubagentStatus({ id: "workflow-parent", view: "transcript", index: 0 }, {
+				asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results"),
+			});
+			assert.equal(unreadable.isError, true);
+			assert.match(textContent(unreadable), /Failed to read async status file .*workflow-child.*status\.json/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("shows host steps in exact workflow status checklist", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-host-checklist-"));
 		try {
@@ -661,7 +835,7 @@ describe("async run status inspection", () => {
 				chainStepCount: 1,
 				parallelGroups: [{ start: 0, count: 2, stepIndex: 0 }],
 				steps: [
-					{ agent: "worker", sessionName: "  worker: Inspect fleet  ", label: "Fleet check", status: "running", startedAt: 100 },
+					{ agent: "worker", sessionName: "  worker: Inspect fleet  ", label: "Fleet check", status: "running", startedAt: 100, runner: { type: "external-cli" }, externalProcess: { startedAt: 100, stdoutPath: path.join(asyncDir, "external-0.stdout.log"), stderrPath: path.join(asyncDir, "external-0.stderr.log") } },
 					{ agent: "reviewer", status: "pending" },
 				],
 			}, null, 2), "utf-8");
@@ -695,6 +869,7 @@ describe("async run status inspection", () => {
 			assert.doesNotMatch(text, /fg-run \| running \| scout/);
 			assert.match(text, /Async runs:/);
 			assert.match(text, /0\. worker: Inspect fleet \| running/);
+			assert.match(text, /external-cli · 150ms/);
 			assert.match(text, /run-fleet \| running .*\| parallel \| 1 agent running · 0\/2 done/);
 			assert.match(text, /transcript: subagent\(\{ action: "status", id: "run-fleet", view: "transcript" \}\)/);
 			assert.match(text, /transcript: subagent\(\{ action: "status", id: "run-fleet", index: 0, view: "transcript" \}\)/);
@@ -703,6 +878,77 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("selects bounded external-cli evidence by lifecycle and preserves it in summaries", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-external-logs-"));
+		try {
+			const stdoutPath = path.join(root, "external-0.stdout.log");
+			const stderrPath = path.join(root, "external-0.stderr.log");
+			const outputPath = path.join(root, "output-0.log");
+			const finalOutputPath = path.join(root, "external-0.final.log");
+			const runner = { type: "external-cli", command: "example", args: [] } as never;
+			fs.writeFileSync(stdoutPath, "STDOUT_SENTINEL", "utf-8");
+			fs.writeFileSync(stderrPath, "STDERR_SENTINEL", "utf-8");
+			const status: AsyncStatus = {
+				runId: "external-logs", mode: "single", state: "running", startedAt: 100, currentStep: 0,
+				steps: [{
+					agent: "worker", status: "running", runner,
+					externalProcess: { startedAt: 100, stdoutPath, stderrPath, finalOutputPath },
+				}],
+			};
+
+			let text = formatAsyncRunTranscript(status, root, { index: 0 });
+			assert.match(text, /External stderr tail/);
+			assert.match(text, /STDERR_SENTINEL/);
+			assert.doesNotMatch(text, /STDOUT_SENTINEL/);
+			fs.writeFileSync(stderrPath, "", "utf-8");
+			text = formatAsyncRunTranscript(status, root, { index: 0 });
+			assert.match(text, /External stdout tail/);
+			assert.match(text, /STDOUT_SENTINEL/);
+
+			fs.writeFileSync(stderrPath, "RAW_FAILURE", "utf-8");
+			fs.writeFileSync(outputPath, "SYNTHESIZED_OUTPUT", "utf-8");
+			fs.writeFileSync(finalOutputPath, "FINAL_OUTPUT", "utf-8");
+			status.state = "failed";
+			status.steps![0]!.status = "failed";
+			text = formatAsyncRunTranscript(status, root, { index: 0 });
+			assert.match(text, /Transcript tail.*external-0\.final\.log/);
+			assert.match(text, /FINAL_OUTPUT/);
+			assert.doesNotMatch(text, /SYNTHESIZED_OUTPUT/);
+			assert.doesNotMatch(text, /RAW_FAILURE/);
+
+			fs.rmSync(outputPath);
+			for (const whitespace of ["\n", "   \n"]) {
+				fs.writeFileSync(finalOutputPath, whitespace, "utf-8");
+				text = formatAsyncRunTranscript(status, root, { index: 0 });
+				assert.match(text, /External stderr tail/);
+				assert.match(text, /RAW_FAILURE/);
+			}
+
+			assert.deepEqual(summarizeAsyncStatus(root, status).steps[0]?.externalProcess, status.steps![0]!.externalProcess);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("refuses external-cli log paths that escape the async directory", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-external-escape-"));
+		try {
+			const asyncDir = path.join(root, "run");
+			fs.mkdirSync(asyncDir);
+			const outside = path.join(root, "outside.log");
+			fs.writeFileSync(outside, "OUTSIDE_SENTINEL", "utf-8");
+			const status: AsyncStatus = {
+				runId: "external-escape", mode: "single", state: "running", startedAt: 100,
+				steps: [{ agent: "worker", status: "running", runner: { type: "external-cli", command: "example", args: [] } as never, externalProcess: { startedAt: 100, stdoutPath: outside, stderrPath: outside } }],
+			};
+			const text = formatAsyncRunTranscript(status, asyncDir, { index: 0 });
+			assert.match(text, /Refusing to read output transcript path outside trusted roots/);
+			assert.doesNotMatch(text, /OUTSIDE_SENTINEL/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("scopes fleet active-run discovery to the current session", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-fleet-session-"));
 		try {
@@ -1203,7 +1449,7 @@ describe("async run status inspection", () => {
 		}
 	});
 
-	it("shows direct run-id recovery for workflow children", () => {
+	it("shows resolved child models and direct run-id recovery for workflow children", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-resume-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
@@ -1221,12 +1467,25 @@ describe("async run status inspection", () => {
 				lastUpdate: 200,
 				steps: [
 					{ agent: "reviewer", workflowKey: "review", runId: "child-review", status: "failed", sessionFile: firstSession },
-					{ agent: "worker", workflowKey: "write", runId: "child-write", status: "paused", sessionFile: secondSession },
+					{ agent: "worker", workflowKey: "write", runId: "child-write", status: "paused", sessionFile: secondSession, model: "anthropic/claude-sonnet-5" },
 				],
+				workflowChildren: {
+					version: 1,
+					parentToolCallId: "tool-call",
+					workflowRunId: "workflow-parent",
+					inventoryComplete: true,
+					workflowState: "failed",
+					children: [
+						{ childId: "review", runId: "child-review", state: "failed", model: "openai-codex/gpt-5.5", thinking: "high" },
+						{ childId: "write", runId: "child-write", state: "paused", model: "ignored/model", thinking: "low" },
+					],
+				},
 			}, null, 2), "utf-8");
 
 			const result = inspectSubagentStatus({ id: "workflow-parent" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
 			const text = textContent(result);
+			assert.match(text, /Workflow child review: reviewer failed \(gpt-5\.5 · thinking high\)/);
+			assert.match(text, /Workflow child write: worker paused \(claude-sonnet-5 · thinking low\)/);
 			assert.match(text, /Revive workflow child 'review': subagent\(\{ action: "resume", id: "child-review", message: "\.\.\." \}\)/);
 			assert.match(text, /Revive workflow child 'write': subagent\(\{ action: "resume", id: "child-write", message: "\.\.\." \}\)/);
 			assert.doesNotMatch(text, /id: "workflow-parent", index:/);
@@ -1235,6 +1494,42 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("returns a workflow terminal proof after every async child exits", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-terminal-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const asyncDir = path.join(asyncRoot, "workflow-parent");
+			const childDir = path.join(asyncRoot, "child-run");
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.mkdirSync(childDir);
+			const childProof = {
+				version: 1, state: "observed", runId: "child-run", runnerProcessInstanceId: "runner-1", observedAt: 300,
+				instances: [{ kind: "runner", processInstanceId: "runner-1", closeObservedAt: 300, exitCode: 0, signal: null }],
+			};
+			fs.writeFileSync(path.join(childDir, "process-terminal.json"), JSON.stringify(childProof));
+			fs.writeFileSync(path.join(childDir, "status.json"), JSON.stringify({
+				runId: "child-run", mode: "single", state: "complete", startedAt: 100, lastUpdate: 300,
+				processTerminal: { version: 1, state: "pending", runId: "child-run", runnerProcessInstanceId: "runner-1" },
+			}));
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId: "workflow-parent", mode: "workflow", state: "complete", startedAt: 100, lastUpdate: 200, endedAt: 250,
+				steps: [{ agent: "worker", workflowKey: "main", runId: "child-run", async: true, status: "completed" }],
+				workflowChildren: {
+					version: 1, parentToolCallId: "tool-call", workflowRunId: "workflow-parent", inventoryComplete: true,
+					workflowState: "completed", children: [{ childId: "main", runId: "child-run", state: "completed" }],
+				},
+			}, null, 2), "utf-8");
+
+			const result = inspectSubagentStatus({ id: "workflow-parent" }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") });
+			assert.deepEqual(result.details.workflowTerminalProof, {
+				version: 1, kind: "workflow", runId: "workflow-parent", state: "observed", dispatchClosed: true,
+				observedAt: 300, children: [childProof],
+			});
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("keeps supervisor-detached workflow children out of generic revive guidance", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-workflow-detached-"));
 		try {
@@ -1398,6 +1693,8 @@ describe("async run status inspection", () => {
 			const asyncRoot = path.join(root, "runs");
 			fs.mkdirSync(path.join(asyncRoot, "run-aaaa-one"), { recursive: true });
 			fs.mkdirSync(path.join(asyncRoot, "run-aaaa-two"), { recursive: true });
+			fs.writeFileSync(path.join(asyncRoot, "run-aaaa-one", "status.json"), "{}");
+			fs.writeFileSync(path.join(asyncRoot, "run-aaaa-two", "status.json"), "{}");
 
 			const result = inspectSubagentStatus({ id: "run-aaaa" }, {
 				asyncDirRoot: asyncRoot,

package/dist/extensions/pi-subagents/test/unit/runner-bootstrap.test.ts

@@ -0,0 +1,182 @@
+import assert from "node:assert/strict";
+import { fork, type ChildProcess } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+import { inspectSessionLease } from "../../src/runs/shared/session-lease.ts";
+import { validateSubagentRunConfig } from "../../src/runs/background/subagent-runner-bootstrap.ts";
+import { persistRunnerStartupFailure } from "../../src/runs/background/runner-startup-failure.ts";
+
+const harness = fileURLToPath(new URL("../fixtures/runner-bootstrap-harness.ts", import.meta.url));
+
+test("runner config validation reports required fields without echoing values", () => {
+	assert.throws(
+		() => validateSubagentRunConfig({ id: "run", steps: [], resultPath: "/result", cwd: "/cwd", asyncDir: "/async", placeholder: "pending" }),
+		{ message: "Invalid runner configuration: 'steps' must be a non-empty array." },
+	);
+	assert.throws(
+		() => validateSubagentRunConfig({ id: "run", steps: [{}], resultPath: "/result", cwd: "/cwd", asyncDir: "/async", placeholder: "pending" }),
+		{ message: "Invalid runner configuration: 'steps[0].agent' must be a non-empty string." },
+	);
+	assert.throws(
+		() => validateSubagentRunConfig({ id: "run", steps: [{ agent: "secret-agent", task: "task" }], resultPath: 42, cwd: "/cwd", asyncDir: "/async", placeholder: "pending" }),
+		(error: unknown) => error instanceof Error && error.message === "Invalid runner configuration: 'resultPath' must be a non-empty string." && !error.message.includes("secret-agent"),
+	);
+});
+
+test("startup failure persistence does not overwrite malformed existing evidence", () => {
+	const asyncDir = fs.mkdtempSync(path.join(os.tmpdir(), "runner-startup-failure-"));
+	const statusPath = path.join(asyncDir, "status.json");
+	fs.writeFileSync(statusPath, "not-json");
+	assert.throws(
+		() => persistRunnerStartupFailure({
+			asyncDir,
+			runId: "run",
+			runnerProcessInstanceId: "runner",
+			message: "setup failed",
+		}),
+		SyntaxError,
+	);
+	assert.equal(fs.readFileSync(statusPath, "utf8"), "not-json");
+	assert.equal(fs.existsSync(path.join(asyncDir, "process-terminal-candidate.json")), false);
+	fs.rmSync(asyncDir, { recursive: true, force: true });
+});
+
+type ChildMessage = { type: string; importRequested?: boolean; token?: string };
+
+function nextMessage(child: ChildProcess, type: string): Promise<ChildMessage> {
+	return new Promise((resolve, reject) => {
+		const onMessage = (message: ChildMessage) => {
+			if (message?.type !== type) return;
+			cleanup();
+			resolve(message);
+		};
+		const onExit = (code: number | null) => { cleanup(); reject(new Error(`runner exited ${code} before ${type}`)); };
+		const cleanup = () => { child.off("message", onMessage); child.off("exit", onExit); };
+		child.on("message", onMessage);
+		child.on("exit", onExit);
+	});
+}
+
+function waitForStartupState(startupPath: string, state: string): Promise<Record<string, unknown>> {
+	return new Promise((resolve, reject) => {
+		const inspect = () => {
+			try {
+				const payload = JSON.parse(fs.readFileSync(startupPath, "utf8")) as Record<string, unknown>;
+				if (payload.state === "error") { cleanup(); reject(new Error(String(payload.error))); }
+				if (payload.state === state) { cleanup(); resolve(payload); }
+			} catch (error) {
+				if ((error as NodeJS.ErrnoException).code !== "ENOENT") { cleanup(); reject(error); }
+			}
+		};
+		// Poll content, not fs.watchFile: its first stat is a silent baseline, so a state
+		// written between the read below and that stat is never reported.
+		const timer = setInterval(inspect, 20);
+		const cleanup = () => clearInterval(timer);
+		inspect();
+	});
+}
+
+function writeControl(asyncDir: string, name: string, action: string, token: string): void {
+	fs.writeFileSync(path.join(asyncDir, name), JSON.stringify({ action, token }));
+}
+
+async function runBootstrapCase(mode: "delayed" | "reject"): Promise<{ code: number | null; stderr: string; candidate: Record<string, unknown>; executed?: ChildMessage }> {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "runner-bootstrap-"));
+	const asyncDir = path.join(root, "run");
+	const sessionFile = path.join(root, "session.jsonl");
+	fs.mkdirSync(asyncDir);
+	fs.writeFileSync(sessionFile, "");
+	const config = {
+		id: `bootstrap-${mode}`,
+		steps: [{ agent: "worker", task: "test", inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false }],
+		resultPath: path.join(root, "result.json"),
+		cwd: root,
+		placeholder: "pending",
+		asyncDir,
+		runnerProcessInstanceId: "runner-instance",
+		revivalLease: { sessionFile, runId: `bootstrap-${mode}`, sourceRunId: "source" },
+	};
+	fs.writeFileSync(path.join(asyncDir, "process-terminal-candidate.json"), JSON.stringify({
+		version: 1, runId: config.id, runnerProcessInstanceId: "runner-instance", writers: {},
+	}));
+	const child = fork(harness, [JSON.stringify(config), mode], {
+		execArgv: ["--experimental-strip-types"],
+		stdio: ["ignore", "ignore", "pipe", "ipc"],
+	});
+	const exitPromise = new Promise<number | null>((resolve) => child.once("exit", resolve));
+	let stderr = "";
+	child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+	const startupPath = path.join(asyncDir, "runner-startup.json");
+	const ready = await waitForStartupState(startupPath, "ready");
+	const token = String(ready.token);
+	assert.equal(inspectSessionLease(sessionFile).state, "owned");
+	writeControl(asyncDir, "runner-startup-ack.json", "ack", token);
+	await waitForStartupState(startupPath, "acknowledged");
+	writeControl(asyncDir, "runner-startup-confirm.json", "confirm", token);
+	await waitForStartupState(startupPath, "confirmed");
+	const probe = nextMessage(child, "probe-result");
+	child.send("probe");
+	assert.equal((await probe).importRequested, false, "heavy import must not start before proceed");
+	const importRequested = nextMessage(child, "import-requested");
+	writeControl(asyncDir, "runner-startup-proceed.json", "proceed", token);
+	await importRequested;
+	assert.equal(inspectSessionLease(sessionFile).state, "owned", "bootstrap must retain the lease during import");
+	const executedPromise = mode === "delayed" ? nextMessage(child, "executed") : undefined;
+	child.send("release-import");
+	const executed = executedPromise ? await executedPromise : undefined;
+	const code = await exitPromise;
+	assert.equal(inspectSessionLease(sessionFile).state, "free");
+	const candidate = JSON.parse(fs.readFileSync(path.join(asyncDir, "process-terminal-candidate.json"), "utf8")) as Record<string, unknown>;
+	assert.equal(candidate.revivalLeaseToken, token);
+	assert.equal(candidate.revivalLeaseReleaseAcknowledged, true);
+	if (mode === "reject") {
+		const status = JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8")) as Record<string, unknown>;
+		assert.equal(status.state, "failed");
+		assert.match(String(status.error), /injected heavy import rejection/);
+		assert.deepEqual(candidate.expectedWriters, { 0: 0 });
+	}
+	fs.rmSync(root, { recursive: true, force: true });
+	return { code, stderr, candidate, ...(executed ? { executed } : {}) };
+}
+
+test("revival handshake commits before delayed heavy import and retains one lease", async () => {
+	const result = await runBootstrapCase("delayed");
+	assert.equal(result.code, 0);
+	assert.ok(result.executed?.token, "revival lease token reaches execution");
+});
+
+test("rejected post-proceed heavy import fails visibly and releases the lease", async () => {
+	const result = await runBootstrapCase("reject");
+	assert.equal(result.code, 1);
+	assert.match(result.stderr, /injected heavy import rejection/);
+});
+
+test("fresh-launch barrier also keeps heavy execution behind proceed", async () => {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "runner-bootstrap-fresh-"));
+	const asyncDir = path.join(root, "run");
+	fs.mkdirSync(asyncDir);
+	const token = "fresh-barrier-token";
+	const config = {
+		id: "bootstrap-fresh", steps: [{ agent: "worker", task: "test", inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false }], resultPath: path.join(root, "result.json"),
+		cwd: root, placeholder: "pending", asyncDir, launchBarrierToken: token,
+	};
+	const child = fork(harness, [JSON.stringify(config), "delayed"], {
+		execArgv: ["--experimental-strip-types"], stdio: ["ignore", "ignore", "pipe", "ipc"],
+	});
+	const exitPromise = new Promise<number | null>((resolve) => child.once("exit", resolve));
+	const probe = nextMessage(child, "probe-result");
+	child.send("probe");
+	assert.equal((await probe).importRequested, false);
+	const importRequested = nextMessage(child, "import-requested");
+	writeControl(asyncDir, "runner-startup-proceed.json", "proceed", token);
+	await importRequested;
+	assert.equal(fs.existsSync(path.join(asyncDir, "runner-startup-proceed.json")), false);
+	const executed = nextMessage(child, "executed");
+	child.send("release-import");
+	await executed;
+	assert.equal(await exitPromise, 0);
+	fs.rmSync(root, { recursive: true, force: true });
+});