@selesai/code 0.5.28 → 0.5.29

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

@@ -44,11 +44,15 @@ describe("resolveIntercomBridgeMode", () => {
 
 describe("resolveIntercomSessionTarget", () => {
 	it("prefers an explicit session name", () => {
-		assert.equal(resolveIntercomSessionTarget("planner", "session-12345678"), "planner");
+		assert.equal(resolveIntercomSessionTarget("planner", "session-12345678", "session-stableabcdef"), "planner");
 	});
 
 	it("uses a runtime-only subagent chat alias when unnamed", () => {
-		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678"), "subagent-chat-12345678");
+		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678", ""), "subagent-chat-12345678");
+	});
+
+	it("uses the current pi-intercom runtime id for unnamed fallback when present", () => {
+		assert.equal(resolveIntercomSessionTarget(undefined, "session-12345678", "session-stableabcdef"), "subagent-chat-stableab");
 	});
 });
 
@@ -94,10 +98,21 @@ describe("resolveIntercomBridge", () => {
 		});
 
 		assert.equal(bridge.active, true);
+		assert.equal(bridge.resultDelivery, true);
 		assert.equal(bridge.orchestratorTarget, "main");
 		assert.equal(bridge.extensionDir, NATIVE_INTERCOM_EXTENSION_DIR);
 	});
 
+	it("can disable external grouped-result delivery without disabling supervisor coordination", () => {
+		const bridge = resolveIntercomBridge({
+			config: { mode: "always", resultDelivery: false },
+			context: "fresh",
+			orchestratorTarget: "main",
+		});
+		assert.equal(bridge.active, true);
+		assert.equal(bridge.resultDelivery, false);
+	});
+
 	it("stays inactive for fresh context when mode is fork-only", () => {
 		const bridge = resolveIntercomBridge({
 			config: { mode: "fork-only" },
@@ -144,6 +159,7 @@ describe("applyIntercomBridgeToAgent", () => {
 	const activeBridge: IntercomBridgeState = {
 		active: true,
 		mode: "always",
+		resultDelivery: true,
 		orchestratorTarget: "main",
 		extensionDir: NATIVE_INTERCOM_EXTENSION_DIR,
 		instruction: "Intercom orchestration channel:\n- Need a decision or blocked: contact_supervisor({ reason: \"need_decision\", message: \"<question>\" })\n- Blocked/update: contact_supervisor({ reason: \"progress_update\", message: \"UPDATE: <summary>\" })",

package/dist/extensions/pi-subagents/test/unit/nested-control.test.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 import { afterEach, describe, it } from "node:test";
 import registerFanoutChildSubagentExtension from "../../src/extension/fanout-child.ts";
 import { createSubagentExecutor } from "../../src/runs/foreground/subagent-executor.ts";
-import { createNestedRoute, projectNestedEvents, readNestedControlRequests, readNestedControlResults, writeNestedControlRequest, writeNestedControlResult, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
+import { createNestedRoute, findNestedControlResult, projectNestedEvents, readNestedControlRequests, readNestedControlResults, snapshotNestedEventFiles, writeNestedControlRequest, writeNestedControlResult, writeNestedEvent } from "../../src/runs/shared/nested-events.ts";
 import {
 	SUBAGENT_CHILD_ENV,
 	SUBAGENT_FANOUT_CHILD_ENV,
@@ -129,6 +129,25 @@ async function waitFor(predicate: () => boolean, timeoutMs = 1_000): Promise<voi
 }
 
 describe("nested control routing", () => {
+	it("finds a control result without considering files present before its request", () => {
+		const route = createNestedRoute("root-targeted-result");
+		routeRoots.push(path.dirname(route.eventSink));
+		const requestedAt = Date.now();
+		writeNestedControlResult(route, { ts: requestedAt, requestId: "older", targetRunId: "child", ok: true, message: "older result" });
+		writeNestedEvent(route, {
+			type: "subagent.nested.updated",
+			ts: requestedAt + 1,
+			parentRunId: route.rootRunId,
+			child: { id: "child", parentRunId: route.rootRunId, depth: 1, path: [], state: "running" },
+		});
+		const ignoredFiles = snapshotNestedEventFiles(route);
+		writeNestedControlResult(route, { ts: requestedAt - 1, requestId: "target", targetRunId: "child", ok: true, message: "target result" });
+
+		assert.equal(findNestedControlResult(route, "target", "child", ignoredFiles)?.message, "target result");
+		assert.equal(findNestedControlResult(route, "older", "child", ignoredFiles), undefined);
+		assert.equal(readNestedControlResults(route).length, 2);
+	});
+
 	it("routes interrupt to an explicit nested id through the control inbox", async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-control-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/nested-events.test.ts

@@ -157,14 +157,18 @@ describe("nested event parsing and projection", () => {
 			ts: 200,
 			parentRunId: "root-run",
 			parentStepIndex: 1,
-			child: { ...child("nested-a", "running", 200), currentTool: "read" },
+			child: {
+				...child("nested-a", "running", 200),
+				currentTool: "read",
+				runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", ids: ["ext.ok", "bad/path", "ext.ok"], omitted: 1 },
+			},
 		});
 		writeNestedEvent(route, {
 			type: "subagent.nested.completed",
 			ts: 300,
 			parentRunId: "root-run",
 			parentStepIndex: 1,
-			child: child("nested-a", "complete", 300),
+			child: { ...child("nested-a", "complete", 300), runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", ids: ["ext.ok", "bad/path", "ext.ok"], omitted: 1 } },
 		});
 
 		const registry = projectNestedEvents(route);
@@ -172,6 +176,12 @@ describe("nested event parsing and projection", () => {
 		assert.equal(registry.children[0]?.id, "nested-a");
 		assert.equal(registry.children[0]?.state, "complete");
 		assert.equal(registry.children[0]?.steps?.[0]?.agent, "leaf");
+		assert.deepEqual(registry.children[0]?.runtimeAcknowledgedExtensions, {
+			version: 1,
+			source: "child-runtime",
+			ids: ["ext.ok"],
+			omitted: 1,
+		});
 
 		const job: AsyncJobState = {
 			asyncId: "root-run",
@@ -349,6 +359,24 @@ describe("nested event parsing and projection", () => {
 		assert.equal(summary.steps?.[0]?.processTerminal?.reason, "proof-write-failed");
 	});
 
+	it("sanitizes runtime acknowledged extensions in nested status summaries", () => {
+		const summary = nestedSummaryFromAsyncStatus({
+			runId: "child-run",
+			mode: "single",
+			state: "complete",
+			startedAt: 1,
+			runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", ids: ["/Users/alice/.secret-extension", "ok-ext", "x".repeat(5000)], omitted: 0 } as never,
+			steps: [{
+				agent: "worker",
+				status: "complete",
+				runtimeAcknowledgedExtensions: { version: 1, source: "child-runtime", ids: ["C:/Users/alice/secret"], omitted: 0 } as never,
+			}],
+		}, "/tmp/child-run", { id: "child-run", parentRunId: "parent-run", depth: 1, mode: "single", ts: 2 });
+
+		assert.deepEqual(summary.runtimeAcknowledgedExtensions?.ids, ["ok-ext"]);
+		assert.equal(summary.steps?.[0]?.runtimeAcknowledgedExtensions, undefined);
+	});
+
 	it("removes evicted status files without replaying completed children", () => {
 		const route = trackRoute();
 		for (let index = 0; index < 1000; index++) {

package/dist/extensions/pi-subagents/test/unit/notify.test.ts

@@ -140,6 +140,12 @@ describe("registerSubagentNotify", () => {
 		assert.equal(sent.length, 1);
 	});
 
+	it("suppresses local delivery after an acknowledged grouped intercom relay", async () => {
+		const { notifier, sent } = createPi("session-a");
+		assert.equal(await notifier.deliver(completionResult({ id: "intercom-delivered", intercomDelivered: true })), true);
+		assert.equal(sent.length, 0);
+	});
+
 	it("rejects a pending batch when the notifier is disposed", async () => {
 		const clock = createFakeClock();
 		const { notifier, sent } = createBatchingPi(clock);
@@ -466,10 +472,12 @@ describe("completion formatting helpers", () => {
 		notifier.dispose();
 	});
 
-	it("buildCompletionDetails derives paused status from state and summary", () => {
+	it("buildCompletionDetails derives paused and stopped statuses", () => {
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, state: "paused", summary: "Paused after interrupt.", timestamp: 1 }).status, "paused");
 		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "boom", exitCode: 1, timestamp: 1 }).status, "failed");
-		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: true, summary: "ok", exitCode: 0, timestamp: 1 }).status, "completed");
+		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "terminated", exitCode: 1, processSignal: "SIGTERM", timestamp: 1 }).status, "stopped");
+		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: false, summary: "terminated", results: [{ success: false, exitCode: 1, processSignal: "SIGTERM" }], timestamp: 1 }).status, "stopped");
+		assert.equal(buildCompletionDetails({ id: "x", agent: "w", success: true, summary: "ok", exitCode: 0, processSignal: "SIGTERM", timestamp: 1 }).status, "completed");
 	});
 
 	it("buildCompletionDetails falls back to the unknown agent label", () => {

package/dist/extensions/pi-subagents/test/unit/parallel-utils.test.ts

@@ -153,6 +153,28 @@ describe("mapConcurrent", () => {
 		assert.ok(d2 < 20, `worker 2 should start immediately, got ${d2}ms delay`);
 	});
 
+	it("notifies scheduling settlement only after workers outliving an early rejection stop", async () => {
+		let release!: () => void;
+		const gate = new Promise<void>((resolve) => { release = resolve; });
+		const started: number[] = [];
+		let schedulingSettled = false;
+		const run = mapConcurrent([0, 1, 2], 2, async (item) => {
+			started.push(item);
+			if (item === 0) throw new Error("early rejection");
+			await gate;
+			return item;
+		}, undefined, () => { schedulingSettled = true; });
+
+		await assert.rejects(run, /early rejection/);
+		assert.equal(schedulingSettled, false);
+		release();
+		for (let attempt = 0; attempt < 20 && !schedulingSettled; attempt++) {
+			await new Promise((resolve) => setTimeout(resolve, 5));
+		}
+		assert.equal(schedulingSettled, true);
+		assert.deepEqual(started, [0, 1, 2]);
+	});
+
 	it("respects a shared global semaphore across simultaneous calls", async () => {
 		const globalSemaphore = new Semaphore(2);
 		let running = 0;

package/dist/extensions/pi-subagents/test/unit/pi-args.test.ts

@@ -23,8 +23,12 @@ import {
 	SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV,
 	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
 	SUBAGENT_RUN_ID_ENV,
+	PI_INTERCOM_STABLE_ID_ENV,
+	PI_INTERCOM_SESSION_ID_ENV,
 	applyThinkingSuffix,
 	buildPiArgs,
+	projectLaunchResolvedChildExtensions,
+	resolvePiLaunchToolPlan,
 } from "../../src/runs/shared/pi-args.ts";
 
 const originalEnv = {
@@ -45,6 +49,10 @@ const originalEnv = {
 	[MCP_DIRECT_CHILD_TOOLS_ENV]: process.env[MCP_DIRECT_CHILD_TOOLS_ENV],
 	[TOOL_BUDGET_ZERO_AUTH_ENV]: process.env[TOOL_BUDGET_ZERO_AUTH_ENV],
 	[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV]: process.env[SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV],
+	[PI_INTERCOM_STABLE_ID_ENV]: process.env[PI_INTERCOM_STABLE_ID_ENV],
+	[PI_INTERCOM_SESSION_ID_ENV]: process.env[PI_INTERCOM_SESSION_ID_ENV],
+	MCP_HASH_ROOT: process.env.MCP_HASH_ROOT,
+	MCP_HASH_TOKEN: process.env.MCP_HASH_TOKEN,
 };
 const originalCwd = process.cwd();
 const tempRoots: string[] = [];
@@ -126,6 +134,29 @@ afterEach(() => {
 });
 
 describe("buildPiArgs session wiring", () => {
+	it("projects launch-resolved extension identifiers without raw paths", () => {
+		const privateExt = path.join(os.tmpdir(), "private-extension-root", "secret-extension.ts");
+		const toolExt = path.join(os.tmpdir(), "tool-extension-root", "tool-extension.ts");
+		const plan = resolvePiLaunchToolPlan({
+			tools: ["read", toolExt],
+			extensions: [privateExt],
+			subagentOnlyExtensions: ["package-extension"],
+		});
+
+		const projection = projectLaunchResolvedChildExtensions(plan);
+
+		assert.equal(projection.version, 1);
+		assert.equal(projection.source, "launch-resolved");
+		assert.equal(projection.disableAmbientExtensions, true);
+		assert.equal(projection.runtime.length, 1);
+		assert.equal(projection.configured.length, 3);
+		assert.equal(projection.effective.length, 4);
+		for (const id of [...projection.runtime, ...projection.configured, ...projection.effective]) {
+			assert.match(id, /^sha256:[a-f0-9]{16}$/);
+		}
+		assert.ok(!JSON.stringify(projection).includes(os.tmpdir()), "projection should not expose raw extension paths");
+	});
+
 	it("uses --session when sessionFile is provided", () => {
 		const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-args-session-"));
 		try {
@@ -415,11 +446,24 @@ describe("buildPiArgs system prompt mode wiring", () => {
 
 		const extensionArgs = args.filter((arg, index) => args[index - 1] === "--extension");
 		assert.ok(extensionArgs.some((arg) => arg.endsWith(path.join("src", "runs", "shared", "subagent-prompt-runtime.ts"))));
+		assert.ok(args.includes("--no-context-files"));
 		assert.equal(env.SELESAI_SUBAGENT_CHILD, "1");
 		assert.equal(env.SELESAI_SUBAGENT_INHERIT_PROJECT_CONTEXT, "0");
 		assert.equal(env.SELESAI_SUBAGENT_INHERIT_SKILLS, "1");
 	});
 
+	it("keeps context file loading enabled when project context is inherited", () => {
+		const { args } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "hello",
+			sessionEnabled: false,
+			inheritProjectContext: true,
+			inheritSkills: true,
+		});
+
+		assert.equal(args.includes("--no-context-files"), false);
+	});
+
 	it("passes tool budget through env", () => {
 		const { env } = buildPiArgs({
 			baseArgs: ["-p"],
@@ -475,6 +519,8 @@ describe("buildPiArgs system prompt mode wiring", () => {
 	});
 
 	it("passes child intercom and orchestrator metadata through env", () => {
+		process.env[PI_INTERCOM_STABLE_ID_ENV] = "subagent-chat-parent";
+		process.env[PI_INTERCOM_SESSION_ID_ENV] = "session-parent-runtime";
 		const { env } = buildPiArgs({
 			baseArgs: ["-p"],
 			task: "hello",
@@ -490,6 +536,8 @@ describe("buildPiArgs system prompt mode wiring", () => {
 		});
 
 		assert.equal(env.SELESAI_SUBAGENT_INTERCOM_SESSION_NAME, "subagent-worker-78f659a3");
+		assert.equal(env[PI_INTERCOM_STABLE_ID_ENV], "subagent-worker-78f659a3");
+		assert.equal(env[PI_INTERCOM_SESSION_ID_ENV], undefined);
 		assert.equal(env.SELESAI_SUBAGENT_ORCHESTRATOR_TARGET, "subagent-chat-parent");
 		assert.equal(env[SUBAGENT_ORCHESTRATOR_SESSION_ID_ENV], "session-parent-123");
 		assert.equal(env.SELESAI_SUBAGENT_RUN_ID, "78f659a3");
@@ -499,6 +547,21 @@ describe("buildPiArgs system prompt mode wiring", () => {
 		assert.match(env[SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV] ?? "", /supervisor-channels/);
 	});
 
+	it("clears inherited pi-intercom identity when no child intercom session name is set", () => {
+		process.env[PI_INTERCOM_STABLE_ID_ENV] = "subagent-chat-parent";
+		process.env[PI_INTERCOM_SESSION_ID_ENV] = "session-parent-runtime";
+		const { env } = buildPiArgs({
+			baseArgs: ["-p"],
+			task: "hello",
+			sessionEnabled: false,
+			inheritProjectContext: true,
+			inheritSkills: true,
+		});
+
+		assert.equal(env[PI_INTERCOM_STABLE_ID_ENV], undefined);
+		assert.equal(env[PI_INTERCOM_SESSION_ID_ENV], undefined);
+	});
+
 	it("does not create a supervisor channel without an exact parent session id", () => {
 		const { env } = buildPiArgs({
 			baseArgs: ["-p"],
@@ -592,6 +655,46 @@ describe("buildPiArgs system prompt mode wiring", () => {
 		assert.equal(args[args.indexOf("--tools") + 1], "read,bash");
 	});
 
+	it("includes adapter tool filters in MCP cache identity", () => {
+		const base = { command: "npx", args: ["browser-mcp"] };
+
+		assert.notEqual(
+			computeMcpServerHash(base),
+			computeMcpServerHash({ ...base, includeTools: ["browser_navigate"] }),
+		);
+	});
+
+	it("matches pi-mcp-adapter 2.15.0 metadata cache hashes", () => {
+		process.env.MCP_HASH_ROOT = "/tmp/mcp-root";
+		process.env.MCP_HASH_TOKEN = "token-value";
+
+		assert.deepEqual(
+			[
+				computeMcpServerHash({
+					command: "npx",
+					args: ["-y", "browser-mcp"],
+					env: { ROOT: "{env:MCP_HASH_ROOT}", SECRET_COMMAND: "!op read test" },
+					cwd: "${MCP_HASH_ROOT}/server",
+					exposeResources: false,
+					includeTools: ["browser_navigate"],
+					excludeTools: ["browser_close"],
+				}),
+				computeMcpServerHash({
+					url: "https://example.test/$env:MCP_HASH_TOKEN",
+					headers: { Authorization: "Bearer ${MCP_HASH_TOKEN}", Secret: "!op read test" },
+					auth: "bearer",
+					bearerTokenEnv: "MCP_HASH_TOKEN",
+				}),
+				computeMcpServerHash({ socket: "{env:MCP_HASH_ROOT}/rmcp.sock" }),
+			],
+			[
+				"8af47bd5a801f42bd252789826df883c6f4db6f1d425b82f8561d75063fbe3a8",
+				"77db141e556d24c3740a4b4f0cd50d8c23309a28062282cc1ca724207359ef5a",
+				"77f7f77a3e8df990d8c78e99ca81508fd8d1f954e814ee7cbfa46719f71eb46b",
+			],
+		);
+	});
+
 	it("augments explicit builtin allowlists with selected direct MCP tool names", () => {
 		const fixture = createMcpFixture();
 		writeMcpFixture(fixture);

package/dist/extensions/pi-subagents/test/unit/pi-coding-agent-dir.test.ts

@@ -252,6 +252,24 @@ Package skill content.
 		assert.equal(history[1]?.taskHash, taskHash("legacy customer secret"));
 	});
 
+	it("re-sanitizes run history after an external write", () => {
+		recordRun("env-agent", "first secret", 0, 1);
+		const historyPath = path.join(agentDir, "run-history.jsonl");
+		fs.appendFileSync(historyPath, `${JSON.stringify({
+			agent: "env-agent",
+			task: "externally written secret",
+			ts: 2,
+			status: "ok",
+			duration: 2,
+		})}\n`);
+
+		recordRun("env-agent", "second secret", 0, 3);
+
+		const rawHistory = fs.readFileSync(historyPath, "utf-8");
+		assert.doesNotMatch(rawHistory, /first secret|externally written secret|second secret/);
+		assert.equal(loadRunsForAgent("env-agent").length, 3);
+	});
+
 	it("uses the configured agent dir for subagent bridge instruction files", () => {
 		const instructionPath = path.join(agentDir, "extensions", "subagent", "bridge.md");
 		writeFile(instructionPath, "Native bridge for {orchestratorTarget}");

package/dist/extensions/pi-subagents/test/unit/preflight.test.ts

@@ -153,6 +153,52 @@ Project prompt.
 		}
 	});
 
+	it("resolves agent aliases to the canonical launch contract agent", async () => {
+		const cwd = path.join(tempDir, "repo-alias");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+aliases: shipper, worker-alias
+---
+Project prompt.
+`);
+
+		const result = await resolveSubagentLaunchContract({
+			agent: "shipper",
+			cwd,
+			task: "Implement the change",
+		});
+
+		assert.equal(result.ok, true);
+		assert.equal(result.contract.agent.name, "worker");
+	});
+
+	it("reports alias collisions as ambiguous agents", async () => {
+		const cwd = path.join(tempDir, "repo-alias-collision");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "worker.md"), `---
+name: worker
+description: Project worker
+aliases: shared-alias
+---
+Project prompt.
+`);
+		writeAgent(path.join(cwd, ".selesai", "agents", "reviewer.md"), `---
+name: reviewer
+description: Project reviewer
+aliases: shared-alias
+---
+Review prompt.
+`);
+
+		const result = await resolveSubagentLaunchContract({ agent: "shared-alias", cwd });
+
+		assert.equal(result.ok, false);
+		assert.equal(result.code, "ambiguous_agent");
+		assert.match(result.message, /Ambiguous agent alias 'shared-alias': reviewer, worker|Ambiguous agent alias 'shared-alias': worker, reviewer/);
+	});
+
 	it("changes definition and launch digests when selected agent content changes", async () => {
 		const cwd = path.join(tempDir, "repo");
 		fs.mkdirSync(cwd, { recursive: true });

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

@@ -3,7 +3,7 @@ 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";
+import { renderSubagentResult, truncLine } from "../../src/tui/render.ts";
 
 const theme = {
 	fg(_name: string, text: string): string {
@@ -49,6 +49,18 @@ test("row keeps styled multiline content within the available width", () => {
 	assert.doesNotMatch(rendered, /[\r\n\t]/);
 });
 
+test("truncLine preserves ANSI styles and resets through the ellipsis", () => {
+	assert.equal(truncLine("\u001b[31mabcdef\u001b[0m", 4), "\u001b[31mabc\u001b[31m…");
+	assert.equal(truncLine("\u001b[31mab\u001b[0mcdef", 4), "\u001b[31mab\u001b[0mc…");
+	assert.equal(truncLine("ab\u001b[xcd", 4), "ab\u001b[…");
+});
+
+test("truncLine respects grapheme display width", () => {
+	const rendered = truncLine("🙂🙂🙂", 5);
+	assert.equal(rendered, "🙂🙂…");
+	assert.equal(visibleWidth(rendered), 5);
+});
+
 test("compact chain rendering uses workflow graph spans for dynamic fanout results", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "done" }],

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

@@ -43,13 +43,14 @@ describe("result intercom formatter", () => {
 		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, /Process status: failed/);
 		assert.match(payload.message, /Children: 1 completed, 1 failed/);
+		assert.match(payload.message, /Outputs: 2 unknown \(semantic adequacy unassessed\)/);
 		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, /1\. reviewer-a — process completed · output unknown/);
 		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, /2\. reviewer-b — process failed · output unknown/);
 		assert.match(payload.message, /Output artifact: \/tmp\/a\.md/);
 		assert.match(payload.message, /Session: \/tmp\/a-session\.jsonl/);
 	});
@@ -161,6 +162,27 @@ describe("result intercom formatter", () => {
 		assert.match(payload.message, /↳ reviewer — complete \[nested-a\]/);
 	});
 
+	it("separates process failure from output presence and gives salvage guidance", () => {
+		const payload = buildSubagentResultIntercomPayload({
+			to: "chat",
+			runId: "run-salvage",
+			mode: "parallel",
+			source: "foreground",
+			children: [
+				{ agent: "a", status: "completed", outputState: "present", summary: "answer a" },
+				{ agent: "b", status: "failed", outputState: "present", summary: "runner crashed after answer b" },
+				{ agent: "c", status: "failed", outputState: "absent", summary: "startup failed" },
+			],
+		});
+
+		assert.equal(payload.status, "failed");
+		assert.equal(payload.children[1]?.outputState, "present");
+		assert.match(payload.message, /Process status: failed/);
+		assert.match(payload.message, /Outputs: 2 present, 1 absent \(semantic adequacy unassessed\)/);
+		assert.match(payload.message, /Inspect that output before retrying/);
+		assert.match(payload.message, /2\. b — process failed · output present/);
+	});
+
 	it("keeps full child summaries inside grouped payloads", () => {
 		const longSummary = `${"x".repeat(2000)}\n${"y".repeat(2000)}`;
 		const payload = buildSubagentResultIntercomPayload({
@@ -217,9 +239,12 @@ describe("result intercom formatter", () => {
 		assert.equal(stripped.results[0]?.truncation, undefined);
 	});
 
-	it("resolves paused and detached statuses", () => {
+	it("resolves paused, detached, and signal-terminated statuses", () => {
 		assert.equal(resolveSubagentResultStatus({ interrupted: true }), "paused");
 		assert.equal(resolveSubagentResultStatus({ detached: true }), "detached");
+		assert.equal(resolveSubagentResultStatus({ processSignal: "SIGTERM", exitCode: 1 }), "stopped");
+		assert.equal(resolveSubagentResultStatus({ processSignal: "SIGTERM", exitCode: 1, timedOut: true }), "failed");
+		assert.equal(resolveSubagentResultStatus({ processSignal: "SIGTERM", exitCode: 0, success: true }), "completed");
 		assert.equal(resolveSubagentResultStatus({ success: true }), "completed");
 		assert.equal(resolveSubagentResultStatus({ exitCode: 1 }), "failed");
 	});