@selesai/code 0.12.0 → 0.13.1

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

@@ -47,6 +47,12 @@ function writeOldResult(resultsDir: string, runId: string, overrides: Record<str
 	return resultPath;
 }
 
+function errno(code: string): NodeJS.ErrnoException {
+	const error = new Error(code) as NodeJS.ErrnoException;
+	error.code = code;
+	return error;
+}
+
 function cleanupOptions(roots: ReturnType<typeof makeRoots>) {
 	return {
 		...roots,
@@ -64,6 +70,53 @@ function writeRunTombstoneMarker(roots: ReturnType<typeof makeRoots>, runId: str
 }
 
 describe("async retention cleanup", () => {
+	it("repairs bounded dead running candidates before retention classification", async () => {
+		const roots = makeRoots();
+		try {
+			const runDir = writeOldRun(roots.asyncDirRoot, "dead-running", {
+				state: "running",
+				endedAt: undefined,
+				lastUpdate: OLD,
+				pid: 12345,
+				sessionId: "session-a",
+				steps: [{ agent: "worker", status: "running" }],
+			});
+			fs.mkdirSync(path.join(roots.asyncDirRoot, ".active-runs"));
+			fs.writeFileSync(path.join(roots.asyncDirRoot, ".active-runs", "dead-running"), "");
+			const protectedDir = writeOldRun(roots.asyncDirRoot, "protected-running", {
+				state: "running",
+				endedAt: undefined,
+				lastUpdate: OLD,
+				pid: 12346,
+				steps: [{ agent: "worker", status: "running" }],
+			});
+
+			const repaired = await cleanupAsyncRetention({
+				...cleanupOptions(roots),
+				protectedRunIds: ["protected-running"],
+				reconcileKill: () => { throw errno("ESRCH"); },
+			});
+
+			assert.equal(repaired.repairedRuns, 1);
+			assert.equal(repaired.deletedRuns, 0);
+			assert.equal(repaired.skipped.recent, 1);
+			assert.equal(JSON.parse(fs.readFileSync(path.join(runDir, "status.json"), "utf-8")).state, "failed");
+			assert.equal(fs.existsSync(path.join(roots.asyncDirRoot, ".active-runs", "dead-running")), false);
+			assert.equal(fs.existsSync(path.join(roots.resultsDir, "dead-running.json")), true);
+			assert.equal(JSON.parse(fs.readFileSync(path.join(protectedDir, "status.json"), "utf-8")).state, "running");
+			assert.equal(repaired.skipped["runtime-reference"], 1);
+
+			const retained = await cleanupAsyncRetention({
+				...cleanupOptions(roots),
+				now: () => NOW + 45 * DAY_MS,
+			});
+			assert.equal(retained.deletedRuns, 1);
+			assert.equal(fs.existsSync(runDir), false);
+		} finally {
+			fs.rmSync(roots.root, { recursive: true, force: true });
+		}
+	});
+
 	it("deletes old proven-terminal runs and orphan results through tombstones", async () => {
 		const roots = makeRoots();
 		try {

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

@@ -0,0 +1,190 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AsyncJobState, HostStepNodeV1 } from "../../src/shared/types.ts";
+import {
+	ASYNC_STATUS_SNAPSHOT_KIND,
+	ASYNC_STATUS_SNAPSHOT_VERSION,
+	projectAsyncWorkflowRows,
+	projectAsyncStatusSnapshot,
+} from "../../src/runs/shared/async-status-projection.ts";
+
+function job(input: Partial<AsyncJobState> & Pick<AsyncJobState, "asyncId" | "status">): AsyncJobState {
+	return {
+		asyncDir: `/tmp/${input.asyncId}`,
+		...input,
+	} as AsyncJobState;
+}
+
+function hostStep(overrides: Partial<HostStepNodeV1> = {}): HostStepNodeV1 {
+	return {
+		version: 1,
+		kind: "host-step",
+		monitorKind: "ci",
+		id: "ci-check",
+		label: "CI checks",
+		provider: "github-ci",
+		state: "done",
+		verdict: "pass",
+		updatedAt: 20,
+		...overrides,
+	};
+}
+
+describe("async status projection", () => {
+	it("projects already-loaded jobs in deterministic newest-first order", () => {
+		const snapshot = projectAsyncStatusSnapshot([
+			job({ asyncId: "older", status: "complete", agents: ["reviewer"], updatedAt: 10 }),
+			job({
+				asyncId: "newer",
+				status: "running",
+				mode: "workflow",
+				agents: ["worker"],
+				updatedAt: 20,
+				steps: [{ agent: "worker", status: "pending" }],
+			}),
+		], { generatedAt: 30 });
+
+		assert.equal(snapshot.kind, ASYNC_STATUS_SNAPSHOT_KIND);
+		assert.equal(snapshot.version, ASYNC_STATUS_SNAPSHOT_VERSION);
+		assert.equal(snapshot.generatedAt, 30);
+		assert.deepEqual(snapshot.runs.map(({ id, kind, state }) => ({ id, kind, state })), [
+			{ id: "newer", kind: "workflow", state: "running" },
+			{ id: "older", kind: "subagent", state: "complete" },
+		]);
+		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "queued");
+	});
+
+	it("preserves partial needs-attention status while excluding private evidence", () => {
+		const snapshot = projectAsyncStatusSnapshot([job({
+			asyncId: "partial-run",
+			status: "partial",
+			agents: ["writer"],
+			activityState: "needs_attention",
+			steps: [{
+				agent: "writer",
+				status: "partial",
+				activityState: "needs_attention",
+				error: "Required file-only output was not produced: /private/report.md",
+				effects: { fileMutation: true },
+			}],
+		})], { generatedAt: 1 });
+
+		assert.equal(snapshot.runs[0]?.state, "partial");
+		assert.equal(snapshot.runs[0]?.activity?.state, "needs_attention");
+		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "partial");
+		assert.equal(snapshot.runs[0]?.children?.[0]?.activity?.state, "needs_attention");
+		const serialized = JSON.stringify(snapshot);
+		assert.doesNotMatch(serialized, /private\/report|fileMutation|Required file-only output/);
+	});
+
+	it("projects compact Fleet workflow rows without applying UI bounds", () => {
+		const rows = projectAsyncWorkflowRows([{
+			agent: "reviewer",
+			workflowKey: "review",
+			label: "Fresh review",
+			phase: "quality",
+			status: "partial",
+			activityState: "needs_attention",
+			startedAt: 10,
+			tokens: { input: 20, output: 5, total: 25, window: 18 },
+		}]);
+
+		assert.deepEqual(rows, [{
+			name: "quality: review · Fresh review (reviewer)",
+			state: "partial",
+			activity: "needs attention",
+			startedAt: 10,
+			tokens: 25,
+			window: 18,
+		}]);
+	});
+
+	it("projects typed CI and gate host rows without treating them as child agents", () => {
+		const rows = projectAsyncWorkflowRows([], {
+			runId: "workflow-1",
+			mode: "workflow",
+			phases: [],
+			nodes: [
+				{ id: "ci-check", kind: "host-step", label: "CI checks", status: "completed", hostStep: hostStep() },
+				{ id: "review-gate", kind: "host-step", label: "Review gate", status: "completed", hostStep: hostStep({ id: "review-gate", monitorKind: "gate", label: "Review gate", verdict: "inconclusive", reasonCode: "stale-head", detail: "head changed", target: "PR #1614", freshness: { expectedRef: "old-head", observedRef: "new-head", stale: true }, reportPath: "/tmp/reports/gate.json" }) },
+			],
+		});
+
+		assert.deepEqual(rows, [
+			{ name: "CI checks", kind: "ci", state: "done", provider: "github-ci", verdict: "pass" },
+			{ name: "Review gate", kind: "gate", state: "done", provider: "github-ci", verdict: "inconclusive", reasonCode: "stale-head", detail: "head changed", target: "PR #1614", freshness: { expectedRef: "old-head", observedRef: "new-head", stale: true }, reportPath: "gate.json" },
+		]);
+	});
+
+	it("projects done host steps without verdicts as partial", () => {
+		const snapshot = projectAsyncStatusSnapshot([job({
+			asyncId: "inconclusive-gate",
+			status: "running",
+			hostSteps: [hostStep({ verdict: undefined })],
+		})]);
+
+		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "partial");
+	});
+
+	it("reserves bounded snapshot capacity for host steps", () => {
+		const snapshot = projectAsyncStatusSnapshot([job({
+			asyncId: "bounded-gate",
+			status: "running",
+			steps: [
+				{ agent: "first", status: "running" },
+				{ agent: "second", status: "running" },
+			],
+			hostSteps: [hostStep()],
+		})], { maxChildrenPerNode: 2 });
+
+		assert.deepEqual(snapshot.runs[0]?.children?.map(({ kind, id }) => ({ kind, id })), [
+			{ kind: "step", id: "step:0" },
+			{ kind: "host-step", id: "ci-check" },
+		]);
+		assert.equal(snapshot.omitted.children, 1);
+	});
+
+	it("omits malformed host nodes instead of rendering them as agents", () => {
+		const rows = projectAsyncWorkflowRows([], {
+			runId: "workflow-1",
+			mode: "workflow",
+			phases: [],
+			nodes: [{ id: "bad", kind: "host-step", label: "bad", status: "running" }],
+		});
+		assert.deepEqual(rows, []);
+	});
+
+	it("projects stored preflight lanes as planned rows and merges launched facts", () => {
+		const rows = projectAsyncWorkflowRows([
+			{ agent: "worker", workflowKey: "writer", label: "Writer", status: "running" },
+		], {
+			version: 1,
+			coverage: "complete",
+			lanes: [
+				{ key: "writer", mode: "mutation", claims: ["src/a.ts"] },
+				{ key: "review", mode: "review", expectedOutput: "review.md" },
+			],
+		});
+
+		assert.deepEqual(rows.map((row) => ({ name: row.name, state: row.state, mode: row.preflight?.mode })), [
+			{ name: "writer · Writer (worker)", state: "running", mode: "mutation" },
+			{ name: "review", state: "planned", mode: "review" },
+		]);
+	});
+
+	it("preserves duplicate loaded rows when a declared lane key is reused", () => {
+		const rows = projectAsyncWorkflowRows([
+			{ agent: "worker", workflowKey: "writer", label: "First", status: "complete" },
+			{ agent: "worker", workflowKey: "writer", label: "Second", status: "running" },
+		], {
+			version: 1,
+			coverage: "partial",
+			lanes: [{ key: "writer", mode: "mutation" }],
+		});
+
+		assert.deepEqual(rows.map((row) => ({ name: row.name, state: row.state })), [
+			{ name: "writer · First (worker)", state: "complete" },
+			{ name: "writer · Second (worker)", state: "running" },
+		]);
+	});
+});

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

@@ -88,6 +88,48 @@ describe("async status snapshot", () => {
 		assert.equal(snapshot.runs[0]?.children?.[0]?.state, "queued");
 	});
 
+	it("projects loaded host CI/gate nodes with bounded provider-neutral metadata", () => {
+		const snapshot = buildAsyncStatusSnapshot([{
+			asyncId: "workflow-1",
+			asyncDir: "/tmp/workflow-1",
+			status: "running",
+			mode: "workflow",
+			agents: [],
+			hostSteps: [{
+				version: 1,
+				kind: "host-step",
+				monitorKind: "gate",
+				id: "gate-1",
+				label: "Gate",
+				provider: "opaque-provider",
+				state: "done",
+				verdict: "inconclusive",
+				reasonCode: "stale-head",
+				freshness: { expectedRef: "old", observedRef: "new", stale: true },
+				reportPath: "/private/reports/gate.json",
+				updatedAt: 100,
+			}],
+		}] as any, { generatedAt: 200 });
+
+		assert.deepEqual(snapshot.runs[0]?.children, [{
+			id: "gate-1",
+			kind: "host-step",
+			label: "Gate",
+			state: "partial",
+			updatedAt: 100,
+			endedAt: 100,
+			hostStep: {
+				kind: "gate",
+				provider: "opaque-provider",
+				state: "done",
+				verdict: "inconclusive",
+				reasonCode: "stale-head",
+				stale: true,
+				report: "gate.json",
+			},
+		}]);
+	});
+
 	it("applies run, child, depth, string, and byte caps", () => {
 		const jobs = Array.from({ length: 5 }, (_, runIndex) => ({
 			asyncId: `run-${runIndex}`,

package/dist/extensions/pi-subagents/test/unit/auto-drain.test.ts

@@ -7,11 +7,15 @@ function state(sessionId: string | null = "session-a"): SubagentState {
 	return { currentSessionId: sessionId } as SubagentState;
 }
 
-function waitResult(text: string, isError = false) {
+function waitResult(text: string, isError = false, windowElapsed = false) {
 	return {
 		content: [{ type: "text" as const, text }],
 		...(isError ? { isError: true } : {}),
-		details: { mode: "management" as const, results: [] } satisfies Details,
+		details: {
+			mode: "management" as const,
+			results: [],
+			...(windowElapsed ? { wait: { reason: "window_elapsed" as const, timedOut: true as const, activeRunIds: ["run-a"], activeProviderItems: [] } } : {}),
+		} satisfies Details,
 	};
 }
 
@@ -59,7 +63,7 @@ describe("headless background-work auto-drain", () => {
 		}), /provider reconcile failed/);
 	});
 
-	it("enforces one absolute timeout across repeated drains", async () => {
+	it("keeps its absolute deadline strict after a non-error wait window elapses", async () => {
 		let clock = 0;
 		await assert.rejects(() => drainOutstandingWork({
 			state: state(),
@@ -68,7 +72,7 @@ describe("headless background-work auto-drain", () => {
 			hasWork: () => true,
 			wait: async () => {
 				clock = 101;
-				return waitResult("first batch done");
+				return waitResult("Wait window elapsed; work remains active.", false, true);
 			},
 		}), /timed out after 100ms.*session 'session-a'/);
 	});

package/dist/extensions/pi-subagents/test/unit/background-work.test.ts

@@ -127,6 +127,29 @@ describe("background-work provider protocol", () => {
 		assert.throws(() => snapshotBackgroundWork("session-a"), /duplicate item 'job'/);
 	});
 
+	it("accepts path-like session ids up to the bound and rejects longer ids", () => {
+		const longSessionId = `${"/nested/".repeat(511)}xsession`;
+		const overBoundSessionId = `${longSessionId}x`;
+		assert.equal(longSessionId.length, 4_096);
+
+		registerBackgroundWorkProvider({
+			name: "patty",
+			listActiveWork: () => [{ id: "job", sessionId: longSessionId }],
+		});
+		assert.deepEqual(snapshotBackgroundWork(longSessionId), {
+			providers: ["patty"],
+			items: [{ provider: "patty", id: "job", sessionId: longSessionId }],
+		});
+		assert.throws(() => snapshotBackgroundWork(overBoundSessionId), /at most 4096 characters/);
+
+		clearRegistry();
+		registerBackgroundWorkProvider({
+			name: "patty",
+			listActiveWork: () => [{ id: "job", sessionId: overBoundSessionId }],
+		});
+		assert.throws(() => snapshotBackgroundWork("session-a"), /at most 4096 characters/);
+	});
+
 	it("preserves list and reconcile errors with provider context", () => {
 		registerBackgroundWorkProvider({
 			name: "broken-reconcile",

package/dist/extensions/pi-subagents/test/unit/chain-root-attachment.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 { afterEach, beforeEach, describe, it } from "node:test";
+import { writePendingAsyncResultFile } from "../../src/runs/background/result-files.ts";
 import { waitForImportedAsyncRoot } from "../../src/runs/background/chain-root-attachment.ts";
 
 let tempDir: string;
@@ -44,7 +45,7 @@ describe("async chain root attachment", () => {
 		writeJson(importedRoot.resultPath, {
 			state: "complete",
 			success: true,
-			results: [{ agent: "worker", output: "root output", success: true, sessionFile }],
+		results: [{ agent: "worker", output: "root output", success: true, sessionFile, usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.001, turns: 1 } }],
 		});
 
 		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
@@ -54,14 +55,41 @@ describe("async chain root attachment", () => {
 			output: result.output,
 			exitCode: result.exitCode,
 			sessionFile: result.sessionFile,
+			usage: result.usage,
 		}, {
 			agent: "worker",
 			output: "root output",
 			exitCode: 0,
 			sessionFile,
+			usage: { input: 100, output: 50, cacheRead: 0, cacheWrite: 0, cost: 0.001, turns: 1 },
 		});
 	});
 
+	it("imports a session-indexed pending result before terminal status fallback", async () => {
+		const importedRoot = { ...root(), resultPath: path.join(tempDir, "root-run", "workflow-result.json") };
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "complete",
+			sessionId: "session-a",
+			startedAt: 1,
+			steps: [{ agent: "worker", status: "complete" }],
+		});
+		writePendingAsyncResultFile(importedRoot.resultPath, {
+			id: importedRoot.runId,
+			runId: importedRoot.runId,
+			sessionId: "session-a",
+			state: "complete",
+			success: true,
+			results: [{ agent: "worker", output: "pending root output", success: true }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1, terminalResultGraceMs: 0 });
+
+		assert.equal(result.output, "pending root output");
+		assert.equal(result.exitCode, 0);
+	});
+
 	it("waits for a running async child to write its terminal result", async () => {
 		const importedRoot = root();
 		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
@@ -111,6 +139,55 @@ describe("async chain root attachment", () => {
 		assert.equal(result.output, "root failed");
 	});
 
+	it("imports a partial root without collapsing it to failed", async () => {
+		const importedRoot = root();
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "partial",
+			activityState: "needs_attention",
+			startedAt: 1,
+			error: "Required file-only output was not produced: report.md",
+			steps: [{ agent: "worker", status: "failed", activityState: "needs_attention", error: "Required file-only output was not produced: report.md" }],
+		});
+		writeJson(importedRoot.resultPath, {
+			state: "partial",
+			success: false,
+			summary: "Required file-only output was not produced: report.md",
+			results: [{ agent: "worker", output: "Required file-only output was not produced: report.md", error: "Required file-only output was not produced: report.md", success: false, effects: { fileMutation: { status: "observed", expected: true, attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } } }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, { pollIntervalMs: 1 });
+
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.error, "Required file-only output was not produced: report.md");
+		assert.equal(result.execution?.status, "partial");
+		assert.deepEqual(result.effects?.fileMutation?.evidence?.changedFiles, ["input.md"]);
+	});
+
+	it("fails a partial root that never produced a result file", async () => {
+		const importedRoot = root();
+		const effects = { fileMutation: { status: "observed", expected: true, attempted: true, evidence: { source: "tracked-files", trackedOnly: true, cwd: tempDir, changedFiles: ["input.md"], attemptedMutation: true } } };
+		writeJson(path.join(importedRoot.asyncDir, "status.json"), {
+			runId: importedRoot.runId,
+			mode: "single",
+			state: "partial",
+			startedAt: 1,
+			error: "Required file-only output was not produced: report.md",
+			steps: [{ agent: "worker", status: "failed", activityState: "needs_attention", error: "Required file-only output was not produced: report.md", effects }],
+		});
+
+		const result = await waitForImportedAsyncRoot(importedRoot, {
+			pollIntervalMs: 1,
+			terminalResultGraceMs: 0,
+		});
+
+		assert.equal(result.exitCode, 1);
+		assert.equal(result.error, "Required file-only output was not produced: report.md");
+		assert.equal(result.execution?.status, "partial");
+		assert.deepEqual(result.effects?.fileMutation?.evidence?.changedFiles, ["input.md"]);
+	});
+
 	it("fails a terminal root that never produced a result file", async () => {
 		const importedRoot = root();
 		writeJson(path.join(importedRoot.asyncDir, "status.json"), {

package/dist/extensions/pi-subagents/test/unit/child-launch-plan.test.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import { planChildLaunch, resolveStepBehavior } from "../../src/runs/shared/child-launch-plan.ts";
+
+const agent = {
+	name: "worker",
+	output: "report.md",
+	outputMode: "file-only",
+	defaultReads: ["brief.md"],
+	defaultProgress: true,
+	skills: ["typescript"],
+	model: "openai-codex/gpt-5.6-luna",
+	fast: true,
+} as AgentConfig;
+
+describe("child launch planning", () => {
+	it("resolves cwd, behavior, skills, model, and output path without side effects", () => {
+		const runnerCwd = path.join("/tmp", "repo");
+		const resolvedRunnerCwd = path.resolve(runnerCwd);
+		const plan = planChildLaunch({
+			agentConfig: agent,
+			stepOverrides: { skills: ["review"], outputMode: "inline" },
+			task: "Implement the change",
+			runnerCwd,
+			runtimeCwd: runnerCwd,
+			stepCwdInput: "packages/cli",
+			chainSkills: ["shared"],
+		});
+
+		assert.equal(plan.stepCwd, path.join(resolvedRunnerCwd, "packages/cli"));
+		assert.equal(plan.instructionCwd, plan.stepCwd);
+		assert.equal(plan.readExistenceCwd, plan.stepCwd);
+		assert.equal(plan.outputPath, path.join(resolvedRunnerCwd, "packages/cli", "report.md"));
+		assert.deepEqual(plan.skillNames, ["review", "shared"]);
+		assert.deepEqual(plan.behavior, {
+			output: "report.md",
+			outputMode: "inline",
+			reads: ["brief.md"],
+			progress: true,
+			skills: ["review", "shared"],
+			model: "openai-codex/gpt-5.6-luna",
+			fast: true,
+		});
+	});
+
+	it("keeps dynamic namespace output unresolved until fanout items materialize", () => {
+		const runnerCwd = path.join("/tmp", "repo");
+		const resolvedRunnerCwd = path.resolve(runnerCwd);
+		const plan = planChildLaunch({
+			agentConfig: agent,
+			stepOverrides: {},
+			runnerCwd,
+			runtimeCwd: runnerCwd,
+			parallelOutputNamespace: { stepIndex: 2 },
+		});
+
+		assert.equal(plan.namespaceOutputPath, true);
+		assert.equal(plan.behavior.output, "report.md");
+		assert.equal(plan.outputPath, path.join(resolvedRunnerCwd, "report.md"));
+	});
+
+	it("namespaces inherited relative parallel output for concrete items", () => {
+		const runnerCwd = path.join("/tmp", "repo");
+		const resolvedRunnerCwd = path.resolve(runnerCwd);
+		const plan = planChildLaunch({
+			agentConfig: agent,
+			stepOverrides: {},
+			runnerCwd,
+			runtimeCwd: runnerCwd,
+			parallelOutputNamespace: { stepIndex: 2, taskIndex: 4 },
+		});
+
+		assert.equal(plan.namespaceOutputPath, false);
+		assert.equal(plan.behavior.output, path.join("parallel-2", "4-worker", "report.md"));
+		assert.equal(plan.outputPath, path.join(resolvedRunnerCwd, "parallel-2", "4-worker", "report.md"));
+	});
+
+	it("suppresses progress for read-only templated tasks", () => {
+		const behavior = resolveStepBehavior(agent, {});
+		const plan = planChildLaunch({
+			agentConfig: agent,
+			stepOverrides: {},
+			resolvedBehavior: behavior,
+			task: "{task}",
+			originalTask: "Review-only. Do not edit files.",
+			runnerCwd: "/tmp/repo",
+			runtimeCwd: "/tmp/repo",
+		});
+
+		assert.equal(plan.behavior.progress, false);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/child-protocol.test.ts

@@ -76,6 +76,19 @@ describe("bounded child protocol reader", () => {
 		}
 	});
 
+	it("projects oversized compaction_end aggregates without losing retry lifecycle metadata", () => {
+		const lines: string[] = [];
+		const reader = createBoundedLineReader({
+			maxPendingLineBytes: 64,
+			oversizedLineProjector: PI_AGGREGATE_EVENT_PROJECTOR,
+			onLine: (line) => lines.push(line),
+			onLimit: () => assert.fail("valid compaction_end aggregate must not fail"),
+		});
+		reader.push(`${JSON.stringify({ type: "compaction_end", result: { summary: "x".repeat(256) }, willRetry: true })}\n`);
+		reader.end();
+		assert.deepEqual(lines.map((line) => JSON.parse(line)), [{ type: "compaction_end", willRetry: true }]);
+	});
+
 	it("fails closed when an oversized agent_end aggregate lacks lifecycle metadata", () => {
 		let failure: ProtocolOutputLimit | undefined;
 		const reader = createBoundedLineReader({
@@ -178,4 +191,12 @@ describe("child lifecycle projection", () => {
 		assert.equal(projectChildLifecycle({ type: "agent_settled" }), "start-drain");
 		assert.equal(projectChildLifecycle({ type: "tool_execution_start" }), "none");
 	});
+
+	it("ignores settlement from a compaction attempt that will retry", () => {
+		const state = { compactionRetryActive: false };
+		assert.equal(projectChildLifecycle({ type: "compaction_end", willRetry: true }, false, state), "cancel-drain");
+		assert.equal(projectChildLifecycle({ type: "agent_settled" }, false, state), "none");
+		assert.equal(projectChildLifecycle({ type: "agent_start" }, false, state), "none");
+		assert.equal(projectChildLifecycle({ type: "agent_settled" }, false, state), "start-drain");
+	});
 });

package/dist/extensions/pi-subagents/test/unit/child-session-name.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	CHILD_SESSION_NAME_MAX_CHARS,
+	deriveChildSessionName,
+} from "../../src/shared/child-session-name.ts";
+import { PROMPT_REDACTED } from "../../src/shared/utils.ts";
+
+describe("deriveChildSessionName", () => {
+	it("combines agent and task excerpt", () => {
+		assert.equal(
+			deriveChildSessionName({ agent: "reviewer", task: "Review the diff since main" }),
+			"reviewer: Review the diff since main",
+		);
+	});
+
+	it("prefers a workflow label over the task", () => {
+		assert.equal(
+			deriveChildSessionName({ agent: "scout", label: "find-callers", task: "ignored task text" }),
+			"scout: find-callers",
+		);
+	});
+
+	it("falls back to the bare agent when no task or label is usable", () => {
+		assert.equal(deriveChildSessionName({ agent: "worker" }), "worker");
+		assert.equal(deriveChildSessionName({ agent: "worker", task: "   " }), "worker");
+	});
+
+	it("never builds a name from a redacted prompt", () => {
+		assert.equal(deriveChildSessionName({ agent: "worker", task: PROMPT_REDACTED }), "worker");
+		assert.equal(deriveChildSessionName({ task: PROMPT_REDACTED }), undefined);
+	});
+
+	it("collapses newlines and control characters into a single line", () => {
+		const name = deriveChildSessionName({ agent: "scout", task: "line one\nline two" });
+		assert.equal(name, "scout: line one line two");
+		assert.doesNotMatch(name!, /[\n]/);
+	});
+
+	it("caps the final name at CHILD_SESSION_NAME_MAX_CHARS", () => {
+		const name = deriveChildSessionName({ agent: "worker", task: "x".repeat(500) });
+		assert.ok(name);
+		assert.ok(name.length <= CHILD_SESSION_NAME_MAX_CHARS);
+		assert.ok(name.endsWith("..."));
+	});
+
+	it("returns undefined when there is nothing to name", () => {
+		assert.equal(deriveChildSessionName({}), undefined);
+	});
+});