@selesai/code 0.5.27 → 0.5.29

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

@@ -42,12 +42,12 @@ function once(events: FakeEvents, event: string): Promise<unknown> {
 	});
 }
 
-function ctx() {
+function ctx(sessionId = "session-123", sessionFile = "/sessions/parent.jsonl") {
 	return {
 		cwd: "/repo",
 		sessionManager: {
-			getSessionId: () => "session-123",
-			getSessionFile: () => "/sessions/parent.jsonl",
+			getSessionId: () => sessionId,
+			getSessionFile: () => sessionFile,
 		},
 	} as any;
 }
@@ -91,6 +91,14 @@ describe("subagent extension RPC bridge", () => {
 			(reply as { data: { capabilities?: { nonRecoveringSteer?: boolean } } }).data.capabilities?.nonRecoveringSteer,
 			true,
 		);
+		assert.equal(
+			(reply as { data: { capabilities?: { resume?: boolean } } }).data.capabilities?.resume,
+			true,
+		);
+		assert.deepEqual(
+			(reply as { data: { capabilities?: { fleetStatus?: unknown } } }).data.capabilities?.fleetStatus,
+			{ version: 1 },
+		);
 
 		bridge.dispose();
 	});
@@ -137,7 +145,149 @@ describe("subagent extension RPC bridge", () => {
 		assert.equal(reply.success, true);
 		assert.deepEqual(executedParams, { action: "status", id: "abc123" });
 		assert.equal((reply as { data: { text?: string } }).data.text, "Run: abc123");
+		assert.deepEqual((reply as { data: { fleet?: unknown } }).data.fleet, {
+			version: 1, entries: [], totalActive: 0, omitted: 0,
+		});
+
+		bridge.dispose();
+	});
+
+	it("projects bounded display-safe active fleet records without internal ids", async () => {
+		const events = new FakeEvents();
+		const state = {
+			currentSessionId: "/sessions/parent.jsonl",
+			foregroundControls: new Map(),
+			asyncJobs: new Map([["async-private-id", {
+				asyncId: "async-private-id", sessionId: "/sessions/parent.jsonl", status: "running", mode: "single",
+				description: ["Review", "\u001b]8;;hostile\u0007", "the diff"].join("\n"),
+				startedAt: 100, steps: [{ agent: "reviewer", label: "opaque label", status: "running", startedAt: 120, model: "anthropic/claude-opus-4-8:high", thinking: "high", tokens: { input: 12, output: 34, total: 46 } }],
+			}]]),
+		} as any;
+		const bridge = registerSubagentRpcBridge({
+			events, getContext: () => ctx("runtime-session-id", "/sessions/parent.jsonl"), state,
+			execute: async () => ({ content: [{ type: "text", text: "Active async runs: 1" }], details: { mode: "management", results: [] } } as any),
+		});
+		const reply = await request(events, "fleet-status", "status");
+		const fleet = (reply as { data: { fleet: { entries: Array<Record<string, unknown>> } } }).data.fleet;
+		assert.equal(fleet.entries.length, 1);
+		assert.equal((fleet as { totalActive?: number }).totalActive, 1);
+		assert.equal((fleet as { omitted?: number }).omitted, 0);
+		assert.deepEqual(fleet.entries[0], {
+			key: "fleet-1", agent: "reviewer", role: "opaque label", model: "anthropic/claude-opus-4-8:high", effort: "high",
+			startedAt: 120, tokens: { input: 12, output: 34, total: 46 }, goal: "Review the diff",
+		});
+		assert.equal(JSON.stringify(fleet).includes("async-private-id"), false);
+		bridge.dispose();
+	});
+
+	it("projects resolved foreground model, effort, split usage, and goal", async () => {
+		const events = new FakeEvents();
+		const state = {
+			currentSessionId: "session-123",
+			foregroundControls: new Map([["private-run", {
+				runId: "private-run",
+				sessionId: "session-123",
+				mode: "single",
+				startedAt: 90,
+				activeChildren: new Map([[0, {
+					index: 0,
+					agent: "worker",
+					description: "Implement the fix",
+					startedAt: 100,
+					updatedAt: 110,
+					model: "openai/gpt-5.6-terra:high",
+					thinking: "high",
+					inputTokens: 321,
+					outputTokens: 45,
+					tokens: 366,
+				}]]),
+			}]]),
+			asyncJobs: new Map(),
+		} as any;
+		state.foregroundControls.set("private-old", {
+			runId: "private-old",
+			sessionId: "old-session",
+			mode: "single",
+			startedAt: 50,
+			currentAgent: "reviewer",
+			description: "Old work",
+		});
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx("session-123", "session-123"),
+			state,
+			execute: async () => ({ content: [], details: { mode: "management", results: [] } } as any),
+		});
+		const reply = await request(events, "foreground-fleet", "status");
+		assert.deepEqual((reply as any).data.fleet, {
+			version: 1,
+			totalActive: 1,
+			omitted: 0,
+			entries: [{
+				key: "fleet-1",
+				agent: "worker",
+				model: "openai/gpt-5.6-terra:high",
+				effort: "high",
+				startedAt: 100,
+				tokens: { input: 321, output: 45, total: 366 },
+				goal: "Implement the fix",
+			}],
+		});
+		assert.equal(JSON.stringify((reply as any).data.fleet).includes("private-run"), false);
+		bridge.dispose();
+	});
+
+	it("uses monotonic opaque keys across removal/insertion and resets them per session", async () => {
+		const events = new FakeEvents();
+		const jobs = new Map<string, any>([
+			["private-a", { asyncId: "private-a", sessionId: "A", status: "running", mode: "single", startedAt: 1, agents: ["alpha"] }],
+			["private-b", { asyncId: "private-b", sessionId: "A", status: "running", mode: "single", startedAt: 2, agents: ["beta"] }],
+			["private-unattributed", { asyncId: "private-unattributed", status: "running", mode: "single", startedAt: 3, agents: ["unknown"] }],
+		]);
+		const state = { currentSessionId: "A", foregroundControls: new Map(), asyncJobs: jobs } as any;
+		let activeSession = "A";
+		const bridge = registerSubagentRpcBridge({ events, getContext: () => ctx(activeSession, activeSession), state, execute: async () => ({ content: [], details: { mode: "management", results: [] } } as any) });
+		const keys = async (id: string) => ((await request(events, id, "status")) as any).data.fleet.entries.map((entry: { key: string }) => entry.key);
+		assert.deepEqual(await keys("keys-a"), ["fleet-1", "fleet-2"]);
+		jobs.delete("private-b"); jobs.set("private-c", { asyncId: "private-c", sessionId: "A", status: "running", mode: "single", startedAt: 3, agents: ["gamma"] });
+		assert.deepEqual(await keys("keys-b"), ["fleet-1", "fleet-3"]);
+		state.currentSessionId = "B";
+		activeSession = "B";
+		assert.deepEqual(await keys("keys-c"), []);
+		jobs.set("private-d", { asyncId: "private-d", sessionId: "B", status: "running", mode: "single", startedAt: 4, agents: ["delta"] });
+		assert.deepEqual(await keys("keys-d"), ["fleet-1"]);
+		bridge.dispose();
+	});
 
+	it("reports bounded overflow and excludes unattributed or foreign-session jobs", async () => {
+		const events = new FakeEvents();
+		const jobs = new Map<string, any>();
+		for (let index = 0; index < 18; index += 1) {
+			jobs.set(`private-${index}`, {
+				asyncId: `private-${index}`,
+				sessionId: "session-123",
+				status: "running",
+				mode: "single",
+				startedAt: index + 1,
+				agents: [`worker-${index}`],
+			});
+		}
+		jobs.set("unattributed", { asyncId: "unattributed", status: "running", mode: "single", startedAt: 20, agents: ["hidden"] });
+		jobs.set("foreign", { asyncId: "foreign", sessionId: "other", status: "running", mode: "single", startedAt: 21, agents: ["hidden"] });
+		const state = { currentSessionId: "session-123", foregroundControls: new Map(), asyncJobs: jobs } as any;
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx("session-123", "session-123"),
+			state,
+			execute: async () => ({ content: [], details: { mode: "management", results: [] } } as any),
+		});
+		const reply = await request(events, "fleet-overflow", "status");
+		const fleet = (reply as any).data.fleet;
+		assert.equal(fleet.entries.length, 16);
+		assert.equal(fleet.totalActive, 18);
+		assert.equal(fleet.omitted, 2);
+		assert.equal(JSON.stringify(fleet).includes("unattributed"), false);
+		assert.equal(JSON.stringify(fleet).includes("foreign"), false);
 		bridge.dispose();
 	});
 
@@ -298,6 +448,75 @@ describe("subagent extension RPC bridge", () => {
 		bridge.dispose();
 	});
 
+	it("delegates resume through the existing package-owned revival action", async () => {
+		const events = new FakeEvents();
+		let executedParams: unknown;
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx(),
+			execute: async (_id, params) => {
+				executedParams = params;
+				return {
+					content: [{ type: "text", text: "Revived async subagent from run-1." }],
+					details: { mode: "single", results: [], asyncId: "run-2", asyncDir: "/tmp/run-2" },
+				} as any;
+			},
+		});
+
+		const reply = await request(events, "resume-1", "resume", {
+			id: "run-1",
+			index: 0,
+			message: " Continue with the focused review. ",
+			output: " /tmp/revived-output.md ",
+			outputMode: "file-only",
+		});
+
+		assert.equal(reply.success, true);
+		assert.deepEqual(executedParams, {
+			action: "resume",
+			id: "run-1",
+			index: 0,
+			message: "Continue with the focused review.",
+			output: "/tmp/revived-output.md",
+			outputMode: "file-only",
+		});
+		assert.equal((reply as { data: { details?: { asyncId?: string } } }).data.details?.asyncId, "run-2");
+
+		bridge.dispose();
+	});
+
+	it("rejects targetless or empty RPC resume before executor dispatch", async () => {
+		const events = new FakeEvents();
+		let executeCalls = 0;
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx(),
+			execute: async () => {
+				executeCalls++;
+				return { content: [], details: { mode: "management", results: [] } } as any;
+			},
+		});
+
+		const targetless = await request(events, "resume-no-target", "resume", { message: "continue" });
+		const empty = await request(events, "resume-empty", "resume", { id: "run-1", message: "   " });
+		const inlineOutput = await request(events, "resume-inline", "resume", {
+			id: "run-1",
+			message: "continue",
+			output: "/tmp/output.md",
+			outputMode: "inline",
+		});
+
+		assert.equal(targetless.success, false);
+		assert.equal((targetless as { error: { code: string } }).error.code, "invalid_params");
+		assert.match((targetless as { error: { message: string } }).error.message, /requires id, runId, or dir/);
+		assert.equal(empty.success, false);
+		assert.equal((empty as { error: { code: string } }).error.code, "invalid_params");
+		assert.equal(inlineOutput.success, false);
+		assert.match((inlineOutput as { error: { message: string } }).error.message, /file-only/);
+		assert.equal(executeCalls, 0);
+		bridge.dispose();
+	});
+
 	it("delegates interrupt through the existing executor action", async () => {
 		const events = new FakeEvents();
 		let executedParams: unknown;
@@ -328,7 +547,7 @@ describe("subagent extension RPC bridge", () => {
 			fs.mkdirSync(asyncDir, { recursive: true });
 			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
 				runId: "run-stop",
-				sessionId: "session-123",
+				sessionId: "/sessions/parent.jsonl",
 				mode: "single",
 				state: "running",
 				pid: 4242,

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

@@ -994,6 +994,36 @@ describe("async run status inspection", () => {
 		}
 	});
 
+	it("shows signal-terminated result-only runs as stopped", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-signal-result-"));
+		try {
+			const asyncRoot = path.join(root, "runs");
+			const resultsDir = path.join(root, "results");
+			fs.mkdirSync(path.join(asyncRoot, "run-signal-result"), { recursive: true });
+			fs.mkdirSync(resultsDir, { recursive: true });
+			fs.writeFileSync(path.join(resultsDir, "run-signal-result.json"), JSON.stringify({
+				id: "run-signal-result",
+				agent: "worker",
+				success: false,
+				state: "failed",
+				summary: "Subagent process terminated by signal SIGTERM.",
+				results: [{ agent: "worker", success: false, exitCode: 1, processSignal: "SIGTERM" }],
+			}, null, 2), "utf-8");
+
+			const result = inspectSubagentStatus({ id: "run-signal-result" }, {
+				asyncDirRoot: asyncRoot,
+				resultsDir,
+			});
+
+			const text = textContent(result);
+			assert.equal(result.isError, undefined);
+			assert.match(text, /State: stopped/);
+			assert.match(text, /Resume: unavailable; stopped runs are not resumable/);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
 	it("falls back to an existing result when async dir has no status file", () => {
 		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-run-status-result-fallback-"));
 		try {

package/dist/extensions/pi-subagents/test/unit/runtime-acknowledged-extensions.test.ts

@@ -0,0 +1,52 @@
+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 { MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES, isRuntimeAcknowledgedExtensionId, projectRuntimeAcknowledgedExtensions, readRuntimeAcknowledgedExtensions, sanitizeRuntimeAcknowledgedExtensions } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
+
+describe("runtime acknowledged extension projection", () => {
+	it("validates opaque ids without path-like content", () => {
+		assert.equal(isRuntimeAcknowledgedExtensionId("com.example-extension:v1"), true);
+		assert.equal(isRuntimeAcknowledgedExtensionId(""), false);
+		assert.equal(isRuntimeAcknowledgedExtensionId("has space"), false);
+		assert.equal(isRuntimeAcknowledgedExtensionId("../secret"), false);
+		assert.equal(isRuntimeAcknowledgedExtensionId("path/to/ext"), false);
+		assert.equal(isRuntimeAcknowledgedExtensionId("path\\to\\ext"), false);
+		assert.equal(isRuntimeAcknowledgedExtensionId("x".repeat(129)), false);
+	});
+
+	it("deduplicates, caps ids, and counts omitted valid ids", () => {
+		const ids = ["dup", "dup", ...Array.from({ length: 35 }, (_, index) => `ext-${index}`), "bad id"];
+		const projected = projectRuntimeAcknowledgedExtensions(ids);
+
+		assert.equal(projected?.source, "child-runtime");
+		assert.equal(projected?.ids.length, 32);
+		assert.equal(projected?.ids[0], "dup");
+		assert.equal(projected?.omitted, 4);
+		assert.equal(projected?.ids.includes("bad id"), false);
+	});
+
+	it("sanitizes persisted projections and rejects invalid shapes", () => {
+		assert.deepEqual(sanitizeRuntimeAcknowledgedExtensions({ version: 1, source: "child-runtime", ids: ["ok", "ok", "bad/path"], omitted: 2 }), {
+			version: 1,
+			source: "child-runtime",
+			ids: ["ok"],
+			omitted: 2,
+		});
+		assert.equal(sanitizeRuntimeAcknowledgedExtensions({ version: 1, source: "launch-resolved", ids: ["ok"] }), undefined);
+		assert.equal(sanitizeRuntimeAcknowledgedExtensions({ version: 1, source: "child-runtime", ids: ["bad/path"] }), undefined);
+	});
+
+	it("rejects oversized capture files without reading them", (t) => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "runtime-ack-"));
+		t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
+		const filePath = path.join(dir, "ack.json");
+
+		fs.writeFileSync(filePath, "x".repeat(MAX_RUNTIME_ACKNOWLEDGED_EXTENSION_FILE_BYTES + 1));
+		assert.equal(readRuntimeAcknowledgedExtensions(filePath), undefined);
+
+		fs.writeFileSync(filePath, JSON.stringify({ version: 1, source: "child-runtime", ids: ["ok"], omitted: 0 }));
+		assert.deepEqual(readRuntimeAcknowledgedExtensions(filePath), { version: 1, source: "child-runtime", ids: ["ok"], omitted: 0 });
+	});
+});

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

@@ -38,6 +38,13 @@ interface SubagentParamsSchema {
 				graceTurns?: { minimum?: number };
 			};
 		};
+		usageBudget?: {
+			properties?: {
+				tokens?: { properties?: { soft?: { exclusiveMinimum?: number }; hard?: { exclusiveMinimum?: number } } };
+				costUsd?: { properties?: { soft?: { exclusiveMinimum?: number }; hard?: { exclusiveMinimum?: number } } };
+			};
+			description?: string;
+		};
 		id?: {
 			type?: string;
 			description?: string;
@@ -206,6 +213,19 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.equal(toolBudgetSchema?.properties?.hard?.minimum, 1);
 	});
 
+	it("includes root-only reported usage budget", () => {
+		const usageBudgetSchema = SubagentParams?.properties?.usageBudget;
+		assert.ok(usageBudgetSchema, "usageBudget schema should exist");
+		assert.equal(usageBudgetSchema.properties?.tokens?.properties?.soft?.exclusiveMinimum, 0);
+		assert.equal(usageBudgetSchema.properties?.tokens?.properties?.hard?.exclusiveMinimum, 0);
+		assert.equal(usageBudgetSchema.properties?.costUsd?.properties?.soft?.exclusiveMinimum, 0);
+		assert.equal(usageBudgetSchema.properties?.costUsd?.properties?.hard?.exclusiveMinimum, 0);
+		assert.match(String(usageBudgetSchema.description ?? ""), /root-only/);
+		assert.match(String(usageBudgetSchema.description ?? ""), /running children are not stopped/i);
+		assert.equal(getPropertySchema(SubagentParams?.properties?.tasks?.items as JsonSchemaNode | undefined, ["usageBudget"]), undefined);
+		assert.equal(getPropertySchema(SubagentParams?.properties?.chain?.items as JsonSchemaNode | undefined, ["usageBudget"]), undefined);
+	});
+
 	it("includes subagent control fields", () => {
 		const idSchema = SubagentParams?.properties?.id;
 		assert.ok(idSchema, "id schema should exist");
@@ -214,6 +234,12 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.match(String(idSchema.description ?? ""), /interrupt/i);
 		assert.match(String(idSchema.description ?? ""), /steer/i);
 		assert.match(String(idSchema.description ?? ""), /append-step/i);
+		assert.match(String(idSchema.description ?? ""), /approve-checkpoint/i);
+		assert.match(String(idSchema.description ?? ""), /reject-checkpoint/i);
+
+		const chainItemSchema = SubagentParams?.properties?.chain?.items;
+		assert.equal(chainItemSchema?.properties?.checkpoint?.type, "string");
+		assert.equal(chainItemSchema?.properties?.message?.type, "string");
 
 		const runIdSchema = SubagentParams?.properties?.runId;
 		assert.ok(runIdSchema, "runId schema should exist");
@@ -318,12 +344,18 @@ describe("SubagentParams schema", { skip: !schemasAvailable ? "typebox not avail
 		assert.ok(SubagentParams, "SubagentParams schema should exist");
 		const schema = SubagentParams as unknown as JsonSchemaNode;
 		const serialized = JSON.stringify(schema);
-		assert.ok(serialized.length < 15_000, `expected compact schema under 15k chars, got ${serialized.length}`);
+		assert.ok(serialized.length < 16_000, `expected compact schema under 16k chars, got ${serialized.length}`);
 		assert.equal(serialized.includes('"$ref"'), false);
 		assert.equal(serialized.includes('"$defs"'), false);
 		assert.equal(serialized.split("Optional acceptance policy.").length - 1, 1);
 		assert.match(String((schema.properties as Record<string, JsonSchemaNode> | undefined)?.agent?.description ?? ""), /SINGLE mode/);
-		assert.match(String((schema.properties as Record<string, JsonSchemaNode> | undefined)?.acceptance?.description ?? ""), /acceptance policy/);
+		const acceptanceDescription = String((schema.properties as Record<string, JsonSchemaNode> | undefined)?.acceptance?.description ?? "");
+		assert.match(acceptanceDescription, /acceptance policy/);
+		assert.match(acceptanceDescription, /Supported evidence kinds:/);
+		assert.match(acceptanceDescription, /commands-run/);
+		assert.match(acceptanceDescription, /changed-files/);
+		assert.match(acceptanceDescription, /manual-notes/);
+		assert.match(acceptanceDescription, /\{ level: "checked", evidence: \["commands-run", "changed-files"\] \}/);
 
 		const nestedDescriptionPaths: string[] = [];
 		const stack: Array<{ path: string; value: unknown }> = [{ path: "SubagentParams", value: schema }];

package/dist/extensions/pi-subagents/test/unit/skills-fallback.test.ts

@@ -340,7 +340,7 @@ describe("skills filesystem fallback", () => {
 		`;
 		execFileSync(
 			process.execPath,
-			["--experimental-transform-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
+			["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script],
 			{
 				cwd: projectRoot,
 				env: {

package/dist/extensions/pi-subagents/test/unit/steering-action.test.ts

@@ -60,7 +60,7 @@ function projectRequest(status: AsyncStatus, request: SteerRequest, states: Stee
 	}
 }
 
-async function waitUntil<T>(read: () => T | undefined, timeoutMs = 1_000): Promise<T> {
+async function waitUntil<T>(read: () => T | undefined, timeoutMs = 30_000): Promise<T> {
 	const deadline = Date.now() + timeoutMs;
 	while (true) {
 		const value = read();

package/dist/extensions/pi-subagents/test/unit/streamed-progress-bounds.test.ts

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import { Buffer } from "node:buffer";
+import { describe, it } from "node:test";
+import {
+	boundStreamedRecentOutput,
+	boundStreamedRecentTools,
+	boundStreamedToolCalls,
+	MAX_STREAMED_OUTPUT_LINE_CHARS,
+	MAX_STREAMED_RECENT_TOOLS,
+	MAX_STREAMED_TOOL_CALLS,
+} from "../../src/shared/utils.ts";
+
+describe("streamed progress snapshot bounds", () => {
+	it("keeps only the most recent tool-history entries and clones them", () => {
+		const recentTools = Array.from({ length: MAX_STREAMED_RECENT_TOOLS + 40 }, (_, i) => ({
+			tool: "read",
+			args: `file-${i}.ts`,
+			endMs: i,
+		}));
+		const bounded = boundStreamedRecentTools(recentTools);
+		assert.equal(bounded.length, MAX_STREAMED_RECENT_TOOLS);
+		// most-recent retained (chronological)
+		assert.equal(bounded.at(-1)?.endMs, recentTools.at(-1)?.endMs);
+		assert.equal(bounded[0]?.endMs, recentTools.at(-MAX_STREAMED_RECENT_TOOLS)?.endMs);
+		// cloned, not aliased
+		bounded[0]!.args = "mutated";
+		assert.notEqual(recentTools.at(-MAX_STREAMED_RECENT_TOOLS)?.args, "mutated");
+	});
+
+	it("truncates long recent-output lines but leaves short lines intact", () => {
+		const shortLine = "ok";
+		const longLine = "x".repeat(MAX_STREAMED_OUTPUT_LINE_CHARS + 5000);
+		const bounded = boundStreamedRecentOutput([shortLine, longLine]);
+		assert.equal(bounded[0], shortLine);
+		assert.ok(bounded[1]!.length < longLine.length);
+		assert.ok(bounded[1]!.startsWith("x".repeat(MAX_STREAMED_OUTPUT_LINE_CHARS)));
+		assert.match(bounded[1]!, /\[truncated\]$/);
+	});
+
+	it("prefers an existing toolCalls summary and caps it", () => {
+		const toolCalls = Array.from({ length: MAX_STREAMED_TOOL_CALLS + 20 }, (_, i) => ({
+			text: `read(${i})`,
+			expandedText: `read(file-${i}.ts)`,
+		}));
+		const bounded = boundStreamedToolCalls({ toolCalls, messages: undefined });
+		assert.equal(bounded?.length, MAX_STREAMED_TOOL_CALLS);
+		assert.equal(bounded?.at(-1)?.text, toolCalls.at(-1)?.text);
+	});
+
+	it("derives tool-call summaries from messages when none are present", () => {
+		const messages = [
+			{ role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "a.ts" } }] },
+			{ role: "assistant", content: [{ type: "toolCall", name: "grep", arguments: { pattern: "foo" } }] },
+			{ role: "user", content: [{ type: "text", text: "ignored" }] },
+		] as never;
+		const bounded = boundStreamedToolCalls({ toolCalls: undefined, messages });
+		assert.equal(bounded?.length, 2);
+		assert.match(bounded![0]!.text, /read/);
+		assert.match(bounded![1]!.text, /grep/);
+	});
+
+	it("returns undefined when there are no tool calls", () => {
+		assert.equal(boundStreamedToolCalls({ toolCalls: [], messages: [] as never }), undefined);
+		assert.equal(boundStreamedToolCalls({ toolCalls: undefined, messages: undefined }), undefined);
+	});
+
+	it("bounds a pathological running snapshot well under the child-stdout protocol cap", () => {
+		// Simulates a long, deep nested fan-out: many tool calls + long output lines.
+		const recentTools = Array.from({ length: 5000 }, (_, i) => ({ tool: "read", args: `services/pkg/file-${i}.ts`, endMs: i }));
+		const recentOutput = Array.from({ length: 50 }, () => "y".repeat(60_000));
+		const snapshot = {
+			recentTools: boundStreamedRecentTools(recentTools),
+			recentOutput: boundStreamedRecentOutput(recentOutput),
+		};
+		const bytes = Buffer.byteLength(JSON.stringify(snapshot), "utf8");
+		assert.ok(bytes < 256 * 1024, `bounded snapshot should be small, was ${bytes} bytes`);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/subagent-prompt-runtime.test.ts

@@ -16,6 +16,7 @@ import {
 	SUBAGENT_STEER_INBOX_ENV,
 	SUBAGENT_SUPERVISOR_CHANNEL_DIR_ENV,
 } from "../../src/runs/shared/pi-args.ts";
+import { RUNTIME_EXTENSION_ACK_EVENT, RUNTIME_EXTENSION_ACK_PATH_ENV } from "../../src/runs/shared/runtime-acknowledged-extensions.ts";
 import { STRUCTURED_OUTPUT_CAPTURE_ENV, STRUCTURED_OUTPUT_SCHEMA_ENV } from "../../src/runs/shared/structured-output.ts";
 import { TOOL_BUDGET_ENV } from "../../src/runs/shared/tool-budget.ts";
 import { CHILD_TOOL_DIAGNOSTIC_PATH_ENV, formatChildToolDiagnostic, MCP_DIRECT_CHILD_TOOLS_ENV, readChildToolDiagnostic, REQUIRED_CHILD_TOOLS_ENV } from "../../src/runs/shared/tool-availability.ts";
@@ -128,6 +129,42 @@ function setSupervisorEnv(): void {
 }
 
 describe("subagent prompt runtime", () => {
+	it("collects runtime extension acknowledgements until terminal serialization", () => {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagent-runtime-ack-"));
+		try {
+			const outputPath = path.join(dir, "acks.json");
+			process.env[RUNTIME_EXTENSION_ACK_PATH_ENV] = outputPath;
+			const runtimeHandlers = new Map<string, Array<(payload?: unknown) => unknown>>();
+			const extensionHandlers = new Map<string, Array<(payload?: unknown) => unknown>>();
+			const pushHandler = (target: Map<string, Array<(payload?: unknown) => unknown>>, event: string, handler: (payload?: unknown) => unknown): void => {
+				target.set(event, [...(target.get(event) ?? []), handler]);
+			};
+			const emitAll = (target: Map<string, Array<(payload?: unknown) => unknown>>, event: string, payload?: unknown): void => {
+				for (const handler of target.get(event) ?? []) handler(payload);
+			};
+
+			registerSubagentPromptRuntime({
+				events: { on(event: string, handler: (payload?: unknown) => unknown) { pushHandler(extensionHandlers, event, handler); } },
+				on(event: string, handler: (payload?: unknown) => unknown) { pushHandler(runtimeHandlers, event, handler); },
+			} as never);
+
+			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "ext.one" });
+			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "ext.one" });
+			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "bad/path" });
+			runtimeHandlers.get("agent_end")?.[0]?.({});
+			emitAll(extensionHandlers, RUNTIME_EXTENSION_ACK_EVENT, { id: "late" });
+
+			assert.deepEqual(JSON.parse(fs.readFileSync(outputPath, "utf-8")), {
+				version: 1,
+				source: "child-runtime",
+				ids: ["ext.one"],
+				omitted: 0,
+			});
+		} finally {
+			fs.rmSync(dir, { recursive: true, force: true });
+		}
+	});
+
 	it("nudges after the tool budget soft limit and blocks configured tools after hard", () => {
 		const handlers = new Map<string, (payload: { toolName?: string }) => unknown>();
 		const sent: string[] = [];
@@ -299,6 +336,10 @@ describe("subagent prompt runtime", () => {
 	});
 
 	it("registers child watchdog lifecycle handlers only when enabled by env", () => {
+		delete process.env[CHILD_WATCHDOG_CONFIG_ENV];
+		// Clear the ack capture env explicitly: when this test suite itself runs inside a
+		// pi-subagents child, the runner sets it and an extra agent_end handler registers.
+		delete process.env[RUNTIME_EXTENSION_ACK_PATH_ENV];
 		const handlersWithout = new Map<string, unknown[]>();
 		registerSubagentPromptRuntime({
 			on(event: string, handler: unknown) {

package/dist/extensions/pi-subagents/test/unit/subagent-startup-retry.test.ts

@@ -0,0 +1,77 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { Usage } from "../../src/shared/types.ts";
+import {
+	MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS,
+	SUBAGENT_STARTUP_RETRY_DELAYS_MS,
+	formatSubagentStartupRetryExhaustedError,
+	formatSubagentStartupRetryNote,
+	isRetryableSubagentStartupFailure,
+	waitForSubagentStartupRetry,
+	type SubagentStartupFailureEvidence,
+} from "../../src/runs/shared/subagent-startup-retry.ts";
+
+function emptyUsage(): Usage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+
+function startupFailure(overrides: Partial<SubagentStartupFailureEvidence> = {}): SubagentStartupFailureEvidence {
+	return {
+		exitCode: 1,
+		messageCount: 0,
+		toolCount: 0,
+		usage: emptyUsage(),
+		durationMs: 20,
+		...overrides,
+	};
+}
+
+describe("subagent startup retry", () => {
+	it("uses a bounded retry schedule", () => {
+		assert.deepEqual(SUBAGENT_STARTUP_RETRY_DELAYS_MS, [250, 750, 1500]);
+	});
+
+	it("classifies a short non-zero exit with no child activity", () => {
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure()), true);
+	});
+
+	it("rejects successful, long-running, and diagnosed exits", () => {
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ exitCode: 0 })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ durationMs: MAX_SUBAGENT_STARTUP_FAILURE_DURATION_MS + 1 })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ error: "authentication failed" })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ finalOutput: "partial response" })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ protocolError: { code: "protocol_output_limit" } })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ processSignal: "SIGKILL" })), false);
+	});
+
+	it("rejects any model, tool, usage, mutation, or lifecycle activity", () => {
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ messageCount: 1 })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ toolCount: 1 })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ usage: { ...emptyUsage(), input: 1 } })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ usage: { ...emptyUsage(), turns: 1 } })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ observedMutationAttempt: true })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ detached: true })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ interrupted: true })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ timedOut: true })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ stopped: true })), false);
+		assert.equal(isRetryableSubagentStartupFailure(startupFailure({ turnBudgetExceeded: true })), false);
+	});
+
+	it("formats retry and exhaustion diagnostics without task content", () => {
+		assert.equal(
+			formatSubagentStartupRetryNote({ model: "openai/test", attempt: 1, maxAttempts: 4, delayMs: 250 }),
+			"[startup-retry] openai/test exited before model or tool activity (attempt 1/4). Retrying the same model in 250ms.",
+		);
+		assert.match(
+			formatSubagentStartupRetryExhaustedError({ model: "openai/test", attempts: 4 }),
+			/failed to start after 4 attempts.*concurrent Pi startup race.*lower subagent concurrency/i,
+		);
+	});
+
+	it("cancels a pending retry delay", async () => {
+		const controller = new AbortController();
+		const wait = waitForSubagentStartupRetry(5000, [controller.signal]);
+		controller.abort();
+		assert.equal(await wait, false);
+	});
+});