@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-subagents/test/unit/async-result-timeout-evidence.test.ts

@@ -0,0 +1,53 @@
+import { it } from "node:test";
+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 { asyncResultTimeoutEvidence } from "../support/async-result-timeout-evidence.ts";
+
+it("correlates timeout evidence without promoting pending sidecars or exposing contents", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "result-evidence-"));
+	try {
+		const proof = { runId: "run", runnerProcessInstanceId: "private-runner", state: "pending" };
+		fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify({ runId: "run", state: "running", pid: 123, processTerminal: proof, steps: [{ status: "complete" }, { status: "complete" }], task: "SECRET" }));
+		fs.writeFileSync(path.join(dir, "process-terminal.json"), JSON.stringify(proof));
+		fs.writeFileSync(path.join(dir, "process-terminal-candidate.json"), JSON.stringify({ ...proof, writers: {}, expectedWriters: { "0": 0, "1": 0 } }));
+		fs.writeFileSync(path.join(dir, "events.jsonl"), [
+			{ type: "subagent.step.completed", runId: "run", stepIndex: 1, ts: 42, output: "SECRET" },
+			{ type: "subagent.parallel.completed", runId: "run", stepIndex: 0, ts: 43 },
+			{ type: "subagent.run.completed", runId: "other", ts: 43 },
+		].map((event) => JSON.stringify(event)).join("\n"));
+		fs.writeFileSync(path.join(dir, "runner.stderr.log"), "SECRET");
+		const evidence = asyncResultTimeoutEvidence(dir, "run").join("\n");
+		assert.match(evidence, /"state":"pending"/);
+		assert.match(evidence, /"runnerIdMatches":true/);
+		assert.match(evidence, /"mismatchedRunEvents":1/);
+		assert.match(evidence, /"stepIndex":1/);
+		assert.match(evidence, /subagent.parallel.completed/);
+		assert.match(evidence, /runner-startup-proceed.json: ENOENT/);
+		assert.doesNotMatch(evidence, /SECRET|private-runner|subagent.run.completed/);
+		fs.writeFileSync(path.join(dir, "process-terminal.json"), JSON.stringify({ ...proof, state: "observed", runnerProcessInstanceId: "other", instances: [{ kind: "runner", processInstanceId: "other", closeObservedAt: 99, exitCode: 1, signal: null }] }));
+		const mismatch = asyncResultTimeoutEvidence(dir, "run").join("\n");
+		assert.match(mismatch, /"runnerIdMatches":false/);
+		assert.match(mismatch, /"closeObservedAt":99,"exitCode":1,"signal":null/);
+	} finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+it("bounds timeout reads and output, and tolerates missing, malformed and oversized evidence", () => {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "result-evidence-"));
+	try {
+		fs.writeFileSync(path.join(dir, "status.json"), "x".repeat(20_000));
+		fs.writeFileSync(path.join(dir, "process-terminal.json"), "{");
+		fs.writeFileSync(path.join(dir, "process-terminal-candidate.json"), JSON.stringify({ runId: "run", runnerProcessInstanceId: "private-runner" }));
+		fs.writeFileSync(path.join(dir, "runner.stdout.log"), "SECRET".repeat(100_000));
+		fs.writeFileSync(path.join(dir, "events.jsonl"), "SECRET".repeat(3_000) + "\n" + Array.from({ length: 100 }, () => JSON.stringify({ type: "subagent.run.completed", runId: "run", ts: 42 })).join("\n"));
+		const evidence = asyncResultTimeoutEvidence(dir, "run").join("\n");
+		assert.match(evidence, /oversize/);
+		assert.match(evidence, /invalid JSON/);
+		assert.match(evidence, /"tailOnly":true/);
+		assert.match(evidence, /"runnerIdMatches":"unavailable"/);
+		assert.equal(evidence.match(/subagent.run.completed/g)?.length, 16);
+		assert.ok(Buffer.byteLength(evidence) < 8_192);
+		assert.doesNotMatch(evidence, /SECRET/);
+	} finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});

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

@@ -3,7 +3,8 @@ 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 { asyncReviveRequiresRecoveryDescriptor, buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import { applySteeringRecoveryAgentConfig, asyncReviveRequiresRecoveryDescriptor, buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
 
 function writeJson(filePath: string, value: object): void {
@@ -42,10 +43,11 @@ describe("async resume lookup", () => {
 		}
 	});
 
-	it("resolves a workflow child session without a recovery descriptor", () => {
+	it("requires a recovery descriptor for a legacy workflow child session", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-workflow-"));
 		try {
 			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
 			const sessionFile = path.join(root, "child-session.jsonl");
 			fs.writeFileSync(sessionFile, "", "utf-8");
 			writeJson(path.join(asyncRoot, "workflow-1", "status.json"), {
@@ -66,8 +68,41 @@ describe("async resume lookup", () => {
 			assert.equal(target.agent, "worker");
 			assert.equal(target.sessionFile, sessionFile);
 			assert.equal(target.recoveryDescriptor, undefined);
+			assert.equal(asyncReviveRequiresRecoveryDescriptor(target), true);
+			assert.equal(asyncReviveRequiresRecoveryDescriptor({}), true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("uses a current workflow's persisted parent admission authority", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-current-workflow-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			const sessionFile = path.join(root, "child-session.jsonl");
+			const parentAuthority = { version: 1 as const, allowedAgents: ["researcher", "worker"], denyExtensions: false, sources: ["workflow-parent"] };
+			fs.writeFileSync(sessionFile, "", "utf-8");
+			writeJson(path.join(asyncRoot, "workflow-2", "status.json"), {
+				runId: "workflow-2", mode: "workflow", state: "complete", startedAt: 100, endedAt: 200, lastUpdate: 200, cwd: root,
+				admissionCapabilityCeiling: parentAuthority,
+				steps: [{ agent: "worker", status: "complete", sessionFile, capabilityCeiling: { version: 1, allowedAgents: ["researcher"], denyExtensions: false, sources: ["agent:worker"] } }],
+			});
+
+			const target = resolveAsyncResumeTarget({ id: "workflow-2" }, { asyncDirRoot: asyncRoot, resultsDir });
+
+			assert.deepEqual(target.capabilityCeiling, parentAuthority);
 			assert.equal(asyncReviveRequiresRecoveryDescriptor(target), false);
-			assert.equal(asyncReviveRequiresRecoveryDescriptor({ mode: "single", sessionFile }), true);
+
+			fs.rmSync(path.join(asyncRoot, "workflow-2"), { recursive: true });
+			writeJson(path.join(resultsDir, "workflow-2.json"), {
+				runId: "workflow-2", mode: "workflow", state: "complete", success: true, cwd: root,
+				admissionCapabilityCeiling: parentAuthority,
+				results: [{ agent: "worker", success: true, sessionFile }],
+			});
+			const resultOnly = resolveAsyncResumeTarget({ id: "workflow-2" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.deepEqual(resultOnly.capabilityCeiling, parentAuthority);
+			assert.equal(asyncReviveRequiresRecoveryDescriptor(resultOnly), false);
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -294,22 +329,47 @@ describe("async resume lookup", () => {
 				...descriptor,
 				launchContractDigest: "launch-contract-digest",
 				allowNestedSubagents: true,
+				allowedAgents: ["worker", "scout", "worker"],
 				intercomBridge: { mode: "off" },
 				extensionBindings: { "shepherd.dispatch/1": { role: "coder" } },
+				requiredExtensions: [{ id: "provider", path: path.join(root, "provider.mjs") }],
 			});
 			const valid = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
 			assert.equal(valid.launchContractDigest, "launch-contract-digest");
 			assert.equal(valid.recoveryDescriptor?.launchContractDigest, "launch-contract-digest");
 			assert.equal(valid.recoveryDescriptor?.allowNestedSubagents, true);
+			assert.deepEqual(valid.recoveryDescriptor?.allowedAgents, ["scout", "worker"]);
 			assert.deepEqual(valid.recoveryDescriptor?.intercomBridge, { mode: "off" });
 			assert.deepEqual(valid.recoveryDescriptor?.extensionBindings, { "shepherd.dispatch/1": { role: "coder" } });
+			assert.deepEqual(valid.recoveryDescriptor?.requiredExtensions, [{ id: "provider", path: path.join(root, "provider.mjs") }]);
+			assert.ok(Object.isFrozen(valid.recoveryDescriptor?.requiredExtensions));
+			const currentAgent = {
+				name: "worker", description: "Current", systemPrompt: "Current", systemPromptMode: "replace",
+				inheritProjectContext: false, inheritGlobalContext: false, inheritSkills: false,
+				source: "project", filePath: "/current/worker.md", allowedAgents: ["reviewer", "worker"],
+			} as AgentConfig;
+			assert.deepEqual(applySteeringRecoveryAgentConfig(currentAgent, valid.recoveryDescriptor!).allowedAgents, ["scout", "worker"]);
+
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, allowedAgents: [] });
+			const denied = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.deepEqual(applySteeringRecoveryAgentConfig(currentAgent, denied.recoveryDescriptor!).allowedAgents, []);
+
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), descriptor);
+			const unrestricted = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(applySteeringRecoveryAgentConfig(currentAgent, unrestricted.recoveryDescriptor!).allowedAgents, undefined);
 
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, allowNestedSubagents: "true" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /allowNestedSubagents/);
 
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, allowedAgents: ["bad name"] });
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /allowedAgents entry 'bad name'/);
+
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, extensionBindings: { invalid: true } });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /namespace/);
 
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, requiredExtensions: [{ id: "unsafe id", path: "/provider.mjs" }] });
+			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /safe id/);
+
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, sourceRunId: "another-run" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /different source run/);
 
@@ -512,6 +572,34 @@ describe("async resume lookup", () => {
 		}
 	});
 
+	it("rejects a stopped child selected from a terminal aggregate", () => {
+		for (const stoppedStep of [{ status: "stopped" }, { status: "failed", stopped: true }]) {
+			const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-stopped-child-"));
+			try {
+				const asyncRoot = path.join(root, "runs");
+				const stoppedSession = path.join(root, "stopped.jsonl");
+				const completedSession = path.join(root, "completed.jsonl");
+				fs.writeFileSync(stoppedSession, "", "utf-8");
+				fs.writeFileSync(completedSession, "", "utf-8");
+				writeJson(path.join(asyncRoot, "run-aggregate", "status.json"), {
+					runId: "run-aggregate", mode: "parallel", state: "failed", startedAt: 100, endedAt: 200, lastUpdate: 200, cwd: root,
+					steps: [
+						{ agent: "stopped-child", ...stoppedStep, sessionFile: stoppedSession },
+						{ agent: "completed-child", status: "complete", sessionFile: completedSession },
+					],
+				});
+
+				assert.throws(
+					() => resolveAsyncResumeTarget({ id: "run-aggregate", index: 0 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }),
+					/child 0 was stopped and cannot be resumed/,
+				);
+				assert.equal(resolveAsyncResumeTarget({ id: "run-aggregate", index: 1 }, { asyncDirRoot: asyncRoot, resultsDir: path.join(root, "results") }).agent, "completed-child");
+			} finally {
+				fs.rmSync(root, { recursive: true, force: true });
+			}
+		}
+	});
+
 	it("rejects stopped runs instead of reviving them", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-resume-stopped-"));
 		try {
@@ -975,4 +1063,4 @@ describe("async resume lookup", () => {
 		assert.match(task, /Original session file: \/tmp\/session\.jsonl/);
 		assert.match(task, /Follow-up:\nWhat changed\?/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/async-retention.test.ts

@@ -4,6 +4,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { describe, it } from "node:test";
+import { writeMissionAsyncBinding } from "../../src/missions/lifecycle.ts";
+import { createMission, missionRecordPath, resolveMissionStoreLocation, updateMission } from "../../src/missions/store.ts";
 import { ASYNC_RETENTION_BATCH_SIZE, cleanupAsyncRetention } from "../../src/runs/background/async-retention.ts";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -193,6 +195,8 @@ describe("async retention cleanup", () => {
 			const mission = writeOldRun(roots.asyncDirRoot, "mission");
 			fs.writeFileSync(path.join(mission, "mission.json"), "{}");
 			writeOldRun(roots.asyncDirRoot, "workflow", { mode: "workflow" });
+			const revived = writeOldRun(roots.asyncDirRoot, "revived-workflow-child");
+			fs.writeFileSync(path.join(revived, "workflow-revival-origin.json"), "{}");
 			writeOldRun(roots.asyncDirRoot, "nested", { isNested: true });
 			writeOldRun(roots.asyncDirRoot, "handoff", { parallelHandoff: { path: "/tmp/handoff.json" } });
 			writeOldRun(roots.asyncDirRoot, "waited");
@@ -201,7 +205,7 @@ describe("async retention cleanup", () => {
 
 			const result = await cleanupAsyncRetention({ ...cleanupOptions(roots), protectedRunIds: ["runtime"] });
 
-			for (const runId of ["active", "paused", "recent", "resumable", "status-session", "step-session", "uninspectable-session", "malformed-ended-at", "malformed-last-update", "missing-mode", "non-finite-ended-at", "mission", "workflow", "nested", "handoff", "waited", "runtime"]) {
+			for (const runId of ["active", "paused", "recent", "resumable", "status-session", "step-session", "uninspectable-session", "malformed-ended-at", "malformed-last-update", "missing-mode", "non-finite-ended-at", "mission", "workflow", "revived-workflow-child", "nested", "handoff", "waited", "runtime"]) {
 				assert.equal(fs.existsSync(path.join(roots.asyncDirRoot, runId)), true, runId);
 			}
 			assert.equal(result.deletedRuns, 0);
@@ -212,7 +216,7 @@ describe("async retention cleanup", () => {
 			assert.equal(result.skipped["invalid-status"], 1);
 			assert.equal(result.skipped["unknown-age"], 3);
 			assert.equal(result.skipped["mission-reference"], 1);
-			assert.equal(result.skipped["workflow-reference"], 1);
+			assert.equal(result.skipped["workflow-reference"], 2);
 			assert.equal(result.skipped["nested-reference"], 1);
 			assert.equal(result.skipped["handoff-reference"], 1);
 			assert.equal(result.skipped["wait-reference"], 1);
@@ -222,6 +226,54 @@ describe("async retention cleanup", () => {
 		}
 	});
 
+	it("reclaims runs bound to terminal or pruned missions and keeps pending syncs and unreadable records", async () => {
+		const roots = makeRoots();
+		try {
+			const projectRoot = path.join(roots.root, "project");
+			const agentDir = path.join(roots.root, "agent");
+			const location = resolveMissionStoreLocation({ projectRoot, agentDir });
+			const bindMission = (runDir: string, missionId: string): void => {
+				writeMissionAsyncBinding(runDir, { missionId, location, autoCreated: true });
+				fs.utimesSync(runDir, OLD / 1000, OLD / 1000);
+			};
+
+			const terminalMission = createMission(location, { title: "Closed mission", objective: "Deliver and close" });
+			updateMission(location, terminalMission.id, { status: "completed" });
+			const terminalRun = writeOldRun(roots.asyncDirRoot, "terminal-mission-run");
+			bindMission(terminalRun, terminalMission.id);
+			const pendingRun = writeOldRun(roots.asyncDirRoot, "pending-sync-run");
+			bindMission(pendingRun, terminalMission.id);
+			const observerDir = path.join(roots.resultsDir, "result-index", "observers", "mission");
+			fs.mkdirSync(observerDir, { recursive: true });
+			fs.writeFileSync(path.join(observerDir, "pending-sync-run.json"), "{}");
+
+			const activeMission = createMission(location, { title: "Open mission", objective: "Still running" });
+			updateMission(location, activeMission.id, { status: "active" });
+			const activeRun = writeOldRun(roots.asyncDirRoot, "active-mission-run");
+			bindMission(activeRun, activeMission.id);
+
+			const prunedRun = writeOldRun(roots.asyncDirRoot, "pruned-mission-run");
+			bindMission(prunedRun, "mission-record-pruned-by-retention");
+
+			const corruptMission = createMission(location, { title: "Corrupt record", objective: "Unreadable on disk" });
+			fs.writeFileSync(missionRecordPath(location, corruptMission.id), "{ corrupt record");
+			const corruptRun = writeOldRun(roots.asyncDirRoot, "corrupt-record-run");
+			bindMission(corruptRun, corruptMission.id);
+
+			const result = await cleanupAsyncRetention(cleanupOptions(roots));
+
+			assert.equal(fs.existsSync(terminalRun), false);
+			assert.equal(fs.existsSync(prunedRun), false);
+			assert.equal(fs.existsSync(activeRun), true);
+			assert.equal(fs.existsSync(pendingRun), true);
+			assert.equal(fs.existsSync(corruptRun), true);
+			assert.equal(result.deletedRuns, 2);
+			assert.equal(result.skipped["mission-reference"], 3);
+		} finally {
+			fs.rmSync(roots.root, { recursive: true, force: true });
+		}
+	});
+
 	it("uses one cleaner, reaps stale tombstones safely, and limits processed runs", async () => {
 		const roots = makeRoots();
 		try {
@@ -239,11 +291,11 @@ describe("async retention cleanup", () => {
 			fs.rmSync(liveLock, { recursive: true });
 			fs.mkdirSync(liveLock);
 			fs.writeFileSync(path.join(liveLock, "owner.json"), JSON.stringify({ version: 1, token: "old-token", pid: process.pid, hostname: "test-host", processStartIdentity: "old-process", startedAt: NOW - 60_000 }));
-			const reusedPidLockResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: () => "current-process" });
+			const reusedPidLockResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: async () => "current-process" });
 			assert.equal(reusedPidLockResult.acquired, true);
 			fs.mkdirSync(liveLock);
 			fs.writeFileSync(path.join(liveLock, "owner.json"), JSON.stringify({ version: 1, token: "other-token", pid: process.pid, hostname: "test-host", processStartIdentity: "current-process", startedAt: NOW - 60_000 }));
-			const protectedLockResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: () => "current-process" });
+			const protectedLockResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: async () => "current-process" });
 			assert.equal(protectedLockResult.acquired, false);
 			assert.equal(JSON.parse(fs.readFileSync(path.join(liveLock, "owner.json"), "utf-8")).token, "other-token");
 			fs.rmSync(liveLock, { recursive: true });
@@ -260,7 +312,7 @@ describe("async retention cleanup", () => {
 			})();
 			const cursorPath = path.join(roots.root, ".async-retention-cursor.json");
 			const cursorBeforeOwnerChange = fs.readFileSync(cursorPath, "utf-8");
-			const changedOwnerResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), randomId: () => "owned-token", protectedRunIds: mutatingReferences, hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: () => "current-process" });
+			const changedOwnerResult = await cleanupAsyncRetention({ ...cleanupOptions(roots), randomId: () => "owned-token", protectedRunIds: mutatingReferences, hostname: "test-host", processStartIdentity: "current-process", getProcessStartIdentity: async () => "current-process" });
 			assert.equal(changedOwnerResult.acquired, true);
 			assert.equal(changedOwnerResult.skipped["lock-owner-changed"], 1);
 			assert.equal(fs.readFileSync(cursorPath, "utf-8"), cursorBeforeOwnerChange);
@@ -317,7 +369,7 @@ describe("async retention cleanup", () => {
 				hostname: "test-host",
 				processStartIdentity: "cleaner-process",
 				isProcessAlive: (pid: number) => pid === reusedPid || pid === process.pid,
-				getProcessStartIdentity: (pid: number) => pid === reusedPid ? currentIdentity : "cleaner-process",
+				getProcessStartIdentity: async (pid: number) => pid === reusedPid ? currentIdentity : "cleaner-process",
 			};
 			const first = await cleanupAsyncRetention(options);
 			assert.equal(first.acquired, false);

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

@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { requestAsyncStop } from "../../src/runs/background/control-channel.ts";
+import { runSubagent, type SubagentRunConfig } from "../../src/runs/background/subagent-runner.ts";
+import type { RunEntry } from "../../src/runs/shared/run-history.ts";
+import { createFakeChildSessions } from "../support/fake-child-session.ts";
+
+// Integration coverage for the run-history wiring at the runner's terminal
+// publication: these tests run the real async runner with fake child sessions
+// and read the history file back, which the pure-mapper tests cannot cover.
+// The launch filter (only children that actually dispatched a child session
+// get a row) matters because stopRunner(), timeoutRunner(), fail-fast, and
+// usage-budget skips all relabel never-launched steps to terminal statuses.
+
+let previousAgentDir: string | undefined;
+let agentDir: string;
+
+beforeEach(() => {
+	previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
+	agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-history-agent-"));
+	fs.chmodSync(agentDir, 0o700);
+	process.env.SELESAI_CODING_AGENT_DIR = agentDir;
+});
+
+afterEach(() => {
+	if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
+	else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
+});
+
+function readHistoryRows(): RunEntry[] {
+	const historyPath = path.join(agentDir, "run-history.jsonl");
+	if (!fs.existsSync(historyPath)) return [];
+	return fs.readFileSync(historyPath, "utf-8")
+		.split("\n")
+		.filter((line) => line.trim().length > 0)
+		.map((line) => JSON.parse(line) as RunEntry);
+}
+
+function baseConfig(root: string, id: string, steps: SubagentRunConfig["steps"]): SubagentRunConfig {
+	const asyncDir = path.join(root, `${id}-async`);
+	fs.mkdirSync(asyncDir, { recursive: true });
+	return {
+		id, steps, resultPath: path.join(root, `${id}-result.json`), cwd: root,
+		asyncDir, sessionId: `session-${id}`, artifactConfig: { enabled: false }, share: false,
+		placeholder: "{previous}",
+	};
+}
+
+describe("async runner run-history rows", () => {
+	it("records no rows when a stop is queued before a two-step chain starts (0 sessions)", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-stop-"));
+		const queue = path.join(root, "queue");
+		fs.mkdirSync(queue, { recursive: true });
+		const fake = createFakeChildSessions(() => queue);
+		try {
+			const config = baseConfig(root, "stop-before-start", [
+				{ agent: "stop-a1", task: "first" },
+				{ agent: "stop-a2", task: "second" },
+			]);
+			requestAsyncStop(config.asyncDir, { source: "test" });
+			await runSubagent(config, fake.factory);
+			assert.equal(fake.sessions.length, 0, "no child session may be created");
+			const rows = readHistoryRows();
+			assert.equal(rows.filter((row) => row.agent === "stop-a1" || row.agent === "stop-a2").length, 0,
+				"never-launched steps must not get history rows, even though stopRunner relabels them to stopped");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("records a row only for the fail-fast child that ran, not for its skipped sibling", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-failfast-"));
+		const queue = path.join(root, "queue");
+		fs.mkdirSync(queue, { recursive: true });
+		fs.writeFileSync(path.join(queue, "pending-ff-first.json"), JSON.stringify({ matchArgIncludes: "ff-first", output: "boom", exitCode: 1 }));
+		fs.writeFileSync(path.join(queue, "default-response.json"), JSON.stringify({ output: "ok" }));
+		const fake = createFakeChildSessions(() => queue);
+		try {
+			await runSubagent(baseConfig(root, "fail-fast-skip", [
+				{ parallel: [{ agent: "ff-first", task: "runs and fails" }, { agent: "ff-second", task: "skipped sibling" }], concurrency: 1, failFast: true },
+			]), fake.factory);
+			assert.equal(fake.sessions.length, 1, "only the first child launches under concurrency 1 + fail-fast");
+			const rows = readHistoryRows();
+			assert.equal(rows.filter((row) => row.agent === "ff-second").length, 0,
+				"the fail-fast skipped child (failed/exitCode -1/skipped, startedAt set) must not get a row");
+			const first = rows.filter((row) => row.agent === "ff-first");
+			assert.equal(first.length, 1, "the child that really ran gets exactly one row");
+			assert.equal(first[0]?.status, "error");
+			assert.equal(first[0]?.outcome, "failed");
+			assert.equal(first[0]?.exit, 1);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("still records one row per launched step for a normally completing chain", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-history-chain-"));
+		const queue = path.join(root, "queue");
+		fs.mkdirSync(queue, { recursive: true });
+		fs.writeFileSync(path.join(queue, "default-response.json"), JSON.stringify({ output: "ok" }));
+		const fake = createFakeChildSessions(() => queue);
+		try {
+			await runSubagent(baseConfig(root, "chain-ok", [
+				{ agent: "chain-a1", task: "first" },
+				{ agent: "chain-a2", task: "second" },
+			]), fake.factory);
+			assert.equal(fake.sessions.length, 2);
+			const rows = readHistoryRows();
+			const a1 = rows.filter((row) => row.agent === "chain-a1");
+			const a2 = rows.filter((row) => row.agent === "chain-a2");
+			assert.equal(a1.length, 1);
+			assert.equal(a2.length, 1);
+			assert.equal(a1[0]?.status, "ok");
+			assert.equal(a1[0]?.outcome, "completed");
+			assert.ok(!("exit" in (a1[0] ?? {})), "successful rows omit exit");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});