@selesai/code 0.2.1 → 0.3.1

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

@@ -0,0 +1,257 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+	checkSubagentDepth,
+	getSubagentDepthEnv,
+	DEFAULT_SUBAGENT_MAX_DEPTH,
+	DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION,
+	normalizeMaxSubagentDepth,
+	normalizeMaxSubagentSpawnsPerSession,
+	resolveMaxSubagentSpawnsPerSession,
+	resolveTopLevelParallelConcurrency,
+	resolveTopLevelParallelMaxTasks,
+	resolveChildMaxSubagentDepth,
+	resolveCurrentMaxSubagentDepth,
+} from "../../src/shared/types.ts";
+
+let savedDepth: string | undefined;
+let savedMaxDepth: string | undefined;
+let savedMaxSpawns: string | undefined;
+
+beforeEach(() => {
+	savedDepth = process.env.SELESAI_SUBAGENT_DEPTH;
+	savedMaxDepth = process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+	savedMaxSpawns = process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
+});
+
+afterEach(() => {
+	if (savedDepth === undefined) delete process.env.SELESAI_SUBAGENT_DEPTH;
+	else process.env.SELESAI_SUBAGENT_DEPTH = savedDepth;
+	if (savedMaxDepth === undefined) delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+	else process.env.SELESAI_SUBAGENT_MAX_DEPTH = savedMaxDepth;
+	if (savedMaxSpawns === undefined) delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
+	else process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION = savedMaxSpawns;
+});
+
+describe("DEFAULT_SUBAGENT_MAX_DEPTH", () => {
+	it("is 2", () => {
+		assert.equal(DEFAULT_SUBAGENT_MAX_DEPTH, 2);
+	});
+});
+
+describe("DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION", () => {
+	it("is 40", () => {
+		assert.equal(DEFAULT_MAX_SUBAGENT_SPAWNS_PER_SESSION, 40);
+	});
+});
+
+describe("normalizeMaxSubagentDepth", () => {
+	it("accepts integers >= 0", () => {
+		assert.equal(normalizeMaxSubagentDepth(0), 0);
+		assert.equal(normalizeMaxSubagentDepth(3), 3);
+		assert.equal(normalizeMaxSubagentDepth("4"), 4);
+	});
+
+	it("rejects negatives and non-integers", () => {
+		assert.equal(normalizeMaxSubagentDepth(-1), undefined);
+		assert.equal(normalizeMaxSubagentDepth(1.5), undefined);
+		assert.equal(normalizeMaxSubagentDepth("garbage"), undefined);
+	});
+});
+
+describe("normalizeMaxSubagentSpawnsPerSession", () => {
+	it("accepts integers >= 0", () => {
+		assert.equal(normalizeMaxSubagentSpawnsPerSession(0), 0);
+		assert.equal(normalizeMaxSubagentSpawnsPerSession(12), 12);
+		assert.equal(normalizeMaxSubagentSpawnsPerSession("9"), 9);
+	});
+
+	it("rejects negatives and non-integers", () => {
+		assert.equal(normalizeMaxSubagentSpawnsPerSession(-1), undefined);
+		assert.equal(normalizeMaxSubagentSpawnsPerSession(1.5), undefined);
+		assert.equal(normalizeMaxSubagentSpawnsPerSession("garbage"), undefined);
+	});
+});
+
+describe("resolveMaxSubagentSpawnsPerSession", () => {
+	it("uses env when present", () => {
+		process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION = "5";
+		assert.equal(resolveMaxSubagentSpawnsPerSession(1), 5);
+	});
+
+	it("falls back to config when env is absent", () => {
+		delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
+		assert.equal(resolveMaxSubagentSpawnsPerSession(7), 7);
+	});
+
+	it("falls back to default when neither env nor config is valid", () => {
+		delete process.env.SELESAI_SUBAGENT_MAX_SPAWNS_PER_SESSION;
+		assert.equal(resolveMaxSubagentSpawnsPerSession(undefined), 40);
+		assert.equal(resolveMaxSubagentSpawnsPerSession(-1), 40);
+	});
+});
+
+describe("resolveCurrentMaxSubagentDepth", () => {
+	it("uses env when present", () => {
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
+		assert.equal(resolveCurrentMaxSubagentDepth(1), 5);
+	});
+
+	it("falls back to config when env is absent", () => {
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		assert.equal(resolveCurrentMaxSubagentDepth(1), 1);
+	});
+
+	it("falls back to default when neither env nor config is valid", () => {
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		assert.equal(resolveCurrentMaxSubagentDepth(undefined), 2);
+		assert.equal(resolveCurrentMaxSubagentDepth(-1), 2);
+	});
+});
+
+describe("top-level parallel config helpers", () => {
+	it("resolves maxTasks from config or falls back to the default", () => {
+		assert.equal(resolveTopLevelParallelMaxTasks(12), 12);
+		assert.equal(resolveTopLevelParallelMaxTasks(undefined), 8);
+		assert.equal(resolveTopLevelParallelMaxTasks(0), 8);
+		assert.equal(resolveTopLevelParallelMaxTasks("oops"), 8);
+	});
+
+	it("resolves concurrency from per-call override, config, or default", () => {
+		assert.equal(resolveTopLevelParallelConcurrency(2, 6), 2);
+		assert.equal(resolveTopLevelParallelConcurrency(undefined, 6), 6);
+		assert.equal(resolveTopLevelParallelConcurrency(0, 6), 6);
+		assert.equal(resolveTopLevelParallelConcurrency(undefined, 0), 4);
+	});
+});
+
+describe("resolveChildMaxSubagentDepth", () => {
+	it("keeps the inherited max when agent override is absent", () => {
+		assert.equal(resolveChildMaxSubagentDepth(3, undefined), 3);
+	});
+
+	it("tightens to the lower per-agent max", () => {
+		assert.equal(resolveChildMaxSubagentDepth(3, 1), 1);
+		assert.equal(resolveChildMaxSubagentDepth(2, 0), 0);
+	});
+
+	it("does not relax an already stricter inherited max", () => {
+		assert.equal(resolveChildMaxSubagentDepth(1, 3), 1);
+	});
+});
+
+describe("checkSubagentDepth", () => {
+	it("not blocked at depth=0, max=2", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
+		const result = checkSubagentDepth();
+		assert.equal(result.blocked, false);
+		assert.equal(result.depth, 0);
+		assert.equal(result.maxDepth, 2);
+	});
+
+	it("uses config max depth when env is absent", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "1";
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const result = checkSubagentDepth(1);
+		assert.equal(result.blocked, true);
+		assert.equal(result.maxDepth, 1);
+	});
+
+	it("not blocked at depth=1, max=2", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "1";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
+		assert.equal(checkSubagentDepth().blocked, false);
+	});
+
+	it("blocks at depth=1, max=1 after one nested level", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "1";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "1";
+		assert.equal(checkSubagentDepth().blocked, true);
+	});
+
+	it("blocked at depth=2, max=2", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "2";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
+		const result = checkSubagentDepth();
+		assert.equal(result.blocked, true);
+		assert.equal(result.depth, 2);
+		assert.equal(result.maxDepth, 2);
+	});
+
+	it("blocked at depth=3, max=2", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "3";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
+		assert.equal(checkSubagentDepth().blocked, true);
+	});
+
+	it("blocked at depth=0, max=0 (disables subagent entirely)", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "0";
+		assert.equal(checkSubagentDepth().blocked, true);
+	});
+
+	it("defaults to depth=0, max=2 when env vars unset", () => {
+		delete process.env.SELESAI_SUBAGENT_DEPTH;
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const result = checkSubagentDepth();
+		assert.equal(result.blocked, false);
+		assert.equal(result.depth, 0);
+		assert.equal(result.maxDepth, 2);
+	});
+
+	it("not blocked when depth is invalid (NaN)", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "garbage";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "2";
+		assert.equal(checkSubagentDepth().blocked, false);
+	});
+});
+
+describe("getSubagentDepthEnv", () => {
+	it("increments from depth=0", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const env = getSubagentDepthEnv();
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "2");
+	});
+
+	it("increments from depth=1", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "1";
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const env = getSubagentDepthEnv();
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "2");
+		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "2");
+	});
+
+	it("uses provided max depth override", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const env = getSubagentDepthEnv(1);
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "1");
+	});
+
+	it("respects inherited SELESAI_SUBAGENT_MAX_DEPTH when override is absent", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
+		const env = getSubagentDepthEnv();
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "5");
+	});
+
+	it("uses the explicit child override even when a looser inherited env max exists", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "0";
+		process.env.SELESAI_SUBAGENT_MAX_DEPTH = "5";
+		const env = getSubagentDepthEnv(1);
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+		assert.equal(env.SELESAI_SUBAGENT_MAX_DEPTH, "1");
+	});
+
+	it("falls back to depth=1 when env var is invalid (NaN)", () => {
+		process.env.SELESAI_SUBAGENT_DEPTH = "not-a-number";
+		delete process.env.SELESAI_SUBAGENT_MAX_DEPTH;
+		const env = getSubagentDepthEnv();
+		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
+	});
+});

package/dist/extensions/pi-subagents/test/unit/render-helpers.test.ts

@@ -0,0 +1,209 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { row } from "../../src/tui/render-helpers.ts";
+import { renderSubagentResult } from "../../src/tui/render.ts";
+
+const theme = {
+	fg(_name: string, text: string): string {
+		return text;
+	},
+	bold(text: string): string {
+		return text;
+	},
+};
+
+function componentText(component: unknown): string {
+	if (typeof component !== "object" || component === null) return "";
+	if ("text" in component && typeof component.text === "string") return component.text;
+	if ("children" in component && Array.isArray(component.children)) return component.children.map(componentText).filter(Boolean).join("\n");
+	return "";
+}
+
+function result(agent: string, output: string) {
+	return {
+		agent,
+		task: `${agent} task`,
+		exitCode: 0,
+		messages: [],
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+		finalOutput: output,
+	};
+}
+
+test("row clips content to the available width", () => {
+	const rendered = row("abcdef", 6, theme as any);
+	assert.equal(visibleWidth(rendered), 6);
+});
+
+test("row normalizes multiline content before clipping", () => {
+	const rendered = row("bash failed: line 1\nline 2\tvalue", 20, theme as any);
+	assert.equal(visibleWidth(rendered), 20);
+	assert.doesNotMatch(rendered, /[\r\n\t]/);
+});
+
+test("row keeps styled multiline content within the available width", () => {
+	const rendered = row("\u001b[31merror line 1\nline 2\tvalue\u001b[39m", 18, theme as any);
+	assert.equal(visibleWidth(rendered), 18);
+	assert.doesNotMatch(rendered, /[\r\n\t]/);
+});
+
+test("compact chain rendering uses workflow graph spans for dynamic fanout results", () => {
+	const component = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["scout", "expand:reviewer", "writer"],
+			totalSteps: 3,
+			results: [result("scout", "targets"), result("reviewer", "a"), result("reviewer", "b"), result("writer", "final")],
+			workflowGraph: {
+				runId: "render-dynamic",
+				mode: "chain",
+				phases: [],
+				nodes: [
+					{ id: "step-0", kind: "step", agent: "scout", label: "Scout", status: "completed", flatIndex: 0, stepIndex: 0 },
+					{
+						id: "step-1",
+						kind: "dynamic-parallel-group",
+						label: "Review targets",
+						status: "completed",
+						stepIndex: 1,
+						children: [
+							{ id: "step-1-item-a", kind: "agent", agent: "reviewer", label: "Review A", status: "completed", flatIndex: 1, stepIndex: 1 },
+							{ id: "step-1-item-b", kind: "agent", agent: "reviewer", label: "Review B", status: "completed", flatIndex: 2, stepIndex: 1 },
+						],
+						dynamic: { sourceOutput: "targets", sourcePath: "/items", itemName: "target", collectAs: "reviews" },
+					},
+					{ id: "step-2", kind: "step", agent: "writer", label: "Writer", status: "completed", flatIndex: 3, stepIndex: 2 },
+				],
+			},
+		},
+	}, { expanded: false }, theme as any);
+
+	const text = componentText(component);
+	assert.match(text, /Step 1: scout/);
+	assert.match(text, /Agent 1\/2: reviewer/);
+	assert.match(text, /Agent 2\/2: reviewer/);
+	assert.match(text, /Step 3: writer/);
+});
+
+test("compact chain rendering shows failed zero-child dynamic fanout groups", () => {
+	const component = renderSubagentResult({
+		content: [{ type: "text", text: "failed" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["scout", "expand:reviewer", "writer"],
+			totalSteps: 3,
+			results: [result("scout", "targets")],
+			workflowGraph: {
+				runId: "render-empty-dynamic-failed",
+				mode: "chain",
+				phases: [],
+				nodes: [
+					{ id: "step-0", kind: "step", agent: "scout", label: "Scout", status: "completed", flatIndex: 0, stepIndex: 0 },
+					{
+						id: "step-1",
+						kind: "dynamic-parallel-group",
+						label: "Review targets",
+						status: "failed",
+						stepIndex: 1,
+						children: [],
+						error: "No review targets materialized",
+						dynamic: { sourceOutput: "targets", sourcePath: "/items", itemName: "target", collectAs: "reviews" },
+					},
+					{ id: "step-2", kind: "step", agent: "writer", label: "Writer", status: "pending", stepIndex: 2 },
+				],
+			},
+		},
+	}, { expanded: false }, theme as any);
+
+	const text = componentText(component);
+	assert.match(text, /step 1\/3/);
+	assert.doesNotMatch(text, /step 3\/3/);
+	assert.match(text, /Step 1: scout/);
+	assert.match(text, /Step 2: Review targets .* failed/);
+	assert.match(text, /No review targets materialized/);
+	assert.match(text, /Step 3: writer .* pending/);
+});
+
+test("expanded chain rendering uses workflow graph spans for dynamic fanout results", () => {
+	const component = renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["scout", "expand:reviewer", "writer"],
+			totalSteps: 3,
+			results: [result("scout", "targets"), result("reviewer", "a"), result("reviewer", "b"), result("writer", "final")],
+			workflowGraph: {
+				runId: "render-dynamic-expanded",
+				mode: "chain",
+				phases: [],
+				nodes: [
+					{ id: "step-0", kind: "step", agent: "scout", label: "Scout", status: "completed", flatIndex: 0, stepIndex: 0 },
+					{
+						id: "step-1",
+						kind: "dynamic-parallel-group",
+						label: "Review targets",
+						status: "completed",
+						stepIndex: 1,
+						children: [
+							{ id: "step-1-item-a", kind: "agent", agent: "reviewer", label: "Review A", status: "completed", flatIndex: 1, stepIndex: 1 },
+							{ id: "step-1-item-b", kind: "agent", agent: "reviewer", label: "Review B", status: "completed", flatIndex: 2, stepIndex: 1 },
+						],
+						dynamic: { sourceOutput: "targets", sourcePath: "/items", itemName: "target", collectAs: "reviews" },
+					},
+					{ id: "step-2", kind: "step", agent: "writer", label: "Writer", status: "completed", flatIndex: 3, stepIndex: 2 },
+				],
+			},
+		},
+	}, { expanded: true }, theme as any);
+
+	const text = componentText(component);
+	assert.match(text, /Step 1: scout/);
+	assert.match(text, /Agent 1\/2: reviewer/);
+	assert.match(text, /Agent 2\/2: reviewer/);
+	assert.match(text, /Step 3: writer/);
+});
+
+test("compact multi-result rendering shows total cost in the header", () => {
+	const text = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "parallel",
+			results: [result("scout", "a"), result("reviewer", "b")],
+			totalCost: { inputTokens: 30, outputTokens: 12, costUsd: 0.04 },
+		},
+	}, { expanded: false }, theme as any));
+
+	assert.match(text, /2\/2 done/);
+	assert.match(text, /in:30 out:12 \$0\.0400/);
+});
+
+test("static sequential and static parallel chain rendering keep existing labels", () => {
+	const sequential = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["scout", "writer"],
+			totalSteps: 2,
+			results: [result("scout", "a"), result("writer", "b")],
+		},
+	}, { expanded: false }, theme as any));
+	assert.match(sequential, /Step 1: scout/);
+	assert.match(sequential, /Step 2: writer/);
+
+	const parallel = componentText(renderSubagentResult({
+		content: [{ type: "text", text: "done" }],
+		details: {
+			mode: "chain",
+			chainAgents: ["scout", "[reviewer+auditor]", "writer"],
+			totalSteps: 3,
+			results: [result("scout", "a"), result("reviewer", "b"), result("auditor", "c"), result("writer", "d")],
+		},
+	}, { expanded: false }, theme as any));
+	assert.match(parallel, /Step 1: scout/);
+	assert.match(parallel, /Agent 1\/2: reviewer/);
+	assert.match(parallel, /Agent 2\/2: auditor/);
+	assert.match(parallel, /Step 3: writer/);
+});

package/dist/extensions/pi-subagents/test/unit/result-intercom.test.ts

@@ -0,0 +1,226 @@
+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 { describe, it } from "node:test";
+import {
+	attachNestedChildrenToResultChildren,
+	buildSubagentResultIntercomPayload,
+	formatSubagentResultReceipt,
+	resolveSubagentResultStatus,
+	stripDetailsOutputsForIntercomReceipt,
+} from "../../src/intercom/result-intercom.ts";
+
+describe("result intercom formatter", () => {
+	it("builds one grouped intercom payload with status counts and child sections", () => {
+		const payload = buildSubagentResultIntercomPayload({
+			to: "subagent-chat-main",
+			runId: "run-123",
+			mode: "chain",
+			source: "foreground",
+			chainSteps: 4,
+			children: [
+				{
+					agent: "reviewer-a",
+					status: "completed",
+					summary: "Completed checks",
+					artifactPath: "/tmp/a.md",
+					sessionPath: "/tmp/a-session.jsonl",
+					intercomTarget: "subagent-reviewer-a-run-123-1",
+				},
+				{
+					agent: "reviewer-b",
+					status: "failed",
+					summary: "Failed checks",
+					artifactPath: "/tmp/b.md",
+				},
+			],
+		});
+
+		assert.equal(payload.status, "failed");
+		assert.equal(payload.summary, "1 completed, 1 failed");
+		assert.equal(payload.children.length, 2);
+		assert.match(payload.message, /^subagent results/m);
+		assert.match(payload.message, /Run: run-123/);
+		assert.match(payload.message, /Mode: chain/);
+		assert.match(payload.message, /Status: failed/);
+		assert.match(payload.message, /Children: 1 completed, 1 failed/);
+		assert.match(payload.message, /Chain steps: 4/);
+		assert.match(payload.message, /Intercom targets below identify child sessions used while they were running/);
+		assert.match(payload.message, /1\. reviewer-a — completed/);
+		assert.match(payload.message, /Run intercom target: subagent-reviewer-a-run-123-1/);
+		assert.match(payload.message, /2\. reviewer-b — failed/);
+		assert.match(payload.message, /Output artifact: \/tmp\/a\.md/);
+		assert.match(payload.message, /Session: \/tmp\/a-session\.jsonl/);
+	});
+
+	it("advertises async revive only for single-child results with an existing session", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-intercom-"));
+		try {
+			const sessionPath = path.join(root, "session.jsonl");
+			fs.writeFileSync(sessionPath, "", "utf-8");
+			const payload = buildSubagentResultIntercomPayload({
+				to: "chat",
+				runId: "run-single",
+				mode: "single",
+				source: "async",
+				asyncId: "run-single",
+				children: [{ agent: "worker", status: "completed", summary: "done", sessionPath }],
+			});
+
+			assert.match(payload.message, /Revive: subagent\(\{ action: "resume", id: "run-single", message: "\.\.\." \}\)/);
+			assert.doesNotMatch(payload.message, /unsupported for multi-child/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("advertises indexed revive for multi-child async results with existing child sessions", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-result-intercom-"));
+		try {
+			const firstSession = path.join(root, "a.jsonl");
+			const secondSession = path.join(root, "b.jsonl");
+			fs.writeFileSync(firstSession, "", "utf-8");
+			fs.writeFileSync(secondSession, "", "utf-8");
+			const payload = buildSubagentResultIntercomPayload({
+				to: "chat",
+				runId: "run-multi",
+				mode: "parallel",
+				source: "async",
+				asyncId: "run-multi",
+				children: [
+					{ agent: "a", status: "completed", summary: "done", sessionPath: firstSession },
+					{ agent: "b", status: "completed", summary: "done", sessionPath: secondSession },
+				],
+			});
+
+			assert.match(payload.message, /Revive child: subagent\(\{ action: "resume", id: "run-multi", index: 0, message: "\.\.\." \}\)/);
+			assert.doesNotMatch(payload.message, /unsupported for multi-child/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("does not advertise async revive for missing child session files", () => {
+		const payload = buildSubagentResultIntercomPayload({
+			to: "chat",
+			runId: "run-missing-session",
+			mode: "single",
+			source: "async",
+			asyncId: "run-missing-session",
+			children: [{ agent: "worker", status: "failed", summary: "failed", sessionPath: path.join(os.tmpdir(), "missing-pi-session.jsonl") }],
+		});
+
+		assert.match(payload.message, /Resume: unavailable; no child session file was persisted/);
+		assert.doesNotMatch(payload.message, /Revive:/);
+	});
+
+	it("attaches compact nested children under their parent result child without route secrets", () => {
+		const payload = buildSubagentResultIntercomPayload({
+			to: "chat",
+			runId: "root-run",
+			mode: "parallel",
+			source: "foreground",
+			children: attachNestedChildrenToResultChildren("root-run", [
+				{ agent: "owner-a", status: "completed", summary: "done", index: 0 },
+				{ agent: "owner-b", status: "completed", summary: "done", index: 1 },
+			], [{
+				id: "nested-a",
+				parentRunId: "root-run",
+				parentStepIndex: 1,
+				depth: 1,
+				path: [{ runId: "root-run", stepIndex: 1 }],
+				state: "complete",
+				agent: "reviewer",
+				sessionFile: path.join(os.tmpdir(), "nested-a.jsonl"),
+				controlInbox: "/tmp/should-not-leak",
+				capabilityToken: "secret-token",
+				children: [{
+					id: "nested-grandchild",
+					parentRunId: "nested-a",
+					depth: 2,
+					path: [{ runId: "root-run", stepIndex: 1 }, { runId: "nested-a" }],
+					state: "complete",
+					agent: "auditor",
+					controlInbox: "/tmp/grandchild-should-not-leak",
+					capabilityToken: "grandchild-secret",
+				}],
+			}]),
+		});
+
+		const nested = payload.children[1]?.children?.[0];
+		const grandchild = nested?.children?.[0];
+		assert.equal(payload.children[0]?.children, undefined);
+		assert.equal(nested?.id, "nested-a");
+		assert.equal(Object.hasOwn(nested ?? {}, "controlInbox"), false);
+		assert.equal(Object.hasOwn(nested ?? {}, "capabilityToken"), false);
+		assert.equal(grandchild?.id, "nested-grandchild");
+		assert.equal(Object.hasOwn(grandchild ?? {}, "controlInbox"), false);
+		assert.equal(Object.hasOwn(grandchild ?? {}, "capabilityToken"), false);
+		assert.match(payload.message, /Nested subagents:/);
+		assert.match(payload.message, /↳ reviewer — complete \[nested-a\]/);
+	});
+
+	it("keeps full child summaries inside grouped payloads", () => {
+		const longSummary = `${"x".repeat(2000)}\n${"y".repeat(2000)}`;
+		const payload = buildSubagentResultIntercomPayload({
+			to: "chat",
+			runId: "run-bound",
+			mode: "single",
+			source: "foreground",
+			children: [{ agent: "worker", status: "completed", summary: longSummary }],
+		});
+		assert.equal(payload.children[0]!.summary, longSummary);
+		assert.match(payload.message, new RegExp(`${"x".repeat(2000)}\\n${"y".repeat(2000)}`));
+	});
+
+	it("formats compact grouped receipts with artifacts and sessions", () => {
+		const payload = buildSubagentResultIntercomPayload({
+			to: "chat",
+			runId: "run-abc",
+			mode: "parallel",
+			source: "foreground",
+			children: [
+				{ agent: "a", status: "completed", summary: "done", artifactPath: "/tmp/a.md", intercomTarget: "subagent-a-run-abc-1" },
+				{ agent: "b", status: "failed", summary: "failed", sessionPath: "/tmp/b.jsonl" },
+			],
+		});
+		const receipt = formatSubagentResultReceipt({
+			mode: "parallel",
+			runId: "run-abc",
+			payload,
+		});
+
+		assert.match(receipt, /Delivered parallel subagent results via intercom\./);
+		assert.match(receipt, /Children: 1 completed, 1 failed/);
+		assert.match(receipt, /Artifacts:\n- a \[completed\]: \/tmp\/a\.md/);
+		assert.match(receipt, /Run intercom targets \(may be inactive after completion\):\n- a \[completed\]: subagent-a-run-abc-1/);
+		assert.match(receipt, /Sessions:\n- b \[failed\]: \/tmp\/b\.jsonl/);
+		assert.match(receipt, /Full grouped output was sent over intercom\./);
+	});
+
+	it("strips heavy output fields from receipt details", () => {
+		const stripped = stripDetailsOutputsForIntercomReceipt({
+			mode: "single",
+			results: [{
+				agent: "worker",
+				task: "Task",
+				exitCode: 0,
+				messages: [{ role: "assistant", content: [{ type: "text", text: "full" }] } as never],
+				usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 1 },
+				finalOutput: "full output",
+				truncation: { text: "truncated", truncated: true },
+			}],
+		});
+		assert.equal(stripped.results[0]?.messages, undefined);
+		assert.equal(stripped.results[0]?.finalOutput, undefined);
+		assert.equal(stripped.results[0]?.truncation, undefined);
+	});
+
+	it("resolves paused and detached statuses", () => {
+		assert.equal(resolveSubagentResultStatus({ interrupted: true }), "paused");
+		assert.equal(resolveSubagentResultStatus({ detached: true }), "detached");
+		assert.equal(resolveSubagentResultStatus({ success: true }), "completed");
+		assert.equal(resolveSubagentResultStatus({ exitCode: 1 }), "failed");
+	});
+});