@selesai/code 0.13.15 → 0.13.18

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

@@ -6,31 +6,13 @@ import { afterEach, describe, it } from "node:test";
 import registerFanoutChildSubagentExtension from "../../src/extension/fanout-child.ts";
 import { createSubagentExecutor, readNestedRecoveryDescriptor } from "../../src/runs/foreground/subagent-executor.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,
-	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-	SUBAGENT_PARENT_CHILD_INDEX_ENV,
-	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-	SUBAGENT_PARENT_EVENT_SINK_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-	SUBAGENT_PARENT_RUN_ID_ENV,
-} from "../../src/runs/shared/pi-args.ts";
+import type { ChildRuntimeConfig } from "../../src/runs/shared/child-runtime-config.ts";
 import { ASYNC_DIR, type SubagentState } from "../../src/shared/types.ts";
 import { createRunFanoutBudget } from "../../src/runs/shared/run-fanout-budget.ts";
+import { getArtifactPaths, getArtifactsDir } from "../../src/shared/artifacts.ts";
 
 const routeRoots: string[] = [];
 const fanoutListenerCleanupKey = "__piSubagentFanoutChildNestedControlInboxCleanups";
-const savedEnv = {
-	[SUBAGENT_CHILD_ENV]: process.env[SUBAGENT_CHILD_ENV],
-	[SUBAGENT_FANOUT_CHILD_ENV]: process.env[SUBAGENT_FANOUT_CHILD_ENV],
-	[SUBAGENT_PARENT_EVENT_SINK_ENV]: process.env[SUBAGENT_PARENT_EVENT_SINK_ENV],
-	[SUBAGENT_PARENT_CONTROL_INBOX_ENV]: process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV],
-	[SUBAGENT_PARENT_ROOT_RUN_ID_ENV]: process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV],
-	[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV],
-	[SUBAGENT_PARENT_RUN_ID_ENV]: process.env[SUBAGENT_PARENT_RUN_ID_ENV],
-	[SUBAGENT_PARENT_CHILD_INDEX_ENV]: process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV],
-};
 
 afterEach(() => {
 	const globalStore = globalThis as Record<string, unknown>;
@@ -43,10 +25,6 @@ afterEach(() => {
 	}
 	delete globalStore[fanoutListenerCleanupKey];
 	for (const root of routeRoots.splice(0)) fs.rmSync(root, { recursive: true, force: true });
-	for (const [key, value] of Object.entries(savedEnv)) {
-		if (value === undefined) delete process.env[key];
-		else process.env[key] = value;
-	}
 });
 
 function createState(): SubagentState {
@@ -68,7 +46,7 @@ function createState(): SubagentState {
 	};
 }
 
-function createExecutor(state = createState(), agents: Array<Record<string, unknown>> = [], allowMutatingManagementActions = true, events: any = { emit() {}, on() { return () => {}; } }) {
+function createExecutor(state = createState(), agents: Array<Record<string, unknown>> = [], allowMutatingManagementActions = true, events: any = { emit() {}, on() { return () => {}; } }, childRuntime?: ChildRuntimeConfig) {
 	return createSubagentExecutor({
 		pi: { events, getSessionName() { return "parent"; } } as any,
 		state,
@@ -79,6 +57,7 @@ function createExecutor(state = createState(), agents: Array<Record<string, unkn
 		expandTilde: (value) => value,
 		discoverAgents: () => ({ agents: agents as any }),
 		allowMutatingManagementActions,
+		...(childRuntime ? { childRuntime } : {}),
 	});
 }
 
@@ -117,13 +96,16 @@ function stateWithNestedRoute(route: ReturnType<typeof createNestedRoute>): Suba
 	return state;
 }
 
-function setNestedRouteEnv(route: ReturnType<typeof createNestedRoute>, parentRunId = route.rootRunId) {
-	process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] = route.eventSink;
-	process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] = route.controlInbox;
-	process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] = route.rootRunId;
-	process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = route.capabilityToken;
-	process.env[SUBAGENT_PARENT_RUN_ID_ENV] = parentRunId;
-	process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = "0";
+/** The child runtime config of a fanout child launched under `route` by `parentRunId`. */
+function fanoutChildRuntime(route: ReturnType<typeof createNestedRoute>, parentRunId = route.rootRunId): ChildRuntimeConfig {
+	return {
+		fanoutChild: true,
+		depth: 1,
+		waitTool: { enabled: true },
+		fast: false,
+		nestedRoute: route,
+		nestedParent: { parentRunId, parentChildIndex: 0, depth: 1, path: [{ runId: parentRunId, stepIndex: 0 }] },
+	};
 }
 
 function text(result: Awaited<ReturnType<ReturnType<typeof createExecutor>["execute"]>>): string {
@@ -183,8 +165,15 @@ describe("nested control routing", () => {
 		try {
 			const route = createNestedRun("nested-foreground");
 			const state = createState();
+			state.artifactDirPreference = "project";
+			const artifactRoot = getArtifactsDir(null, root, "project");
+			fs.mkdirSync(artifactRoot, { recursive: true });
+			fs.writeFileSync(getArtifactPaths(artifactRoot, "root-control", "orchestrator", 0).transcriptPath,
+				`${JSON.stringify({ recordType: "message", role: "assistant", text: "LIVE_FOREGROUND_ACTIVITY" })}\n`);
 			state.foregroundControls.set("root-control", {
 				runId: "root-control",
+				sessionId: "session",
+				cwd: root,
 				mode: "single",
 				startedAt: 1,
 				updatedAt: 1,
@@ -205,6 +194,12 @@ describe("nested control routing", () => {
 			const transcript = await createExecutor(state).execute("transcript", { action: "status", id: "root-control", index: 0, view: "transcript" }, new AbortController().signal, undefined, ctx(root));
 			assert.equal(transcript.isError, undefined);
 			assert.match(text(transcript), /^Transcript target: run root-control · child 0\nSpawn budget:/);
+			assert.match(text(transcript), /LIVE_FOREGROUND_ACTIVITY/);
+			for (const hasUI of [false, true]) {
+				const implicit = await createExecutor(state).execute("implicit-transcript", { action: "status", view: "transcript" }, new AbortController().signal, undefined, { ...ctx(root), hasUI });
+				assert.equal(implicit.isError, undefined);
+				assert.match(text(implicit), /LIVE_FOREGROUND_ACTIVITY/);
+			}
 		} finally {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
@@ -250,7 +245,6 @@ describe("nested control routing", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-child-scope-"));
 		try {
 			const allowedRoute = createNestedRun("shared-nested");
-			setNestedRouteEnv(allowedRoute, "root-control");
 			const outsideRoute = createNestedRoute("root-outside");
 			routeRoots.push(path.dirname(outsideRoute.eventSink));
 			writeNestedEvent(outsideRoute, {
@@ -261,7 +255,7 @@ describe("nested control routing", () => {
 				child: { id: "shared-nested", parentRunId: "root-outside", parentStepIndex: 0, depth: 1, path: [{ runId: "root-outside", stepIndex: 0 }], state: "running", agent: "outside" },
 			});
 
-			const result = await createExecutor(createState(), [], false).execute("status", { action: "status", id: "shared-nested" }, new AbortController().signal, undefined, ctx(root));
+			const result = await createExecutor(createState(), [], false, undefined, fanoutChildRuntime(allowedRoute, "root-control")).execute("status", { action: "status", id: "shared-nested" }, new AbortController().signal, undefined, ctx(root));
 
 			assert.equal(result.isError, undefined);
 			assert.match(text(result), /Nested run: shared-nested/);
@@ -337,22 +331,33 @@ describe("nested control routing", () => {
 		}
 	});
 
-	it("routes resume for live nested runs through the control inbox", async () => {
+	for (const workflow of [false, true]) it(`routes ${workflow ? "workflow string" : "action"} resume for live nested runs through the control inbox`, async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-live-resume-"));
 		try {
 			const emitted: Array<{ name: string; payload: unknown }> = [];
 			const events = { emit(name: string, payload: unknown) { emitted.push({ name, payload }); }, on() { return () => {}; } };
 			const route = createNestedRun("nested-live-resume", "running", { intercomTarget: "attacker-target", leafIntercomTarget: "attacker-leaf" });
 			const executor = createExecutor(stateWithNestedRoute(route), [], true, events);
-			setTimeout(() => {
-				const request = readNestedControlRequests(route)[0];
+			const responder = (async () => {
+				const deadline = Date.now() + 2_000;
+				let request = readNestedControlRequests(route)[0];
+				while (!request && Date.now() < deadline) {
+					await new Promise((resolve) => setTimeout(resolve, 10));
+					request = readNestedControlRequests(route)[0];
+				}
 				assert.ok(request, "expected a nested resume request");
 				assert.equal(request.action, "resume");
 				assert.equal(request.message, "continue please");
 				writeNestedControlResult(route, { ts: Date.now(), requestId: request.requestId, targetRunId: request.targetRunId, ok: true, message: "nested resume accepted" });
-			}, 50);
+			})();
 
-			const result = await executor.execute("resume", { action: "resume", id: "nested-live-resume", message: "continue please" }, new AbortController().signal, undefined, ctx(root));
+			const execution = Promise.resolve().then(() => executor.execute("resume", workflow
+				? { async: false, workflowScript: `return runs.run("live", { resume: "nested-live-resume", task: "continue please", output: false });` }
+				: { action: "resume", id: "nested-live-resume", message: "continue please" }, new AbortController().signal, undefined, ctx(root)));
+			const [response, executed] = await Promise.allSettled([responder, execution]);
+			if (response.status === "rejected") throw response.reason;
+			if (executed.status === "rejected") throw executed.reason;
+			const result = executed.value;
 
 			assert.equal(result.isError, undefined);
 			assert.match(text(result), /nested resume accepted/);
@@ -407,13 +412,15 @@ describe("nested control routing", () => {
 		}
 	});
 
-	it("rejects stopped nested runs before attempting revival", async () => {
+	for (const workflow of [false, true]) it(`rejects stopped nested runs before ${workflow ? "workflow string resume" : "action revival"}`, async () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-nested-stopped-resume-"));
 		try {
 			const route = createNestedRun("nested-stopped-resume", "stopped", { sessionFile: path.join(root, "missing-session.jsonl") });
 
 			const result = await createExecutor(stateWithNestedRoute(route), [{ name: "worker", description: "Worker", prompt: "Do work" }])
-				.execute("resume", { action: "resume", id: "nested-stopped-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root));
+				.execute("resume", workflow
+					? { async: false, workflowScript: `return runs.run("stopped", { resume: "nested-stopped-resume", task: "continue", output: false });` }
+					: { action: "resume", id: "nested-stopped-resume", message: "continue" }, new AbortController().signal, undefined, ctx(root));
 
 			assert.equal(result.isError, true);
 			assert.match(text(result), /was stopped and cannot be resumed/);
@@ -468,13 +475,12 @@ describe("nested control routing", () => {
 		try {
 			const route = createNestedRoute("root-parent");
 			routeRoots.push(path.dirname(route.eventSink));
-			setNestedRouteEnv(route, "root-parent");
 			const throwingCtx = {
 				...ctx(root),
 				modelRegistry: { getAvailable() { throw new Error("model registry exploded"); } },
 			};
 
-			const result = await createExecutor(createState(), [{ name: "worker", description: "Worker", prompt: "Do work" }])
+			const result = await createExecutor(createState(), [{ name: "worker", description: "Worker", prompt: "Do work" }], true, undefined, fanoutChildRuntime(route, "root-parent"))
 				.execute("run", { agent: "worker", task: "go" }, new AbortController().signal, undefined, throwingCtx);
 
 			assert.equal(result.isError, true);
@@ -491,9 +497,7 @@ describe("nested control routing", () => {
 	it("keeps the fanout child control listener alive after control inbox polling errors", async () => {
 		const route = createNestedRoute("root-poll-error");
 		routeRoots.push(path.dirname(route.eventSink));
-		setNestedRouteEnv(route, "root-poll-error");
-		process.env[SUBAGENT_CHILD_ENV] = "1";
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+		const childRuntime = fanoutChildRuntime(route, "root-poll-error");
 		const pi = {
 			events: { emit() {}, on() { return () => {}; } },
 			registerTool() {},
@@ -507,7 +511,7 @@ describe("nested control routing", () => {
 			logged.push(args);
 		};
 		try {
-			registerFanoutChildSubagentExtension(pi);
+			registerFanoutChildSubagentExtension(pi, childRuntime);
 			await waitFor(() => logged.some((entry) => String(entry[0] ?? "").includes(route.controlInbox) && String(entry[0] ?? "").includes("root-poll-error")));
 
 			fs.rmSync(route.controlInbox, { force: true });
@@ -529,9 +533,7 @@ describe("nested control routing", () => {
 	it("keeps fanout child control requests when result writing fails and retries after recovery", async () => {
 		const route = createNestedRoute("root-result-write-fails");
 		routeRoots.push(path.dirname(route.eventSink));
-		setNestedRouteEnv(route, "root-result-write-fails");
-		process.env[SUBAGENT_CHILD_ENV] = "1";
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+		const childRuntime = fanoutChildRuntime(route, "root-result-write-fails");
 		const pi = {
 			events: { emit() {}, on() { return () => {}; } },
 			registerTool() {},
@@ -551,7 +553,7 @@ describe("nested control routing", () => {
 			logged.push(args);
 		};
 		try {
-			registerFanoutChildSubagentExtension(pi);
+			registerFanoutChildSubagentExtension(pi, childRuntime);
 			await waitFor(() => logged.some((entry) => String(entry[0] ?? "").includes("result-write-fails") && /keeping request for retry/.test(String(entry[0] ?? ""))));
 			assert.equal(fs.existsSync(requestPath), true);
 
@@ -567,9 +569,7 @@ describe("nested control routing", () => {
 	it("cleans the prior listener on reload and processes a resume request once", async () => {
 		const route = createNestedRoute("root-reload-listener");
 		routeRoots.push(path.dirname(route.eventSink));
-		setNestedRouteEnv(route, "root-reload-listener");
-		process.env[SUBAGENT_CHILD_ENV] = "1";
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+		const childRuntime = fanoutChildRuntime(route, "root-reload-listener");
 		const registrations: string[] = [];
 		const activeIntervals = new Set<ReturnType<typeof setInterval>>();
 		const originalSetInterval = globalThis.setInterval;
@@ -591,25 +591,19 @@ describe("nested control routing", () => {
 			}) as any;
 			const firstPi = makePi();
 
-			registerFanoutChildSubagentExtension(firstPi);
-			registerFanoutChildSubagentExtension(firstPi);
-			registerFanoutChildSubagentExtension(makePi());
+			registerFanoutChildSubagentExtension(firstPi, childRuntime);
+			registerFanoutChildSubagentExtension(firstPi, childRuntime);
+			registerFanoutChildSubagentExtension(makePi(), childRuntime);
 			assert.equal(activeIntervals.size, 1);
 
 			const unrelatedRoute = createNestedRoute("root-unrelated-listener");
 			routeRoots.push(path.dirname(unrelatedRoute.eventSink));
-			setNestedRouteEnv(unrelatedRoute, "root-unrelated-listener");
-			registerFanoutChildSubagentExtension(makePi());
+			registerFanoutChildSubagentExtension(makePi(), fanoutChildRuntime(unrelatedRoute, "root-unrelated-listener"));
 			assert.equal(activeIntervals.size, 2);
 
-			delete process.env[SUBAGENT_PARENT_EVENT_SINK_ENV];
-			delete process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV];
-			delete process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV];
-			delete process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV];
-			registerFanoutChildSubagentExtension(makePi());
+			registerFanoutChildSubagentExtension(makePi(), { ...childRuntime, nestedRoute: undefined });
 			assert.equal(activeIntervals.size, 2);
 
-			setNestedRouteEnv(route, "root-reload-listener");
 			writeNestedControlRequest(route, {
 				ts: Date.now(),
 				requestId: "reload-resume-once",
@@ -630,9 +624,7 @@ describe("nested control routing", () => {
 	it("negatively acknowledges ownerless fanout child control requests and removes them", async () => {
 		const route = createNestedRoute("root-ownerless");
 		routeRoots.push(path.dirname(route.eventSink));
-		setNestedRouteEnv(route, "root-ownerless");
-		process.env[SUBAGENT_CHILD_ENV] = "1";
-		process.env[SUBAGENT_FANOUT_CHILD_ENV] = "1";
+		const childRuntime = fanoutChildRuntime(route, "root-ownerless");
 		const pi = {
 			events: { emit() {}, on() { return () => {}; } },
 			registerTool() {},
@@ -645,11 +637,11 @@ describe("nested control routing", () => {
 			action: "interrupt",
 		});
 
-		registerFanoutChildSubagentExtension(pi);
+		registerFanoutChildSubagentExtension(pi, childRuntime);
 		await waitFor(() => readNestedControlResults(route).some((result) => result.requestId === "ownerless-request" && result.ok === false));
 
 		assert.equal(fs.existsSync(requestPath), false);
 		const result = readNestedControlResults(route).find((item) => item.requestId === "ownerless-request");
 		assert.match(result?.message ?? "", /not active/);
 	});
-});
+});

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

@@ -9,35 +9,15 @@ import {
 	hasLiveNestedDescendants,
 	nestedSummaryFromAsyncStatus,
 	parseNestedEventRecords,
+	inheritedNestedParentAddressOf,
+	inheritedNestedRouteOf,
 	projectNestedEvents,
-	resolveNestedParentAddressFromEnv,
-	resolveNestedRouteFromEnv,
 	updateAsyncJobNestedProjection,
 	updateForegroundNestedProjection,
 	writeNestedEvent,
 } from "../../src/runs/shared/nested-events.ts";
-import {
-	SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV,
-	SUBAGENT_PARENT_CHILD_INDEX_ENV,
-	SUBAGENT_PARENT_CONTROL_INBOX_ENV,
-	SUBAGENT_PARENT_DEPTH_ENV,
-	SUBAGENT_PARENT_EVENT_SINK_ENV,
-	SUBAGENT_PARENT_PATH_ENV,
-	SUBAGENT_PARENT_ROOT_RUN_ID_ENV,
-	SUBAGENT_PARENT_RUN_ID_ENV,
-} from "../../src/runs/shared/pi-args.ts";
 
 const routes: Array<{ eventSink: string }> = [];
-const savedEnv = {
-	[SUBAGENT_PARENT_EVENT_SINK_ENV]: process.env[SUBAGENT_PARENT_EVENT_SINK_ENV],
-	[SUBAGENT_PARENT_CONTROL_INBOX_ENV]: process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV],
-	[SUBAGENT_PARENT_ROOT_RUN_ID_ENV]: process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV],
-	[SUBAGENT_PARENT_RUN_ID_ENV]: process.env[SUBAGENT_PARENT_RUN_ID_ENV],
-	[SUBAGENT_PARENT_CHILD_INDEX_ENV]: process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV],
-	[SUBAGENT_PARENT_DEPTH_ENV]: process.env[SUBAGENT_PARENT_DEPTH_ENV],
-	[SUBAGENT_PARENT_PATH_ENV]: process.env[SUBAGENT_PARENT_PATH_ENV],
-	[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV]: process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV],
-};
 
 async function removeDirWithRetry(dir: string): Promise<void> {
 	let lastError: unknown;
@@ -57,10 +37,6 @@ afterEach(async () => {
 	for (const route of routes.splice(0)) {
 		await removeDirWithRetry(path.dirname(route.eventSink));
 	}
-	for (const [key, value] of Object.entries(savedEnv)) {
-		if (value === undefined) delete process.env[key];
-		else process.env[key] = value;
-	}
 });
 
 function trackRoute(rootRunId = "root-run") {
@@ -69,7 +45,7 @@ function trackRoute(rootRunId = "root-run") {
 	return route;
 }
 
-function child(id: string, state: "queued" | "running" | "complete" | "failed" | "paused", ts: number, parentRunId = "root-run") {
+function child(id: string, state: "queued" | "running" | "complete" | "failed" | "paused" | "rejected", ts: number, parentRunId = "root-run") {
 	return {
 		id,
 		parentRunId,
@@ -123,17 +99,18 @@ describe("nested route index", () => {
 });
 
 describe("nested event route validation", () => {
-	it("resolves nested parent addresses with full inherited path", () => {
-		process.env[SUBAGENT_PARENT_RUN_ID_ENV] = "nested-parent";
-		process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = "2";
-		process.env[SUBAGENT_PARENT_DEPTH_ENV] = "3";
-		process.env[SUBAGENT_PARENT_PATH_ENV] = JSON.stringify([
-			{ runId: "root-run", stepIndex: 0, agent: "root-agent" },
-			{ runId: "../unsafe", stepIndex: 1, agent: "bad" },
-			{ runId: "nested-parent", stepIndex: 2, agent: "nested-agent" },
-		]);
-
-		assert.deepEqual(resolveNestedParentAddressFromEnv(), {
+	it("resolves nested parent addresses from the inherited child runtime", () => {
+		assert.deepEqual(inheritedNestedParentAddressOf({
+			nestedParent: {
+				parentRunId: "nested-parent",
+				parentChildIndex: 2,
+				depth: 3,
+				path: [
+					{ runId: "root-run", stepIndex: 0, agent: "root-agent" },
+					{ runId: "nested-parent", stepIndex: 2, agent: "nested-agent" },
+				],
+			},
+		}), {
 			parentRunId: "nested-parent",
 			parentStepIndex: 2,
 			depth: 3,
@@ -142,26 +119,33 @@ describe("nested event route validation", () => {
 				{ runId: "nested-parent", stepIndex: 2, agent: "nested-agent" },
 			],
 		});
+		assert.deepEqual(inheritedNestedParentAddressOf({ nestedParent: { parentRunId: "nested-parent", depth: 1, path: [] } }), {
+			parentRunId: "nested-parent",
+			depth: 1,
+			path: [{ runId: "nested-parent" }],
+		});
 	});
 
-	it("ignores unsafe nested parent ids from env", () => {
-		process.env[SUBAGENT_PARENT_RUN_ID_ENV] = "../unsafe";
-		process.env[SUBAGENT_PARENT_CHILD_INDEX_ENV] = "2";
-
-		assert.equal(resolveNestedParentAddressFromEnv(), undefined);
+	it("ignores unsafe nested parent ids and missing parents", () => {
+		assert.equal(inheritedNestedParentAddressOf({ nestedParent: { parentRunId: "../unsafe", parentChildIndex: 2, depth: 1, path: [] } }), undefined);
+		assert.equal(inheritedNestedParentAddressOf({}), undefined);
+		assert.equal(inheritedNestedParentAddressOf(undefined), undefined);
 	});
 
-	it("resolves only matching contained routes from env", () => {
+	it("resolves only matching contained routes from the inherited child runtime", () => {
 		const route = trackRoute();
-		process.env[SUBAGENT_PARENT_EVENT_SINK_ENV] = route.eventSink;
-		process.env[SUBAGENT_PARENT_CONTROL_INBOX_ENV] = route.controlInbox;
-		process.env[SUBAGENT_PARENT_ROOT_RUN_ID_ENV] = route.rootRunId;
-		process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = route.capabilityToken;
-
-		assert.deepEqual(resolveNestedRouteFromEnv(), route);
+		assert.deepEqual(inheritedNestedRouteOf({ nestedRoute: route }), route);
+		assert.equal(inheritedNestedRouteOf({}), undefined);
 
-		process.env[SUBAGENT_PARENT_CAPABILITY_TOKEN_ENV] = "wrong-token";
-		assert.throws(() => resolveNestedRouteFromEnv(), /capability token/);
+		const originalError = console.error;
+		const logged: unknown[] = [];
+		console.error = (...args: unknown[]) => { logged.push(args[1]); };
+		try {
+			assert.equal(inheritedNestedRouteOf({ nestedRoute: { ...route, capabilityToken: "wrong-token" } }), undefined);
+		} finally {
+			console.error = originalError;
+		}
+		assert.match(String(logged[0]), /capability token/);
 	});
 });
 
@@ -326,6 +310,27 @@ describe("nested event parsing and projection", () => {
 		}]), true);
 	});
 
+	it("preserves rejected nested states across the event and registry boundary", () => {
+		const route = trackRoute("rejected-root");
+		writeNestedEvent(route, {
+			type: "subagent.nested.completed",
+			ts: 300,
+			parentRunId: route.rootRunId,
+			parentStepIndex: 0,
+			child: {
+				...child("rejected-child", "rejected", 300, route.rootRunId),
+				parentStepIndex: 0,
+				path: [{ runId: route.rootRunId, stepIndex: 0 }],
+				steps: [{ agent: "leaf", status: "rejected" }],
+			},
+		});
+
+		const registry = projectNestedEvents(route);
+		assert.equal(registry.children[0]?.state, "rejected");
+		assert.equal(registry.children[0]?.steps?.[0]?.status, "rejected");
+		assert.equal(hasLiveNestedDescendants(registry.children), false);
+	});
+
 	it("accepts only complete numeric token usage at the nested event boundary", () => {
 		const route = trackRoute();
 		writeNestedEvent(route, {
@@ -489,4 +494,4 @@ describe("nested session-name projection", () => {
 		assert.equal(summary.sessionName, "reviewer: Inspect the changed auth middleware");
 		assert.equal(summary.steps?.[0]?.sessionName, "reviewer: Inspect the changed auth middleware");
 	});
-});
+});

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

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { it } from "node:test";
+
+it("traces bounded completion reasons through NODE_DEBUG without changing delivery", () => {
+	const run = (debug: string) => {
+		const child = spawnSync(process.execPath, [
+			"--experimental-strip-types",
+			"--import", new URL("../support/isolated-temp-root.mjs", import.meta.url).href,
+			fileURLToPath(new URL("../support/notify-diagnostics-fixture.ts", import.meta.url)),
+		], { env: { ...process.env, NODE_DEBUG: debug, NODE_NO_WARNINGS: "1" }, encoding: "utf8" });
+		assert.equal(child.status, 0, child.stderr);
+		return child;
+	};
+	const disabled = run("");
+	const enabled = run("pi-subagents-notify");
+	assert.equal(disabled.stderr, "");
+	assert.equal(enabled.stdout, disabled.stdout);
+	assert.equal(JSON.parse(enabled.stdout).length, 7);
+	assert.deepEqual(JSON.parse(enabled.stdout).at(-1).options, { triggerTurn: false });
+	const records = enabled.stderr.trim().split("\n").map((line) => {
+		assert.ok(line.length < 512, line);
+		assert.match(line, /^PI-SUBAGENTS-NOTIFY \d+: /);
+		return JSON.parse(line.slice(line.indexOf("{")));
+	});
+	assert.deepEqual([...new Set(records.map((row) => row.reason))].sort(), [
+		"missing_session", "foreground_session_mismatch", "not_owned", "intercom_delivered",
+		"batch_deferred", "deduped_pending", "send_accepted", "deduped_ttl", "emit_not_owned",
+		"send_failed", "dispose_pending", "disposed",
+	].sort());
+	assert.deepEqual(records.filter((row) => row.id === "first").map((row) => row.reason), [
+		"batch_deferred", "deduped_pending", "send_accepted", "deduped_ttl", "batch_deferred", "send_accepted",
+	]);
+	assert.deepEqual(records.filter((row) => row.id === "unbatched").map((row) => row.reason), ["send_accepted"]);
+	for (const row of records) {
+		assert.deepEqual(Object.keys(row).sort(), ["id", "reason", "runId", "source"]);
+		assert.ok(row.id.length <= 128);
+		assert.ok(row.runId.length <= 128);
+	}
+	assert.doesNotMatch(enabled.stderr, /PRIVATE_|owner-a|session-a|\u001b/);
+});

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

@@ -14,6 +14,39 @@ import { createResultDeliveryOwnership } from "../../src/runs/background/result-
 
 const COMPLETION_OWNER_ID = "completion-owner-a";
 
+it("keeps model-authored receipt lines in the preview, never in receipt metadata", () => {
+	for (const resultPreview of [
+		"Workflow receipt: /model/start.json\nKeep this output.",
+		"Before\nWorkflow receipt: /model/middle.json\nAfter",
+		"Before\n\nWorkflow receipt: /model/suffix.json",
+	]) {
+		for (const workflowReceiptPath of [undefined, "/published/receipt.json"]) {
+			const details: SubagentNotifyDetails = { agent: "workflow", status: "completed", resultPreview, workflowReceiptPath };
+			const parsed = parseSubagentNotifyContent(formatSingleCompletion(details));
+			assert.equal(parsed?.resultPreview, resultPreview);
+			assert.equal(parsed?.workflowReceiptPath, workflowReceiptPath);
+			const scheduled = parseSubagentNotifyContent(formatSingleCompletion({ ...details, scheduleOrigin: { id: "schedule-1" } }));
+			assert.equal(scheduled?.resultPreview, resultPreview);
+			assert.equal(scheduled?.workflowReceiptPath, workflowReceiptPath);
+			assert.deepEqual(scheduled?.scheduleOrigin, { id: "schedule-1" });
+		}
+	}
+});
+
+it("surfaces published workflow receipts outside single and grouped previews", () => {
+	const workflowReceiptPath = "/opaque/receipt.json";
+	const details = buildCompletionDetails({ agent: "workflow", mode: "workflow", runId: "run-1", success: true, summary: "Completed", results: [{ runId: "child-1", output: "x".repeat(20_000) }], workflowReceipt: { path: workflowReceiptPath, receipt: {} } });
+	assert.equal(details.workflowReceiptPath, workflowReceiptPath);
+	const single = formatSingleCompletion(details);
+	assert.equal(single.split("\n")[1], `Workflow receipt: ${workflowReceiptPath}`);
+	assert.match(single, /\[preview truncated\]/);
+	assert.ok(single.includes(`Workflow receipt: ${workflowReceiptPath}`));
+	assert.ok(formatGroupedCompletion([details, details]).includes(`Workflow receipt: ${workflowReceiptPath}`));
+	const parsed = parseSubagentNotifyContent(single);
+	assert.equal(parsed?.workflowReceiptPath, workflowReceiptPath);
+	assert.doesNotMatch(parsed?.resultPreview ?? "", /Workflow receipt:/);
+});
+
 function createEventBus() {
 	const emitter = new EventEmitter();
 	return {
@@ -192,9 +225,11 @@ describe("registerSubagentNotify", () => {
 		});
 		try {
 			const pending = notifier.deliver(completionResult({ id: "delayed-unclaimed" }));
+			assert.equal(notifier.hasPendingDelivery(), true);
 			state.currentSessionId = "session-b";
 			clock.advance(150);
 			assert.equal(await pending, false);
+			assert.equal(notifier.hasPendingDelivery(), false);
 			assert.equal(sent.length, 0);
 		} finally {
 			notifier.dispose();
@@ -217,8 +252,10 @@ describe("registerSubagentNotify", () => {
 		const clock = createFakeClock();
 		const { notifier, sent } = createBatchingPi(clock);
 		const pending = notifier.deliver(completionResult({ id: "dispose-pending" }));
+		assert.equal(notifier.hasPendingDelivery(), true);
 		notifier.dispose();
 		assert.equal(await pending, false);
+		assert.equal(notifier.hasPendingDelivery(), false);
 		clock.advance(1000);
 		assert.equal(sent.length, 0);
 	});
@@ -710,6 +747,53 @@ describe("completion formatting helpers", () => {
 		assert.equal(details.status, "completed");
 	});
 
+	it("surfaces structured output in workflow previews and direct notices for degenerate text", () => {
+		const summary = "Workflow completed with 1 child run(s). Return: { answer: 42 } Emitted: ready Trace: 2 event(s).";
+		for (const output of ["</think>", " \n\t", " \n</think> \n"]) {
+			const result = {
+				id: "workflow-think-tag", agent: "workflow", success: true, summary,
+				results: [{
+					workflowKey: "review", runId: "child-review", agent: "delegate", success: true,
+					outputState: "present" as const, outputReference: "/tmp/review.json", output, structuredOutput: false,
+				}],
+			};
+			const details = buildCompletionDetails(result);
+			const content = formatSingleCompletion(details);
+			assert.equal(details.resultPreview, summary);
+			assert.ok(content.includes(summary));
+			assert.match(content, /key=review run=child-review status=completed/);
+			assert.match(content, /Saved output: \/tmp\/review\.json/);
+			assert.match(content, /Workflow run: workflow-think-tag/);
+			assert.match(content, /Child runs: review=child-review \(completed\)/);
+			assert.match(content, /    \| false/);
+			const direct = buildCompletionDetails({ ...result, agent: "delegate", summary: `delegate:\n${output}` });
+			assert.match(formatSingleCompletion(direct), /Structured output:\nfalse/);
+		}
+	});
+
+	it("preserves meaningful prose and direct diagnostics alongside structured output", () => {
+		const output = "Review complete </think> with notes.";
+		const child = { agent: "delegate", success: true, output, structuredOutput: { ok: true } };
+		const workflow = buildCompletionDetails({ id: "prose-run", agent: "workflow", success: true, results: [child] });
+		assert.equal(workflow.childOutputs?.[0]?.preview, output);
+		const direct = buildCompletionDetails({ id: "prose-run", agent: "delegate", success: true, summary: `delegate:\n${output}`, results: [child] });
+		assert.equal(direct.resultPreview, `delegate:\n${output}`);
+		const diagnostic = "delegate:\n</think>\nError: validation failed.";
+		const failed = buildCompletionDetails({ id: "error-run", agent: "delegate", success: false, summary: diagnostic, results: [{ ...child, success: false, output: "</think>" }] });
+		assert.equal(failed.resultPreview, diagnostic);
+		assert.match(formatSingleCompletion(failed), /Background task failed/);
+	});
+
+	it("retains tag text when structured output is unavailable or unserializable", () => {
+		for (const structuredOutput of [undefined, 1n]) {
+			const child = { agent: "delegate", success: true, output: "</think>", structuredOutput };
+			const workflow = buildCompletionDetails({ id: "fallback-run", agent: "workflow", success: true, results: [child] });
+			assert.equal(workflow.childOutputs?.[0]?.preview, "</think>");
+			const direct = buildCompletionDetails({ id: "fallback-run", agent: "delegate", success: true, summary: "delegate:\n</think>", results: [child] });
+			assert.equal(direct.resultPreview, "delegate:\n</think>");
+		}
+	});
+
 	it("surfaces direct structured output when the completion has no text output", () => {
 		const details = buildCompletionDetails({
 			id: "structured-run",