@selesai/code 0.13.16 → 0.13.19

package/dist/extensions/pi-subagents/test/unit/supervisor-ui.test.ts

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import {
+	renderSupervisorReply,
+	renderSupervisorRequest,
+	type SupervisorReplyEntryData,
+	type SupervisorRequestMessageDetails,
+} from "../../src/intercom/supervisor-ui.ts";
+
+const identityTheme = {
+	fg: (_color: string, text: string) => text,
+};
+
+function renderRequest(details: SupervisorRequestMessageDetails, content: string, width = 100, expanded = true): string[] {
+	const component = renderSupervisorRequest({ content, details }, { expanded }, identityTheme as never);
+	assert.ok(component);
+	return component.render(width);
+}
+
+function renderReply(data: SupervisorReplyEntryData, width = 100): string[] {
+	const component = renderSupervisorReply({ data }, { expanded: true }, identityTheme as never);
+	assert.ok(component);
+	return component.render(width);
+}
+
+describe("native supervisor UI", () => {
+	it("renders request metadata, interview shape, and an exact reply hint", () => {
+		const requestId = "request-123456";
+		const output = renderRequest({
+			id: requestId,
+			reason: "interview_request",
+			expectsReply: true,
+			runId: "run-1845",
+			agent: "worker",
+			childIndex: 2,
+			childTarget: "child-worker",
+			replyHint: `subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`,
+			interview: { approved: "boolean", rationale: "string" },
+			requestBody: "Should this change be applied?",
+		}, [
+			"Subagent requests a structured supervisor interview.",
+			"Run: run-1845",
+			"Agent: worker",
+			"Child index: 2",
+			"Should this change be applied?",
+			`Reply with: subagent_supervisor({ action: "reply", replyTo: "${requestId}", message: "..." })`,
+		].join("\n"));
+		const text = output.join("\n");
+
+		assert.match(text, /Supervisor interview request/);
+		assert.match(text, /Reason: interview_request/);
+		assert.match(text, /Run: run-1845/);
+		assert.match(text, /Agent: worker/);
+		assert.match(text, /Child index: 2/);
+		assert.match(text, /Child target: child-worker/);
+		assert.match(text, new RegExp(`Request ID: ${requestId}`));
+		assert.match(text, new RegExp(`replyTo: "${requestId}"`));
+		assert.match(text, /Interview shape:/);
+		assert.match(text, /approved/);
+		assert.match(text, /Should this change be applied/);
+		assert.equal(text.match(/Run: run-1845/g)?.length, 1);
+		assert.equal(text.match(/Agent: worker/g)?.length, 1);
+		assert.equal(text.match(/Child index: 2/g)?.length, 1);
+		assert.equal(text.match(/Reply with:/g)?.length, 1);
+	});
+
+	it("omits reply hints for progress updates and renders durable reply metadata", () => {
+		const requestOutput = renderRequest({
+			id: "progress-1",
+			reason: "progress_update",
+			expectsReply: false,
+			runId: "run-progress",
+			agent: "reviewer",
+			childIndex: 0,
+		}, "Progress is continuing.");
+		assert.equal(requestOutput.join("\n").includes("Reply with:"), false);
+
+		const replyOutput = renderReply({
+			requestId: "request-1",
+			reason: "need_decision",
+			runId: "run-1",
+			agent: "worker",
+			childIndex: 1,
+			childTarget: "child-worker",
+			message: "Approved; continue.",
+			createdAt: 123,
+		});
+		const text = replyOutput.join("\n");
+		assert.match(text, /Supervisor reply to child/);
+		assert.match(text, /Reply to: request-1/);
+		assert.match(text, /Approved; continue\./);
+		assert.match(text, /child-worker/);
+	});
+
+	it("ignores malformed request and reply metadata", () => {
+		assert.equal(renderSupervisorRequest({ content: "request", details: { id: "request-1", expectsReply: true, replyHint: ["bad"] } }, { expanded: true }, identityTheme as never), undefined);
+		assert.equal(renderSupervisorReply({ data: { requestId: "request-1", runId: "run-1", agent: "worker", childIndex: 0, message: ["bad"], createdAt: 123 } }, { expanded: true }, identityTheme as never), undefined);
+	});
+
+	it("sanitizes and bounds collapsed untrusted content at narrow widths", () => {
+		const output = renderRequest({
+			id: "request-long",
+			reason: "need_decision",
+			expectsReply: true,
+			runId: "run-long",
+			agent: "worker",
+			childIndex: 0,
+		}, `\u0001${"untrusted ".repeat(400)}`, 24, false);
+		assert.ok(output.length <= 39, `expected bounded rows, got ${output.length}`);
+		for (const line of output) assert.ok(visibleWidth(line) <= 24, `line exceeds width: ${line}`);
+		const text = output.join("\n");
+		assert.match(text, /truncated/);
+		assert.equal(text.includes("\u0001"), false);
+		assert.match(text, /\[U\+0001\]/);
+	});
+
+	it("keeps long blocking requests visible when expanded", () => {
+		const content = `${Array.from({ length: 45 }, (_, index) => `decision line ${index + 1}`).join("\n")}\n${"body-detail ".repeat(800)}END_BODY`;
+		const output = renderRequest({
+			id: "request-expanded",
+			reason: "need_decision",
+			expectsReply: true,
+			runId: "run-expanded",
+			agent: "worker",
+			childIndex: 0,
+			interview: { questions: Array.from({ length: 12 }, (_, index) => ({ id: `q${index + 1}`, question: `${"Question detail ".repeat(40)}${index === 11 ? "END_INTERVIEW" : index + 1}` })) },
+		}, content, 120, true);
+		const text = output.join("\n");
+
+		assert.ok(output.length > 39, `expected expanded rows, got ${output.length}`);
+		assert.match(text, /decision line 45/);
+		assert.match(text, /END_BODY/);
+		assert.match(text, /END_INTERVIEW/);
+		assert.doesNotMatch(text, /\[truncated\]/);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/tool-budget.test.ts

@@ -2,8 +2,6 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
 	DEFAULT_TOOL_BUDGET_BLOCK,
-	decodeToolBudgetEnv,
-	encodeToolBudgetEnv,
 	initialToolBudgetState,
 	shouldBlockToolForBudget,
 	toolBudgetBlockedMessage,
@@ -41,14 +39,6 @@ describe("tool-budget module", () => {
 		assert.equal(validateToolBudgetConfig({ hard: 4, block: [""] }).error, "toolBudget.block must contain non-empty tool names.");
 	});
 
-	it("serializes and decodes env config", () => {
-		const budget = { soft: 2, hard: 4, block: ["read"] };
-		assert.deepEqual(decodeToolBudgetEnv(encodeToolBudgetEnv(budget)), budget);
-		const zeroBudget = { hard: 0, block: "*" as const };
-		assert.throws(() => decodeToolBudgetEnv(encodeToolBudgetEnv(zeroBudget)), /SELESAI_SUBAGENT_TOOL_BUDGET\.hard must be an integer >= 1/);
-		assert.deepEqual(decodeToolBudgetEnv(encodeToolBudgetEnv(zeroBudget), { allowZero: true }), zeroBudget);
-	});
-
 	it("tracks state and block decisions", () => {
 		const budget = { soft: 2, hard: 3, block: ["read"] };
 		assert.deepEqual(initialToolBudgetState(budget), { soft: 2, hard: 3, block: ["read"], toolCount: 0, outcome: "within-budget" });
@@ -64,4 +54,4 @@ describe("tool-budget module", () => {
 		assert.match(toolBudgetSoftNudge(budget, 2), /soft limit reached after 2 tool calls/);
 		assert.match(toolBudgetBlockedMessage(budget, "read", 4), /'read' tool is blocked/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/tool-description.test.ts

@@ -12,7 +12,7 @@ import {
 	FULL_SUBAGENT_TOOL_DESCRIPTION,
 	SUBAGENT_SAFETY_GUIDANCE,
 } from "../../src/extension/tool-description.ts";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
+import { SUBAGENT_CHILD_ENV } from "../../src/runs/shared/child-runtime-config.ts";
 
 const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -23,7 +23,6 @@ function escapeRegex(value: string): string {
 function parentToolEnv(agentDir?: string): NodeJS.ProcessEnv {
 	const env = { ...process.env };
 	delete env[SUBAGENT_CHILD_ENV];
-	delete env[SUBAGENT_FANOUT_CHILD_ENV];
 	if (agentDir) env.SELESAI_CODING_AGENT_DIR = agentDir;
 	return env;
 }
@@ -39,6 +38,13 @@ describe("registered subagent tool description", () => {
 		assert.equal(metadata.promptGuidelines, undefined);
 	});
 
+	it("explains managed worktree baseRef restrictions in every built-in description", () => {
+		for (const description of [FULL_SUBAGENT_TOOL_DESCRIPTION, COMPACT_SUBAGENT_TOOL_DESCRIPTION]) {
+			assert.match(description, /baseRef.*HEAD.*named ref.*40\/64-character commit IDs.*revision expressions.*unsupported/);
+			assert.match(description, /Omitted baseRef defaults to HEAD resolved at worktree allocation/);
+		}
+	});
+
 	it("keeps the full description when configured", () => {
 		const description = buildSubagentToolDescription({ toolDescriptionMode: "full" });
 		assert.equal(buildSubagentToolPromptMetadata({ toolDescriptionMode: "full" }).promptSnippet, undefined);
@@ -77,6 +83,7 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /suffix on the model string.*off\/minimal\/low\/medium\/high\/xhigh\/max/i);
 		assert.match(description, /suffix wins over the agent's thinking default/i);
 		assert.match(description, /watchdog\.configure' and is ignored on dispatch/i);
+		assert.match(description, /lane infrastructure blocker.*explicit owner approval/i);
 	});
 
 	it("offers a compact mode that keeps the two-tier contract and safety guidance", () => {
@@ -108,6 +115,7 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /Per-run thinking is a suffix on the model string.*off\/minimal\/low\/medium\/high\/xhigh\/max/i);
 		assert.match(description, /suffix wins over the agent's thinking default/i);
 		assert.match(description, /watchdog\.configure' and is ignored on dispatch/i);
+		assert.match(description, /lane infrastructure blocker.*explicit owner approval/i);
 		assert.ok(description.length < FULL_SUBAGENT_TOOL_DESCRIPTION.length);
 	});
 
@@ -153,6 +161,18 @@ describe("registered subagent tool description", () => {
 		assert.match(description, /status\.json/);
 	});
 
+	it("deduplicates compact placeholder safety guidance in custom descriptions", () => {
+		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-compact-custom-"));
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
+		fs.mkdirSync(path.join(cwd, ".selesai"), { recursive: true });
+		fs.writeFileSync(path.join(cwd, ".selesai", "subagent-tool-description.md"), "{{compactDescription}}", "utf-8");
+
+		const description = buildSubagentToolDescription({ toolDescriptionMode: "custom" }, { cwd, agentDir });
+
+		assert.equal(description.split("lane infrastructure blocker").length - 1, 1);
+		assert.ok(description.endsWith(SUBAGENT_SAFETY_GUIDANCE));
+	});
+
 	it("keeps mandatory safety guidance last when custom prose embeds it before an override", () => {
 		const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-injection-"));
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-agent-"));
@@ -261,7 +281,7 @@ describe("registered subagent tool description", () => {
 		fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify(config), "utf-8");
 	}
 
-	it("registers full, compact, custom, and fallback descriptions from extension config", () => {
+	it("registers split, full, compact, custom, and fallback descriptions from extension config", () => {
 		const defaultAgentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-tool-desc-default-"));
 		writeExtensionConfig(defaultAgentDir, {});
 		const defaultTool = readRegisteredTool(defaultAgentDir);

package/dist/extensions/pi-subagents/test/unit/wait-completions.test.ts

@@ -3,10 +3,16 @@ import { describe, it } from "node:test";
 import { toWaitCompletion } from "../../src/runs/background/wait-completions.ts";
 
 describe("workflow wait completion projection", () => {
+	it("omits absent and malformed receipt references", () => {
+		for (const workflowReceipt of [undefined, null, [], "path", { path: "" }, { path: 42 }]) {
+			assert.equal("workflowReceiptPath" in toWaitCompletion({ workflowReceipt }, "run"), false);
+		}
+	});
 	it("retains the bounded workflow-child summary and excludes result output", () => {
 		const completion = toWaitCompletion({
 			agent: "workflow",
 			mode: "workflow",
+			workflowReceipt: { path: "/opaque/published-receipt.json", receipt: { output: "must not be copied" } },
 			state: "complete",
 			success: true,
 			workflowChildren: {
@@ -29,6 +35,7 @@ describe("workflow wait completion projection", () => {
 		}, "workflow-1");
 
 		assert.equal(completion.workflowChildren?.children[0]?.childId, "review");
+		assert.equal(completion.workflowReceiptPath, "/opaque/published-receipt.json");
 		assert.deepEqual(completion.results?.[0]?.usage, { input: 10, output: 2, cacheRead: 30, cacheWrite: 0, cost: 0.04, turns: 1 });
 		assert.equal(completion.results?.[0]?.sessionFile, "/sessions/run-1.jsonl");
 		assert.doesNotMatch(JSON.stringify(completion), /must not be copied/);
@@ -107,4 +114,4 @@ describe("workflow wait completion projection", () => {
 	it("rejects a summary bound to another completion", () => {
 		assert.throws(() => toWaitCompletion({ workflowChildren: { version: 1, parentToolCallId: "tool", workflowRunId: "other", inventoryComplete: true, workflowState: "completed", children: [] } }, "run"), /does not match its completion run id/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/watchdog-tool-actions.test.ts

@@ -77,6 +77,24 @@ describe("watchdog tool actions", () => {
 		assert.equal(result.isError, undefined);
 		assert.equal(runtime.getSnapshot(tempProject).config.main.model, "anthropic/claude-opus-4-8");
 		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, "low");
+		const off = handleWatchdogToolAction("watchdog.configure", { thinking: false }, ctx, runtime);
+		assert.equal(off.isError, undefined);
+		assert.equal(runtime.getSnapshot(tempProject).config.main.thinking, false);
+	});
+
+	it("rejects transport-permitted true thinking without changing session or settings", () => {
+		const runtime = new MainWatchdogRuntime({ cwd: tempProject });
+		const ctx = createCtx({ provider: "openai-codex", id: "gpt-5.5" });
+		const before = runtime.getSnapshot(tempProject).config.main;
+		for (const scope of ["session", "user"]) {
+			// SAFETY: Deliberately pass invalid tool JSON to prove the false-only runtime contract.
+			const result = handleWatchdogToolAction("watchdog.configure", { scope, thinking: true as never }, ctx, runtime);
+			assert.equal(result.isError, true);
+			assert.match(text(result), /Unsupported watchdog thinking 'true'/);
+			assert.deepEqual(runtime.getSnapshot(tempProject).config.main, before);
+		}
+		assert.equal(fs.existsSync(path.join(tempHome, ".selesai", "agent", "settings.json")), false);
+		assert.equal(fs.existsSync(path.join(tempProject, ".selesai", "settings.json")), false);
 	});
 
 	it("persists the recommended model when user scope is explicit", () => {
@@ -88,4 +106,4 @@ describe("watchdog tool actions", () => {
 		assert.equal(settings.subagents.watchdog.main.model, "openai-codex/gpt-5.5");
 		assert.equal(settings.subagents.watchdog.main.thinking, "high");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/workflow-chat-progress.test.ts

@@ -7,6 +7,7 @@ import { describe, it } from "node:test";
 import { buildWorkflowChatProgressRows, isSameGitRepository, resolveWorkflowChatProgress } from "../../src/workflows/chat-progress.ts";
 import { renderSubagentResult } from "../../src/tui/render.ts";
 import { bindMissionWorkflowChildAsyncLaunch, createSubagentExecutor, foregroundResultIntercomStatus, missionWorkflowChildStatus, runMissionWorkflowChild, shouldSuppressRoutineResultIntercom } from "../../src/runs/foreground/subagent-executor.ts";
+import { encodeIndexSegment } from "../../src/runs/background/index-segment.ts";
 import { readMissionBinding } from "../../src/missions/lifecycle.ts";
 import { createMission, readMission } from "../../src/missions/store.ts";
 import { DIRS, type Details, type SingleResult, type SubagentState } from "../../src/shared/types.ts";
@@ -110,12 +111,76 @@ describe("workflow chat progress policy", () => {
 });
 
 describe("workflow chat progress rendering", () => {
-	it("emits live-card updates for same-repo watched workflowScript runs", async () => {
+	for (const scenario of ["explicit off", "non-repository auto", "cross-repository auto"] as const) {
+		it(`emits foreground lifecycle updates before settlement with ${scenario}`, async () => {
+			const root = scenario === "non-repository auto"
+				? fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-progress-headless-"))
+				: createRepo("pi-workflow-progress-off-");
+			const other = scenario === "cross-repository auto" ? createRepo("pi-workflow-progress-cross-") : undefined;
+			try {
+				const updates: Details[] = [];
+				let settled = false;
+				const result = await createExecutor().execute(
+					"wf-headless",
+					{
+						workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan" });`,
+						async: false,
+						chatProgress: scenario === "explicit off" ? "off" : "auto",
+						...(other ? { cwd: other } : {}),
+					},
+					new AbortController().signal,
+					(update) => {
+						assert.equal(settled, false);
+						updates.push(structuredClone(update.details));
+					},
+					ctx(root),
+				).then((result) => { settled = true; return result; });
+				assert.equal(result.isError, true);
+				assert.ok(updates.every((details) => details.chatProgress?.mode === "off"));
+				const started = updates.find((details) => details.workflowChildren?.children[0]?.state === "running");
+				assert.ok(started, "expected running child inventory before failure");
+				assert.equal(started.mode, "workflow");
+				assert.equal(started.runId, result.details.runId);
+				assert.equal(started.workflowChildren?.parentToolCallId, "wf-headless");
+				assert.equal(started.workflowChildren?.workflowRunId, result.details.runId);
+				assert.equal(started.workflowChildren?.inventoryComplete, false);
+				assert.equal(started.workflow?.trace[0]?.key, "scout");
+				assert.ok(updates.some((details) => details.workflow?.trace.some((entry) => entry.state === "failed")));
+				assert.equal(result.details.workflowChildren?.inventoryComplete, true);
+			} finally {
+				fs.rmSync(root, { recursive: true, force: true });
+				if (other) fs.rmSync(other, { recursive: true, force: true });
+			}
+		});
+	}
+
+	it("emits headless workflow values before returning final output without an update callback requirement", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-workflow-progress-emits-"));
+		try {
+			const updates: Details[] = [];
+			const params = { workflowScript: `emit({ phase: "checking" }); return "done";`, async: false, chatProgress: "off" as const };
+			const result = await createExecutor().execute("wf-emits", params, undefined, (update) => {
+				assert.equal(update.details.workflow?.value, undefined);
+				updates.push(structuredClone(update.details));
+			}, ctx(root));
+			assert.ok(updates.some((details) => details.workflow?.emits.some((value) => (value as { phase?: string }).phase === "checking")));
+			assert.equal(result.details.workflow?.value, "done");
+			assert.equal(result.isError, undefined);
+			const withoutCallback = await createExecutor().execute("wf-no-callback", params, undefined, undefined, ctx(root));
+			assert.equal(withoutCallback.details.workflow?.value, "done");
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("emits live-card updates with bounded workflow ids", async () => {
 		const repo = createRepo("pi-workflow-progress-executor-");
+		const toolCallId = `wf-live-${"x".repeat(300)}`;
+		const workflowRunId = encodeIndexSegment(toolCallId);
 		try {
 			const updates: Array<{ details?: Details }> = [];
 			const result = await createExecutor().execute(
-				"wf-live",
+				toolCallId,
 				{ workflowScript: `return await runs.run("scout", { agent: "missing-agent", task: "scan", phase: "Validation", label: "Find renderer seam" });`, async: false },
 				new AbortController().signal,
 				(update) => updates.push(update),
@@ -124,16 +189,19 @@ describe("workflow chat progress rendering", () => {
 			assert.equal(result.isError, true);
 			const liveUpdate = updates.find((update) => update.details?.chatProgress?.mode === "live-card");
 			assert.ok(liveUpdate, "expected a live-card update");
+			assert.equal(liveUpdate.details?.runId, workflowRunId);
+			assert.equal(liveUpdate.details?.workflowChildren?.workflowRunId, workflowRunId);
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.key, "scout");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.phase, "Validation");
 			assert.equal(liveUpdate.details?.workflow?.trace[0]?.label, "Find renderer seam");
 			const ledgerChild = result.details.mission?.workflowChildren[0];
 			assert.equal(ledgerChild?.key, "scout");
-			assert.equal(ledgerChild?.workflowRunId, "wf-live");
+			assert.equal(ledgerChild?.workflowRunId, workflowRunId);
 			assert.equal(ledgerChild?.agent, "missing-agent");
 			assert.equal(ledgerChild?.phase, "Validation");
 			assert.equal(ledgerChild?.status, "failed");
 			assert.equal(ledgerChild?.heartbeat?.status, "failed");
+			assert.equal(result.details.workflowChildren?.workflowRunId, workflowRunId);
 		} finally {
 			fs.rmSync(repo, { recursive: true, force: true });
 		}
@@ -567,4 +635,4 @@ describe("workflow chat progress rendering", () => {
 		assert.match(text, /final answer/);
 		assert.doesNotMatch(text, /workflow wf_done/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/workflow-checklist.test.ts

@@ -2,7 +2,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import { formatWorkflowChecklistBottleneck, formatWorkflowChecklistText, projectWorkflowChecklist } from "../../src/workflows/workflow-checklist.ts";
-import type { HostStepNodeV1, WorkflowGraphSnapshot } from "../../src/shared/types.ts";
+import type { HostStepNode, WorkflowGraphSnapshot } from "../../src/shared/types.ts";
 
 function graph(): WorkflowGraphSnapshot {
 	return {
@@ -50,7 +50,7 @@ test("workflow checklist fuses graph phases with loaded child state without dupl
 });
 
 test("workflow checklist preserves explicit host monitor verdicts and trace lane identity", () => {
-	const host: HostStepNodeV1 = {
+	const host: HostStepNode = {
 		version: 1,
 		kind: "host-step",
 		monitorKind: "ci",
@@ -81,8 +81,22 @@ test("workflow checklist preserves explicit host monitor verdicts and trace lane
 	assert.match(formatWorkflowChecklistBottleneck(projection.bottleneck) ?? "", /CI/);
 });
 
+test("workflow checklist renders a failed item error only once when item details are included", () => {
+	const projection = projectWorkflowChecklist({
+		steps: [{ workflowKey: "review", agent: "reviewer", status: "failed", error: "review failed with details" }],
+	});
+
+	const expanded = formatWorkflowChecklistText(projection).join("\n");
+	assert.equal(expanded.match(/review failed with details/g)?.length, 1);
+	assert.doesNotMatch(expanded, /bottleneck .*error:review failed with details/);
+
+	const collapsed = formatWorkflowChecklistText(projection, "", { includeItems: false }).join("\n");
+	assert.equal(collapsed.match(/review failed with details/g)?.length, 1);
+	assert.match(collapsed, /bottleneck .*error:review failed with details/);
+});
+
 test("workflow checklist counts one host monitor when host status and trace share an id", () => {
-	const host: HostStepNodeV1 = {
+	const host: HostStepNode = {
 		version: 1,
 		kind: "host-step",
 		monitorKind: "ci",

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

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { it } from "node:test";
+import { workflowChildActivity, workflowChildProgress, workflowChildSummary, parseWorkflowChildSummary } from "../../src/workflows/workflow-child-summary.ts";
+import type { AgentProgress } from "../../src/shared/types.ts";
+
+const progress = { agent: "worker", status: "running", model: "provider/model", thinking: "high", currentTool: "read", currentToolStartedAt: 100, lastActivityAt: 120, durationMs: 20, toolCount: 1, turnCount: 2, tokens: 10, inputTokens: 8, outputTokens: 2, task: "private", currentToolArgs: "private", recentOutput: ["private"] } as AgentProgress;
+const input = { parentToolCallId: "tool", workflowRunId: "wf", workflowState: "running" as const, inventoryComplete: false, trace: ["a", "b"].map((key) => ({ operation: "run" as const, key, state: "started" as const })) };
+
+it("projects independent bounded snapshots by stable key and clears terminal activity", () => {
+	const snapshots = new Map([["b", workflowChildProgress(progress)], ["a", workflowChildProgress({ ...progress, currentTool: "bash", toolCount: 9 })]]);
+	const summary = workflowChildSummary({ ...input, progress: snapshots });
+	assert.deepEqual(summary.children.map((row) => [row.childId, row.activity?.currentTool, row.activity?.toolCount]), [["a", "bash", 9], ["b", "read", 1]]);
+	assert.equal(summary.children[0].model, progress.model);
+	assert.equal(summary.children[0].thinking, "high");
+	assert.equal(JSON.stringify(summary).includes("private"), false);
+	assert.deepEqual(parseWorkflowChildSummary(summary), summary);
+	snapshots.set("a", workflowChildProgress({ ...progress, currentTool: undefined, currentToolStartedAt: undefined }));
+	assert.equal(workflowChildSummary({ ...input, progress: snapshots }).children[0].activity?.currentTool, undefined);
+	assert.equal(summary.children[0].activity?.currentTool, "bash", "published snapshots stay immutable");
+	assert.ok(workflowChildSummary({ ...input, inventoryComplete: true, workflowState: "failed", progress: snapshots }).children.every((row) => row.activity === undefined));
+});
+
+it("bounds UTF-8 and JSON bytes and rejects malformed activity strictly", () => {
+	assert.equal(workflowChildActivity({ currentTool: "界".repeat(86) }).currentTool, undefined);
+	assert.equal(workflowChildActivity({ currentTool: "界".repeat(85) }).currentTool?.length, 85);
+	const activity = workflowChildActivity({ ...progress, currentTool: "\u0000".repeat(256), tokens: Number.MAX_VALUE });
+	assert.ok(Buffer.byteLength(JSON.stringify(activity)) < 2048);
+	assert.deepEqual(workflowChildActivity({ tokens: NaN, toolCount: -1, durationMs: Infinity }), {});
+	const summary = workflowChildSummary({ ...input, progress: new Map([["a", workflowChildProgress(progress)]]) });
+	for (const invalid of [null, [], { tokens: -1 }, { tokens: Infinity }, { tokens: "1" }, { currentTool: "界".repeat(86) }, { recentOutput: [] }, { currentToolArgs: "secret" }]) {
+		assert.throws(() => parseWorkflowChildSummary({ ...summary, children: [{ ...summary.children[0], activity: invalid }] }), /activity/);
+	}
+	assert.throws(() => parseWorkflowChildSummary({ ...summary, children: [{ ...summary.children[0], state: "completed" }] }), /running state/);
+});

package/dist/extensions/pi-subagents/test/unit/workflow-detach-reconcile.test.ts

@@ -5,6 +5,7 @@ import { describe, it } from "node:test";
 import { applyDetachedChildToPausedWorkflow, promotePausedWorkflowIfSettled, reconcileDetachedWorkflowChildCompletion } from "../../src/runs/foreground/workflow-detach-reconcile.ts";
 import { DIRS, type AsyncStatus, type IntercomEventBus, type SubagentState } from "../../src/shared/types.ts";
 import { buildWorkflowReceipt, writeWorkflowReceipt } from "../../src/workflows/workflow-receipt.ts";
+import { buildCompletionDetails, formatSingleCompletion, parseSubagentNotifyContent, type CompletionNotification } from "../../src/runs/background/notify.ts";
 
 function pausedWorkflow(childRunId: string, extra?: Partial<NonNullable<AsyncStatus["steps"]>[number]>): AsyncStatus {
 	return {
@@ -176,10 +177,12 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		const state = {
 			asyncJobs: new Map([[workflowRunId, { asyncId: workflowRunId, asyncDir, status: "paused" as const }]]),
 		} as SubagentState;
+		let emitted: CompletionNotification | undefined;
 		assert.equal(reconcileDetachedWorkflowChildCompletion({
 			state,
 			workflowRunId,
 			childRunId: "child-1",
+			events: { emit: (_name, payload) => { emitted = payload as CompletionNotification; } } as IntercomEventBus,
 			result: { index: 0, agent: "worker", task: `Write your findings to exactly this path: ${requestedPath}`, exitCode: 0, sessionFile, savedOutputPath: savedPath, usage: { input: 100, output: 50, cacheRead: 25, cacheWrite: 5, cost: 0.001, turns: 1 } },
 		}), true);
 		const published = JSON.parse(fs.readFileSync(path.join(DIRS.results, `${workflowRunId}.json`), "utf-8")) as { state?: string; success?: boolean; summary?: string; error?: string; sessionId?: string; workflowResolution?: string; recovery?: unknown[]; results?: Array<{ outputReference?: string; outputPathMapping?: unknown }>; workflowReceipt?: { receipt?: { state?: string; workflowResolution?: string; recovery?: unknown[]; entries?: Record<string, { resumability?: { state?: string; reason?: string } }> } } };
@@ -200,6 +203,11 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		assert.equal(published.workflowReceipt?.receipt?.workflowResolution, "settled-awaiting-resume");
 		assert.deepEqual(published.workflowReceipt?.receipt?.recovery, published.recovery);
 		assert.equal(published.workflowReceipt?.receipt?.entries?.detaches?.resumability?.state, "resumable");
+		assert.ok(emitted);
+		const notification = parseSubagentNotifyContent(formatSingleCompletion(buildCompletionDetails(emitted)));
+		const publishedPath = (published.workflowReceipt as { path: string }).path;
+		assert.equal(notification?.workflowReceiptPath, publishedPath);
+		assert.deepEqual(JSON.parse(fs.readFileSync(notification.workflowReceiptPath!, "utf8")), published.workflowReceipt?.receipt);
 		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
 		assert.match(events, /"type":"subagent.workflow.completed"/);
 		assert.match(events, /"state":"failed"/);
@@ -578,7 +586,8 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		const asyncDir = path.join(DIRS.async, workflowRunId);
 		fs.mkdirSync(asyncDir, { recursive: true });
 		fs.mkdirSync(DIRS.results, { recursive: true });
-		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1" };
+		const status = { ...pausedWorkflow("child-1"), runId: workflowRunId, sessionId: "session-1", workflowReceiptPath: "/stale/receipt.json" };
+		fs.writeFileSync(path.join(DIRS.results, `${workflowRunId}.json`), JSON.stringify({ workflowReceipt: { path: status.workflowReceiptPath, receipt: {} } }));
 		fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify(status), "utf-8");
 		fs.writeFileSync(path.join(asyncDir, "workflow-receipt.json"), JSON.stringify({ version: 1, workflowRunId, state: "paused", createdAt: 1, entries: { detaches: { key: "wrong" } } }), "utf-8");
 		const state = {
@@ -597,6 +606,7 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		assert.equal(published.success, false);
 		assert.match(published.error ?? "", /evidence-persistence-failed/);
 		assert.equal(published.workflowReceipt, undefined);
+		assert.equal(JSON.parse(fs.readFileSync(path.join(asyncDir, "status.json"), "utf8")).workflowReceiptPath, undefined);
 		const events = fs.readFileSync(path.join(asyncDir, "events.jsonl"), "utf-8");
 		assert.match(events, /"type":"subagent.workflow.receipt_write_failed"/);
 		assert.match(events, /"type":"subagent.workflow.completed"/);
@@ -774,4 +784,4 @@ describe("reconcileDetachedWorkflowChildCompletion", () => {
 		assert.equal(published.workflowResolution, undefined);
 		assert.equal(published.recovery, undefined);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/workflow-launch-params.test.ts

@@ -4,7 +4,7 @@ import { prepareWorkflowLaunchParams, promptAuditRedoParams, resolveRevivalContr
 import { resolveControlConfig } from "../../src/runs/shared/subagent-control.ts";
 
 describe("workflow launch params", () => {
-	it("keeps omitted workflow child async foreground", () => {
+	it("preserves omitted workflow child async defaults and awaits background resolution", () => {
 		assert.deepEqual(
 			prepareWorkflowLaunchParams(
 				{},
@@ -15,13 +15,52 @@ describe("workflow launch params", () => {
 			{
 				agent: "worker",
 				task: "Run",
-				async: false,
+				workflowAwaitAsync: true,
 				workflowParentRunId: "workflow-run",
 				workflowKey: "run",
 			},
 		);
 	});
 
+	it("forwards workflow baseRef only to launches where it can affect allocation", () => {
+		assert.equal(
+			prepareWorkflowLaunchParams(
+				{ baseRef: "refs/heads/release" },
+				{ agent: "worker", task: "Run" },
+				"workflow-run",
+				"run",
+			).baseRef,
+			"refs/heads/release",
+		);
+		assert.equal(
+			prepareWorkflowLaunchParams(
+				{ baseRef: "refs/heads/release" },
+				{ resume: "retained-run", task: "Continue" },
+				"workflow-run",
+				"resume",
+			).baseRef,
+			undefined,
+		);
+		assert.equal(
+			prepareWorkflowLaunchParams(
+				{ baseRef: "refs/heads/release" },
+				{ resume: "retained-run", task: "Continue", baseRef: "refs/heads/topic" },
+				"workflow-run",
+				"resume-explicit",
+			).baseRef,
+			"refs/heads/topic",
+		);
+		assert.equal(
+			prepareWorkflowLaunchParams(
+				{ baseRef: "refs/heads/release" },
+				{ agent: "worker", task: "Run", baseRef: "refs/heads/topic" },
+				"workflow-run",
+				"override",
+			).baseRef,
+			"refs/heads/topic",
+		);
+	});
+
 	it("does not forward workflow capacity overrides to children", () => {
 		const params = prepareWorkflowLaunchParams(
 			{ globalConcurrencyLimit: 2, maxSubagentSpawnsPerRun: 3 },
@@ -92,7 +131,8 @@ describe("workflow launch params", () => {
 			"run",
 			{ parentDeadlineAt },
 		);
-		assert.equal(params.async, false);
+		assert.equal(params.async, undefined);
+		assert.equal(params.workflowAwaitAsync, true);
 		assert.equal(params.timeoutMs, undefined);
 		assert.equal(params.workflowParentDeadlineAt, parentDeadlineAt);
 	});
@@ -199,7 +239,7 @@ describe("workflow launch params", () => {
 				agent: "worker",
 				task: "Run",
 				intercomBridge: { mode: "off" },
-				async: false,
+				workflowAwaitAsync: true,
 				workflowParentRunId: "workflow-run",
 				workflowKey: "isolated",
 			},
@@ -226,7 +266,7 @@ describe("workflow launch params", () => {
 				agent: "worker",
 				task: "Implement",
 				worktree: true,
-				async: false,
+				workflowAwaitAsync: true,
 				workflowParentRunId: "workflow-run",
 				workflowKey: "gated",
 				acceptance: { level: "verified", verify: [{ id: "gate", command: "npm test" }] },
@@ -404,4 +444,4 @@ describe("workflow launch params", () => {
 			assert.equal(sanitized, "a".repeat(120));
 		});
 	});
-});
+});