@selesai/code 0.8.6 → 0.8.7

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

@@ -3,6 +3,7 @@ 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 { acquireActiveAsyncCapacity } from "../../src/runs/background/active-async-capacity.ts";
 import { consumeSteerRequests, consumeSteerRequestsFromDir, stepSteerInboxDir, writeSteerAck } from "../../src/runs/background/control-channel.ts";
 import { listAsyncRuns } from "../../src/runs/background/async-status.ts";
 import { inspectSubagentStatus } from "../../src/runs/background/run-status.ts";
@@ -125,6 +126,74 @@ function text(result: { content: Array<{ type: string; text?: string }> }): stri
 }
 
 describe("async interrupt action", () => {
+	it("routes debug.run to async lifecycle debug, not live foreground status", async () => {
+		const state = createState();
+		state.currentSessionId = "session";
+		const runId = `debug-foreground-${Date.now().toString(36)}`;
+		const asyncDir = createRunningAsync(state, runId, { track: false, sessionId: "session" });
+		state.foregroundControls.set(runId, {
+			runId,
+			sessionId: "session",
+			mode: "single",
+			startedAt: 100,
+			updatedAt: 100,
+			cwd: os.tmpdir(),
+			agent: "worker",
+			status: "running",
+			controller: new AbortController(),
+		});
+		try {
+			const result = await executorWithKill(state, () => true)
+				.execute("debug.run", { action: "debug.run", id: runId }, new AbortController().signal, undefined, ctx());
+			const output = text(result);
+
+			assert.equal(result.isError, undefined);
+			assert.match(output, /Run lifecycle debug/);
+			assert.doesNotMatch(output, /Live foreground/);
+		} finally {
+			state.foregroundControls.delete(runId);
+			cleanup(runId, asyncDir);
+		}
+	});
+
+	it("renders run lifecycle debug without transcript content", () => {
+		const state = createState();
+		state.currentSessionId = "session";
+		const runId = `debug-run-${Date.now().toString(36)}`;
+		const activeCapacityRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-debug-capacity-"));
+		const asyncDir = path.join(ASYNC_DIR, runId);
+		try {
+			const capacity = acquireActiveAsyncCapacity({ sessionId: "session", limit: 1, runId, kind: "workflow", asyncDir }, { rootDir: activeCapacityRoot });
+			assert.ok(capacity);
+			capacity.markWorkflowStarted();
+			writeJson(path.join(asyncDir, "status.json"), {
+				runId,
+				sessionId: "session",
+				mode: "workflow",
+				state: "complete",
+				startedAt: 100,
+				processTerminal: { version: 1, state: "pending", runId, runnerProcessInstanceId: "workflow-runner" },
+				steps: [{ agent: "worker", workflowKey: "review", status: "completed", async: false }],
+			});
+			fs.writeFileSync(path.join(asyncDir, "output-0.log"), "SECRET_TRANSCRIPT_TEXT", "utf-8");
+
+			const result = inspectSubagentStatus({ action: "debug.run", id: runId }, { state, activeCapacityRoot });
+			const output = text(result);
+
+			assert.match(output, /Run lifecycle debug/);
+			assert.match(output, new RegExp(`Run: ${runId}`));
+			assert.match(output, /Status process terminal: pending · runner workflow-runner/);
+			assert.match(output, /Sidecar process terminal: missing/);
+			assert.match(output, /Active capacity: releasable/);
+			assert.match(output, /Workflow children: 1/);
+			assert.match(output, /key review · worker · completed · async no/);
+			assert.doesNotMatch(output, /SECRET_TRANSCRIPT_TEXT/);
+		} finally {
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+			fs.rmSync(activeCapacityRoot, { recursive: true, force: true });
+		}
+	});
+
 	it("steers a live workflow-owned foreground child by child id", async () => {
 		const state = createState();
 		const workflowRunId = `workflow-child-${Date.now().toString(36)}`;
@@ -489,6 +558,13 @@ describe("async interrupt action", () => {
 			assert.match(statusText, /State: display-dismissed/);
 			assert.match(statusText, /No running work was terminated/);
 			assert.doesNotMatch(statusText, /Steer/);
+			const debugResult = inspectSubagentStatus({ action: "debug.run", id: runId }, { state, kill: () => {
+				throw new Error("dismissed workflow debug must not inspect the pid");
+			} });
+			const debugText = text(debugResult);
+			assert.match(debugText, /Run lifecycle debug/);
+			assert.match(debugText, /State: running/);
+			assert.match(debugText, /Active capacity: not-owned/);
 			const transcriptResult = inspectSubagentStatus({ action: "status", id: runId, view: "transcript" }, { state, kill: () => {
 				throw new Error("dismissed workflow transcript must not inspect the pid");
 			} });

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

@@ -113,10 +113,12 @@ describe("async resume lookup", () => {
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
 				...descriptor,
 				launchContractDigest: "launch-contract-digest",
+				intercomBridge: { mode: "off" },
 			});
 			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.deepEqual(valid.recoveryDescriptor?.intercomBridge, { mode: "off" });
 
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, sourceRunId: "another-run" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /different source run/);

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

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	ASYNC_STATUS_SNAPSHOT_KIND,
+	ASYNC_STATUS_SNAPSHOT_VERSION,
+	ASYNC_STATUS_SNAPSHOT_WIDGET_PREFIX,
+	buildAsyncStatusSnapshot,
+	buildAsyncStatusSnapshotForState,
+	encodeAsyncStatusSnapshotWidget,
+} from "../../src/runs/background/async-status-snapshot.ts";
+
+const privateNeedle = "PRIVATE_LEAK_NEEDLE";
+
+function json(value: unknown): string {
+	return JSON.stringify(value);
+}
+
+describe("async status snapshot", () => {
+	it("projects current async jobs with a versioned safe shape", () => {
+		const snapshot = buildAsyncStatusSnapshot([{
+			asyncId: "run-1",
+			asyncDir: `/tmp/${privateNeedle}/run`,
+			cwd: `/repo/${privateNeedle}`,
+			sessionRoot: `/sessions/${privateNeedle}`,
+			sessionDir: `/session-dir/${privateNeedle}`,
+			outputFile: `/output/${privateNeedle}.log`,
+			sessionFile: `/session-file/${privateNeedle}.jsonl`,
+			sessionId: "session-a",
+			status: "running",
+			mode: "parallel",
+			agents: ["worker"],
+			description: `task ${privateNeedle}`,
+			startedAt: 100,
+			updatedAt: 150,
+			currentTool: "bash\n\u001b]8;;bad\u0007",
+			currentPath: `/current/${privateNeedle}`,
+			steps: [{
+				index: 0,
+				agent: "worker",
+				status: "running",
+				startedAt: 110,
+				currentTool: "read",
+				currentToolArgs: `args ${privateNeedle}`,
+				recentOutput: [`output ${privateNeedle}`],
+				error: `error ${privateNeedle}`,
+				transcriptPath: `/transcript/${privateNeedle}.jsonl`,
+			}],
+		}], { generatedAt: 200 });
+
+		assert.equal(snapshot.kind, ASYNC_STATUS_SNAPSHOT_KIND);
+		assert.equal(snapshot.version, ASYNC_STATUS_SNAPSHOT_VERSION);
+		assert.equal(snapshot.generatedAt, 200);
+		assert.equal(snapshot.runs.length, 1);
+		assert.deepEqual(snapshot.runs[0], {
+			id: "run-1",
+			kind: "subagent",
+			label: "worker",
+			state: "running",
+			startedAt: 100,
+			updatedAt: 150,
+			activity: { currentTool: "bash" },
+			children: [{
+				id: "step:0",
+				kind: "step",
+				label: "worker",
+				state: "running",
+				startedAt: 110,
+				updatedAt: 110,
+				activity: { currentTool: "read" },
+			}],
+		});
+		assert.equal(json(snapshot).includes(privateNeedle), false);
+		assert.equal(json(snapshot).includes("currentPath"), false);
+		assert.equal(json(snapshot).includes("currentToolArgs"), false);
+		assert.equal(json(snapshot).includes("recentOutput"), false);
+		assert.equal(json(snapshot).includes("transcriptPath"), false);
+	});
+
+	it("normalizes pending child steps to queued", () => {
+		const snapshot = buildAsyncStatusSnapshot([{
+			asyncId: "run",
+			asyncDir: "/tmp/run",
+			status: "queued",
+			agents: ["worker"],
+			steps: [{ agent: "worker", status: "pending" }],
+		} as any], { generatedAt: 1 });
+
+		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "queued");
+	});
+
+	it("applies run, child, depth, string, and byte caps", () => {
+		const jobs = Array.from({ length: 5 }, (_, runIndex) => ({
+			asyncId: `run-${runIndex}`,
+			asyncDir: `/tmp/run-${runIndex}`,
+			status: "running" as const,
+			mode: "workflow" as const,
+			agents: [`agent-${runIndex}-${"x".repeat(50)}`],
+			startedAt: runIndex,
+			updatedAt: runIndex,
+			steps: Array.from({ length: 5 }, (_, stepIndex) => ({
+				agent: `child-${stepIndex}-${"y".repeat(50)}`,
+				status: "running" as const,
+				children: [{
+					id: `nested-${stepIndex}`,
+					parentRunId: `run-${runIndex}`,
+					depth: 1,
+					path: [],
+					state: "running" as const,
+					agent: "nested",
+				}],
+			})),
+		}));
+
+		const snapshot = buildAsyncStatusSnapshot(jobs, {
+			generatedAt: 10,
+			maxRuns: 2,
+			maxChildrenPerNode: 2,
+			maxDepth: 1,
+			maxStringLength: 16,
+			maxSerializedBytes: 1200,
+		});
+
+		assert.equal(snapshot.runs.length, 2);
+		assert.equal(snapshot.omitted.runs, 3);
+		assert.equal(snapshot.runs[0]?.children?.length, 2);
+		assert.ok(snapshot.omitted.children >= 6);
+		assert.ok((snapshot.runs[0]?.label.length ?? 0) <= 16);
+		assert.ok(Buffer.byteLength(json(snapshot), "utf8") <= 1200);
+
+		const byteCapped = buildAsyncStatusSnapshot(jobs, { maxSerializedBytes: 512 });
+		assert.equal(byteCapped.omitted.byteLimitExceeded, true);
+		assert.ok(Buffer.byteLength(json(byteCapped), "utf8") <= 512);
+	});
+
+	it("uses current-session state and retained fleet jobs without rebuilding history", () => {
+		const state = {
+			currentSessionId: "session-a",
+			foregroundControls: new Map(),
+			asyncJobs: new Map([["active", { asyncId: "active", asyncDir: "/tmp/active", sessionId: "session-a", status: "running", agents: ["worker"] }]]),
+			fleetJobs: new Map([
+				["terminal", { asyncId: "terminal", asyncDir: "/tmp/terminal", sessionId: "session-a", status: "complete", agents: ["reviewer"], updatedAt: 300, outputFile: `/tmp/${privateNeedle}.log` }],
+				["foreign", { asyncId: "foreign", asyncDir: "/tmp/foreign", sessionId: "other", status: "running", agents: ["hidden"] }],
+			]),
+		} as any;
+
+		const snapshot = buildAsyncStatusSnapshotForState(state, "session-a", { generatedAt: 1 });
+		assert.deepEqual(snapshot.runs.map((run) => run.id).sort(), ["active", "terminal"]);
+		assert.equal(snapshot.runs.find((run) => run.id === "terminal")?.endedAt, 300);
+		assert.equal(json(snapshot).includes(privateNeedle), false);
+		assert.deepEqual(buildAsyncStatusSnapshotForState(state, "other").runs, []);
+	});
+
+	it("encodes RPC widget payloads as a string-array snapshot", () => {
+		const lines = encodeAsyncStatusSnapshotWidget([{ asyncId: "run", asyncDir: "/tmp/run", status: "queued", agents: ["planner"] } as any], { generatedAt: 5 });
+		assert.equal(lines.length, 1);
+		assert.ok(lines[0]?.startsWith(ASYNC_STATUS_SNAPSHOT_WIDGET_PREFIX));
+		const snapshot = JSON.parse(lines[0]!.slice(ASYNC_STATUS_SNAPSHOT_WIDGET_PREFIX.length));
+		assert.equal(snapshot.kind, ASYNC_STATUS_SNAPSHOT_KIND);
+		assert.equal(snapshot.version, 1);
+		assert.equal(snapshot.runs[0].id, "run");
+	});
+});

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

@@ -25,17 +25,216 @@ function assistantText(text: string): Message {
 }
 
 test("implementation task with no mutation triggers the completion guard", () => {
-	const result = evaluateCompletionMutationGuard({
-		agent: "worker",
-		task: "Implement the approved fix",
-		messages: [assistantText("Plan: update the files...")],
-	});
+	for (const report of [
+		"No better current-scope change is needed.",
+		"Kept the current implementation. No new code or test changes were made in this challenge pass.",
+	]) {
+		const result = evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: "Implement the approved fix",
+			messages: [assistantText(report)],
+		});
+
+		assert.deepEqual(result, {
+			expectedMutation: true,
+			attemptedMutation: false,
+			triggered: true,
+		});
+	}
+});
+
+function revivedTask(followUp: string): string {
+	return [
+		"You are reviving a previous subagent conversation.",
+		"",
+		"Original run: abc123",
+		"Original agent: worker",
+		"Original session file: /tmp/session.jsonl",
+		"",
+		"Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child process is still alive.",
+		"",
+		"Follow-up:",
+		followUp,
+	].join("\n");
+}
+
+const implementationChallengeTask = revivedTask("Run implementation challenge pass two and implement any better current-scope change.");
+
+test("implementation challenges may complete with explicit no-change reports", () => {
+	for (const report of [
+		"No better current-scope change is needed.",
+		[
+			"Kept the current implementation. No new code or test changes were made in this challenge pass.",
+			"Reason: the current candidate is the smallest correct shape.",
+		].join("\n\n"),
+		"The current implementation was kept. No code changes were made.",
+		"The current candidate was kept. No source changes were made.",
+		"The current shape was kept. No file or test changes were made.",
+		"Kept the current implementation. No code/source/file/test changes were made.",
+		"Kept the current implementation. No code, source, or test changes were made.",
+		"No better current-scope change is needed.\n\nReason: I cannot identify a smaller safe change.",
+		"No better current-scope change is needed because I did not identify a smaller safe change.",
+		"No better current-scope change is needed because no work remains.",
+		"No better current-scope change is needed. I haven't identified required changes.",
+		"No better current-scope change is needed. I haven’t identified required changes.",
+		"No better current-scope change is needed; I did not identify a smaller safe change.",
+		"No better current-scope change is needed, since I did not identify a smaller safe change.",
+		"No better current-scope change is needed, I did not identify a smaller safe change.",
+		"No better current-scope change is needed, the current implementation does not require further edits.",
+		"No better current-scope change is needed; the current implementation does not require further edits.",
+		"No better current-scope change is needed, but the current implementation does not require further edits.",
+		"Kept the current implementation. No code changes were made.\n\nReason: this does not need a broader rewrite.",
+		"Kept the current implementation; I did not identify a smaller safe change. No code changes were made.",
+		"Kept the current implementation. No code changes were made, since I did not identify a smaller safe change.",
+		"Kept the current implementation. No code changes were made, I did not identify a smaller safe change.",
+		"Kept the current implementation, the current candidate does not need more work. No code changes were made.",
+		"Kept the current implementation; the current candidate does not need more work. No code changes were made.",
+		"Kept the current implementation because I did not identify a smaller safe change. No code changes were made.",
+		"Kept the current implementation. No code changes were made because I did not identify a smaller safe change.",
+	]) {
+		const result = evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: implementationChallengeTask,
+			messages: [assistantText(report)],
+		});
+
+		assert.deepEqual(result, {
+			expectedMutation: true,
+			attemptedMutation: false,
+			triggered: false,
+		});
+	}
+});
+
+test("implementation challenge reports require both a kept-current rationale and no-change statement", () => {
+	for (const report of [
+		"Kept the current implementation.",
+		"No new code or test changes were made in this challenge pass.",
+		"Kept the current implementation. No new code or test changes were made, but I am uncertain.",
+	]) {
+		assert.equal(evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: implementationChallengeTask,
+			messages: [assistantText(report)],
+		}).triggered, true, report);
+	}
+});
+
+test("implementation challenge reports require current kept/no-change claims", () => {
+	for (const report of [
+		"The previous message said \"Kept the current implementation. No code changes were made\".",
+		"The prior report stated Kept the current implementation. No code changes were made.",
+		"The previous message said \"Kept the current implementation. No code changes were made\". Kept the current implementation.",
+		"'Kept the current implementation. No code changes were made.'",
+	]) {
+		assert.equal(evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: implementationChallengeTask,
+			messages: [assistantText(report)],
+		}).triggered, true, report);
+	}
+});
+
+test("implementation challenge reports with later implementation retractions remain guarded", () => {
+	for (const report of [
+		"No better current-scope change is needed. I found a required code change.",
+		"Kept the current implementation. No code changes were made. Implementation work remains.",
+		"No better current-scope change is needed. A code change is needed.",
+		"Kept the current implementation. No code changes were made. I need to implement the fix.",
+		"No better current-scope change is needed, but I found a required code change.",
+		"No better current-scope change is needed\nI found a required code change.",
+		"No better current-scope change is needed. I found required changes.",
+		"No better current-scope change is needed. Code changes are needed.",
+		"No better current-scope change is needed. Changes are needed.",
+		"No better current-scope change is needed because no work remains. Code changes are needed.",
+		"No better current-scope change is needed. I need changes.",
+		"No better current-scope change is needed. We need edits.",
+		"Kept the current implementation. No code changes were made. I need changes.",
+		"Kept the current implementation. No code changes were made. We need patches.",
+		"No better current-scope change is needed. That claim is rejected.",
+		"No better current-scope change is needed. This report is retracted.",
+		"No better current-scope change is needed. Required changes.",
+		"No better current-scope change is needed. Need changes.",
+		"No better current-scope change is needed, I disagree.",
+		"No better current-scope change is needed; I disagree.",
+		"Kept the current implementation. No code changes were made, I reject.",
+		"Kept the current implementation. No code changes were made; I reject.",
+		"No better current-scope change is needed: I disagree.",
+		"No better current-scope change is needed — I disagree.",
+		"No better current-scope change is needed. \"I reject.\"",
+		"No better current-scope change is needed. 'I reject.'",
+		"No better current-scope change is needed. ‘I reject.’",
+		"Kept the current implementation. No code changes were made: I reject.",
+		"Kept the current implementation. No code changes were made. \"I retract.\"",
+		"No better current-scope change is needed. I disagree.",
+		"No better current-scope change is needed. I reject.",
+		"No better current-scope change is needed. I retract.",
+		"Kept the current implementation. No code changes were made. I disagree.",
+		"Kept the current implementation. No code changes were made. I reject.",
+		"Kept the current implementation. No code changes were made. I retract.",
+		"No better current-scope change is needed. I disagree with that.",
+		"No better current-scope change is needed. I retract that.",
+		"No better current-scope change is needed. I reject that.",
+		"Kept the current implementation. No code changes were made. I disagree with that.",
+		"Kept the current implementation. No code changes were made. I retract that.",
+		"Kept the current implementation. No code changes were made. I reject that.",
+	]) {
+		assert.equal(evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: implementationChallengeTask,
+			messages: [assistantText(report)],
+		}).triggered, true, report);
+	}
+});
+
+test("revived implementation tasks that mention implementation challenge remain guarded", () => {
+	for (const followUp of [
+		"Fix the implementation challenge completion guard bug.",
+		"Implementation challenge pass 1. Implement the required fix.",
+		"Implementation challenge pass 1 and implement the fix.",
+	]) {
+		const result = evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: revivedTask(followUp),
+			messages: [assistantText("No better current-scope change is needed.")],
+		});
+
+		assert.deepEqual(result, {
+			expectedMutation: true,
+			attemptedMutation: false,
+			triggered: true,
+		}, followUp);
+	}
+});
+
+test("implementation challenge reports with negated or uncertain no-better-change claims remain guarded", () => {
+	for (const report of [
+		"I cannot say no better current-scope change is needed.",
+		"The previous message said \"No better current-scope change is needed\", but I disagree.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but I disagree.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but that was wrong.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but that was false.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but I reject that.",
+		"The previous message said \"Kept the current implementation. No code changes were made\". I reject that.",
+		"The previous message said \"Kept the current implementation. No code changes were made\". I reject this.",
+		"The previous message said \"Kept the current implementation. No code changes were made\". I disagree.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but it was rejected.",
+		"The previous message said \"Kept the current implementation. No code changes were made\", but I am rejecting it.",
+		"The prior report stated no better current-scope change is needed.",
+		"I don't think no better current-scope change is needed.",
+		"I dont think no better current-scope change is needed.",
+		"I do not think no better current-scope change is needed.",
+		"I cant say no better current-scope change is needed.",
+		"It is unclear whether no better current-scope change is needed.",
+		"Maybe no better current-scope change is needed.",
+	]) {
+		assert.equal(evaluateCompletionMutationGuard({
+			agent: "worker",
+			task: implementationChallengeTask,
+			messages: [assistantText(report)],
+		}).triggered, true, report);
+	}
 
-	assert.deepEqual(result, {
-		expectedMutation: true,
-		attemptedMutation: false,
-		triggered: true,
-	});
 });
 
 test("declared read-only builtin tools suppress implementation-word false positives", () => {

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

@@ -4,7 +4,7 @@ import { createRequire, syncBuiltinESMExports } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { describe, it } from "node:test";
-import { cleanupCompletionReplay, completionArchivePath, readCompletionArchive, readCompletionReplay, writeCompletionArchive } from "../../src/runs/background/completion-replay.ts";
+import { cleanupCompletionReplay, completionArchivePath, completionReplayPath, readCompletionArchive, readCompletionReplay, writeCompletionReplay, writeCompletionArchive } from "../../src/runs/background/completion-replay.ts";
 import { utf8Tail } from "../../src/shared/utf8.ts";
 import { collectWaitCompletions, recordWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 import type { AsyncRunSummary } from "../../src/runs/background/async-status.ts";
@@ -161,6 +161,46 @@ describe("completion replay", () => {
 		}
 	});
 
+	it("throttles cleanup while writing completion replay records", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-replay-throttle-"));
+		const originalReaddirSync = fsCjs.readdirSync;
+		let cleanupScans = 0;
+		try {
+			fsCjs.readdirSync = ((target: Parameters<typeof fs.readdirSync>[0], options?: Parameters<typeof fs.readdirSync>[1]) => {
+				if (String(target).includes(`${path.sep}completion-replay`)) cleanupScans += 1;
+				return originalReaddirSync(target, options as never);
+			}) as typeof fs.readdirSync;
+			syncBuiltinESMExports();
+
+			writeCompletionReplay({
+				resultsDir: root,
+				runId: "run-a",
+				sessionId: "session-a",
+				completion: { runId: "run-a" },
+				data: { summary: "done" },
+				now: 10_000,
+				ttlMs: 60_000,
+			});
+			writeCompletionReplay({
+				resultsDir: root,
+				runId: "run-b",
+				sessionId: "session-a",
+				completion: { runId: "run-b" },
+				data: { summary: "done" },
+				now: 10_001,
+				ttlMs: 60_000,
+			});
+
+			assert.equal(cleanupScans, 1);
+			assert.equal(fs.existsSync(completionReplayPath(root, "run-a")), true);
+			assert.equal(fs.existsSync(completionReplayPath(root, "run-b")), true);
+		} finally {
+			fsCjs.readdirSync = originalReaddirSync;
+			syncBuiltinESMExports();
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("prefers saved outputs and bounds fallback output tails", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-completion-archive-"));
 		try {