@selesai/code 0.13.6 → 0.13.7

package/dist/extensions/pi-subagents/test/unit/orca-progress-tabs.test.ts

@@ -542,4 +542,4 @@ test("mirror output truncates at a finite byte bound", { skip: process.platform
 	const text = fs.readFileSync(log, "utf-8");
 	assert.match(text, /progress mirror truncated at 1048576 bytes/);
 	assert.doesNotMatch(text, /must be dropped/);
-});
+});

package/dist/extensions/pi-subagents/test/unit/owned-process-tree.test.ts

@@ -66,4 +66,4 @@ test("owned process tree kills descendants and verifies a TERM-resistant POSIX g
 		delete process.env.PI_TEST_REAL_PS;
 		fs.rmSync(fixtureDir, { recursive: true, force: true });
 	}
-});
+});

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

@@ -238,4 +238,4 @@ test("Pi package resolution stays export-map safe", () => {
 		assert.equal(piPackageJsonSubpathPattern.test(source), false, `${file} should not resolve unexported package.json subpaths`);
 		assert.equal(cjsPiPackageResolutionPattern.test(source), false, `${file} should not use CommonJS resolution for ESM-only Pi packages`);
 	}
-});
+});

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

@@ -560,4 +560,4 @@ describe("parallel handoff", () => {
 			fs.rmSync(dir, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -266,4 +266,4 @@ describe("MAX_PARALLEL_CONCURRENCY", () => {
 	it("is 4", () => {
 		assert.equal(MAX_PARALLEL_CONCURRENCY, 4);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/path-handling.test.ts

@@ -106,4 +106,3 @@ describe("path.join vs template string concatenation", () => {
 		assert.equal(windowsJoin, path.join("parallel-0", "0-_code-reviewer", output));
 	});
 });
-

package/dist/extensions/pi-subagents/test/unit/path-resolution.test.ts

@@ -100,4 +100,4 @@ describe("Path resolution for .agents and ~/.agents", () => {
 		assert.ok(agent);
 		assert.strictEqual(agent?.filePath, path.join(userAgentsDir, "test-agent-2.md"));
 	});
-});
+});

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

@@ -43,4 +43,4 @@ describe("native child permissions", () => {
 		assert.doesNotMatch(multibytePreview, /�/);
 		assert.match(multibytePreview, /…$/);
 	});
-});
+});

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

@@ -434,4 +434,4 @@ describe("buildPiArgs <active_agent> tag injection", () => {
 			"prompt runtime extension should always be included",
 		);
 	});
-});
+});

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

@@ -366,7 +366,7 @@ describe("buildPiArgs session wiring", () => {
 		assert.equal(env[SUBAGENT_PARENT_SESSION_ENV], "direct-parent");
 	});
 
-	it("passes the child display session name through as PI_SUBAGENT_SESSION_NAME", () => {
+	it("passes the child display session name through as SELESAI_SUBAGENT_SESSION_NAME", () => {
 		const { env } = buildPiArgs({
 			baseArgs: ["-p"],
 			task: "hello",
@@ -376,10 +376,10 @@ describe("buildPiArgs session wiring", () => {
 			sessionName: "worker: Fix the flaky test",
 		});
 
-		assert.equal(env.PI_SUBAGENT_SESSION_NAME, "worker: Fix the flaky test");
+		assert.equal(env.SELESAI_SUBAGENT_SESSION_NAME, "worker: Fix the flaky test");
 	});
 
-	it("omits PI_SUBAGENT_SESSION_NAME when no session name is provided", () => {
+	it("omits SELESAI_SUBAGENT_SESSION_NAME when no session name is provided", () => {
 		const { env } = buildPiArgs({
 			baseArgs: ["-p"],
 			task: "hello",
@@ -388,7 +388,7 @@ describe("buildPiArgs session wiring", () => {
 			inheritSkills: false,
 		});
 
-		assert.equal(env.PI_SUBAGENT_SESSION_NAME, undefined);
+		assert.equal(env.SELESAI_SUBAGENT_SESSION_NAME, undefined);
 	});
 
 	it("falls back to inherited parent session env for permission forwarding", () => {
@@ -2238,4 +2238,4 @@ describe("buildPiArgs system prompt mode wiring", () => {
 
 		assert.ok(args.includes("--system-prompt"));
 	});
-});
+});

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

@@ -158,7 +158,7 @@ Inspect env.
 		assert.equal(fs.existsSync(path.join(agentDir, "agents", `${createdName}.md`)), true);
 	});
 
-	it("ignores nested .pi and sync-backups agent definitions", () => {
+	it("ignores nested .selesai and sync-backups agent definitions", () => {
 		const userAgentsDir = path.join(agentDir, "agents");
 		const rootAgentPath = path.join(userAgentsDir, "root-agent.md");
 		writeFile(rootAgentPath, `---
@@ -458,4 +458,4 @@ Package skill content.
 		assert.equal(bridge.extensionDir, "native:pi-subagents-supervisor-channel");
 		assert.match(bridge.instruction, /Native bridge for main/);
 	});
-});
+});

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

@@ -372,4 +372,4 @@ describe("resolvePiCliScript", () => {
 		});
 		assert.equal(resolvePiCliScript(deps), cliPath);
 	});
-});
+});

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

@@ -7,6 +7,7 @@ import { registerSubagentCapabilityCeiling, resolveSubagentCapabilityCeiling } f
 import { resolveSubagentLaunchContract, SUBAGENT_LAUNCH_CONTRACT_VERSION } from "../../src/api/preflight.ts";
 import { clearSkillCache } from "../../src/agents/skills.ts";
 import { computeMcpServerHash } from "../../src/runs/shared/mcp-direct-tool-allowlist.ts";
+import { clearExclusions, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
 import { TEMP_ARTIFACTS_DIR } from "../../src/shared/types.ts";
 
 let tempDir = "";
@@ -59,10 +60,12 @@ describe("public launch contract preflight", () => {
 		process.env.USERPROFILE = home;
 		process.env.SELESAI_CODING_AGENT_DIR = path.join(home, ".selesai", "agent");
 		clearSkillCache();
+		clearExclusions();
 	});
 
 	afterEach(() => {
 		clearSkillCache();
+		clearExclusions();
 		if (previousHome === undefined) delete process.env.HOME;
 		else process.env.HOME = previousHome;
 		if (previousUserProfile === undefined) delete process.env.USERPROFILE;
@@ -299,6 +302,108 @@ Project prompt.
 		);
 	});
 
+	it("uses an available configured fallback when the agent primary is unavailable", async () => {
+		const cwd = path.join(tempDir, "repo-unavailable-primary");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
+name: scout
+description: Project scout
+model: test/missing-primary
+fallbackModels:
+  - test/fallback
+---
+Project prompt.
+`);
+
+		const result = await resolveSubagentLaunchContract({
+			agent: "scout",
+			cwd,
+			availableModels: [{ provider: "test", id: "fallback", fullId: "test/fallback" }],
+		});
+
+		assert.equal(result.ok, true);
+		assert.deepEqual(result.contract.modelCandidates, ["test/fallback"]);
+	});
+
+	it("rejects an explicit unknown per-call model even when a fallback is configured", async () => {
+		const cwd = path.join(tempDir, "repo-explicit-unknown-model");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
+name: scout
+description: Project scout
+model: test/missing-primary
+fallbackModels:
+  - test/fallback
+---
+Project prompt.
+`);
+
+		await assert.rejects(
+			resolveSubagentLaunchContract({
+				agent: "scout",
+				cwd,
+				model: "test/does-not-exist",
+				availableModels: [{ provider: "test", id: "fallback", fullId: "test/fallback" }],
+			}),
+			/Unknown subagent model 'test\/does-not-exist'/,
+		);
+	});
+
+	it("fails closed when every configured candidate is unavailable", async () => {
+		const cwd = path.join(tempDir, "repo-all-unavailable-models");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
+name: scout
+description: Project scout
+model: test/missing-primary
+fallbackModels:
+  - test/missing-fallback
+---
+Project prompt.
+`);
+
+		await assert.rejects(
+			resolveSubagentLaunchContract({
+				agent: "scout",
+				cwd,
+				availableModels: [{ provider: "test", id: "other", fullId: "test/other" }],
+			}),
+			/Unknown subagent model 'test\/missing-primary'/,
+		);
+	});
+
+	it("fails closed when cached exclusions leave zero launch candidates", async () => {
+		const cwd = path.join(tempDir, "repo-cached-excluded-models");
+		fs.mkdirSync(cwd, { recursive: true });
+		writeAgent(path.join(cwd, ".selesai", "agents", "scout.md"), `---
+name: scout
+description: Project scout
+model: test/primary
+fallbackModels:
+  - test/fallback
+---
+Project prompt.
+`);
+		recordModelFailure({ modelId: "primary", provider: "test", reason: "sk-secret-token-xyz" });
+		recordModelFailure({ modelId: "fallback", provider: "test", reason: "sk-secret-token-xyz" });
+
+		await assert.rejects(
+			resolveSubagentLaunchContract({
+				agent: "scout",
+				cwd,
+				availableModels: [
+					{ provider: "test", id: "primary", fullId: "test/primary" },
+					{ provider: "test", id: "fallback", fullId: "test/fallback" },
+				],
+			}),
+			(error: unknown) => {
+				const message = String(error);
+				return /No usable subagent models remain after registry, scope, and cached-exclusion filtering/.test(message)
+					&& !message.includes("sk-secret-token-xyz");
+			},
+		);
+	});
+
 	it("trusts an inherited parent model outside the host registry", async () => {
 		const cwd = path.join(tempDir, "repo-parent-model");
 		fs.mkdirSync(cwd, { recursive: true });
@@ -850,4 +955,4 @@ Project prompt.
 		assert.equal(result.code, "denied_required_tool");
 		assert.match(result.message, /Unresolved MCP direct-tool selectors: rt__wiki\/read_wiki_structure\./);
 	});
-});
+});

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

@@ -115,4 +115,4 @@ describe("proactive skill subagent recommendations", () => {
 		assert.deepEqual(failedDiscoveryLines, []);
 		assert.equal(discoveryCalls, 1);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/process-terminal.test.ts

@@ -254,4 +254,4 @@ test("process-terminal reports unknown when the runner candidate is unavailable"
 	} finally {
 		fs.rmSync(asyncDir, { recursive: true, force: true });
 	}
-});
+});

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

@@ -369,4 +369,4 @@ describe("profiles helpers", () => {
 		assert.equal(result.results[0]?.inRegistry, true);
 		assert.deepEqual(probedModels, ["openai-codex/gpt-5.3-codex-spark:high"]);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/project-panes-public-api.test.ts

@@ -282,4 +282,4 @@ describe("public project-panes package export", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -241,4 +241,4 @@ describe("prompt-template delegation bridge", () => {
 		assert.equal(executeCalls, 0);
 		bridge.dispose();
 	});
-});
+});

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

@@ -164,4 +164,4 @@ Fix from {previous}: $@
 		]);
 		assert.equal(executed.value, "fixed output");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/pruned-fork.test.ts

@@ -211,4 +211,4 @@ describe("pruned fork sessions", () => {
 			fs.rmSync(tempDir, { recursive: true, force: true });
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/public-execution.test.ts

@@ -4,9 +4,10 @@ import { normalizePublicSubagentExecution } from "../../src/extension/public-exe
 
 describe("public subagent execution normalization", () => {
 	it("accepts structured single-child, workflow, management, and schedules", () => {
-		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1" }), { ok: true, params: { workflowScript: "return 1" } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1", globalConcurrencyLimit: 4, maxSubagentSpawnsPerRun: 8 }), { ok: true, params: { workflowScript: "return 1", globalConcurrencyLimit: 4, maxSubagentSpawnsPerRun: 8 } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflow: "review", args: { task: "Review this" } }), { ok: true, params: { workflow: "review", args: { task: "Review this" } } });
 		assert.deepEqual(normalizePublicSubagentExecution({ workflowScript: "return 1", preflight: { version: 1, lanes: [] } }), { ok: true, params: { workflowScript: "return 1", preflight: { version: 1, lanes: [] } } });
-		assert.deepEqual(normalizePublicSubagentExecution({ workflowScriptPath: "workflows/review.js" }), { ok: true, params: { workflowScriptPath: "workflows/review.js" } });
+		assert.deepEqual(normalizePublicSubagentExecution({ workflowScriptPath: "workflows/review.js", globalConcurrencyLimit: 2 }), { ok: true, params: { workflowScriptPath: "workflows/review.js", globalConcurrencyLimit: 2 } });
 		const task = "Use `quotes`\nand newlines";
 		assert.deepEqual(normalizePublicSubagentExecution({ agent: " worker ", task, context: "fresh", async: false }), {
 			ok: true,
@@ -74,6 +75,36 @@ describe("public subagent execution normalization", () => {
 		if (!result.ok) assert.match(result.error, /mutually exclusive/);
 	});
 
+	it("rejects named workflow combinations and caller-controlled provenance fields", () => {
+		for (const params of [
+			{ workflow: "review", workflowScript: "return 1" },
+			{ workflow: "review", workflowScriptPath: "workflow.js" },
+			{ workflow: "review", agent: "worker" },
+			{ workflow: "review", task: "work" },
+			{ args: { task: "work" } },
+			{ workflow: "review", resource: { kind: "workflow" } },
+			{ workflow: "review", resourceProvenance: { kind: "workflow" } },
+			{ workflow: "review", workflowResourcePermit: {} },
+		] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false, JSON.stringify(params));
+		}
+	});
+
+	it("keeps raw workflow inputs untrusted and rejects invalid named-resource arguments", () => {
+		const raw = normalizePublicSubagentExecution({ workflowScript: `return await runs.host("ci", { kind: "command", command: "npm test", timeoutMs: 1000 });` });
+		assert.equal(raw.ok, true);
+		if (raw.ok) assert.equal(Object.hasOwn(raw.params, "resource"), false);
+		for (const params of [
+			{ args: { task: "work" } },
+			{ workflow: "", args: {} },
+			{ workflow: 42, args: {} },
+		] as const) {
+			const result = normalizePublicSubagentExecution(params);
+			assert.equal(result.ok, false, JSON.stringify(params));
+		}
+	});
+
 	it("rejects preflight without a workflow input", () => {
 		const result = normalizePublicSubagentExecution({ agent: "worker", preflight: { version: 1, lanes: [] } });
 		assert.equal(result.ok, false);
@@ -138,8 +169,14 @@ describe("public subagent execution normalization", () => {
 			{ workflowScript: "return 1", isolation: "invalid" },
 			{ workflowScript: "return 1", isolation: "none", worktree: true },
 			{ workflowScript: "return 1", isolation: "worktree", worktree: false },
+			{ agent: "worker", globalConcurrencyLimit: 2 },
+			{ workflow: "review", maxSubagentSpawnsPerRun: 2 },
+			{ action: "validate", workflowScript: "return 1", globalConcurrencyLimit: 2 },
+			{ workflowScript: "return 1", globalConcurrencyLimit: 0 },
+			{ workflowScript: "return 1", maxSubagentSpawnsPerRun: 1.5 },
+			{ workflowScript: "return 1", maxSubagentSpawnsPerRun: Number.MAX_SAFE_INTEGER + 1 },
 		] as const) {
 			assert.equal(normalizePublicSubagentExecution(params).ok, false, JSON.stringify(params));
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/reads-resolution.test.ts

@@ -63,4 +63,4 @@ describe("reads path resolution", () => {
 			assert.equal(resolveChainPath("docs/x.md", chainDir), path.join(chainDir, "docs/x.md"));
 		});
 	});
-});
+});

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

@@ -262,4 +262,4 @@ describe("getSubagentDepthEnv", () => {
 		const env = getSubagentDepthEnv();
 		assert.equal(env.SELESAI_SUBAGENT_DEPTH, "1");
 	});
-});
+});

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

@@ -33,6 +33,37 @@ function result(agent: string, output: string) {
 	};
 }
 
+function countedWorkflowJob(onNodesRead: () => void): AsyncJobState {
+	const nodes = [
+		{ id: "step-0", kind: "step", agent: "scout", label: "Scout", status: "completed", flatIndex: 0, stepIndex: 0 },
+		{ id: "step-1", kind: "step", agent: "reviewer", label: "Review", status: "running", flatIndex: 1, stepIndex: 1 },
+	] as const;
+	return {
+		asyncId: "workflow-run",
+		asyncDir: "/tmp/workflow-run",
+		status: "running",
+		mode: "workflow",
+		agents: ["scout", "reviewer"],
+		currentStep: 1,
+		startedAt: 0,
+		updatedAt: 1000,
+		steps: [
+			{ index: 0, agent: "scout", status: "completed", workflowKey: "step-0" },
+			{ index: 1, agent: "reviewer", status: "running", workflowKey: "step-1" },
+		],
+		workflowGraph: {
+			runId: "workflow-run",
+			mode: "workflow",
+			phases: [],
+			currentNodeId: "step-1",
+			get nodes() {
+				onNodesRead();
+				return nodes;
+			},
+		} as never,
+	};
+}
+
 test("row clips content to the available width", () => {
 	const rendered = row("abcdef", 6, theme as any);
 	assert.equal(visibleWidth(rendered), 6);
@@ -160,7 +191,7 @@ test("widget render keys keep compact payloads quiet and expanded payloads fresh
 	assert.notEqual(widgetRenderKey(warningDetailChange, true), widgetRenderKey(preflightJob, true));
 });
 
-test("seeded running glyphs advance at wall-clock frame boundaries while unseeded glyphs stay static", () => {
+test("seeded running glyphs stay stable until the supplied animation frame advances", () => {
 	const originalNow = Date.now;
 	const runningGlyph = (lines: string[]): string => lines
 		.map((line) => line.match(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏●]/u)?.[0])
@@ -181,16 +212,18 @@ test("seeded running glyphs advance at wall-clock frame boundaries while unseede
 
 	try {
 		Date.now = () => 1_000;
-		const seededBeforeBoundary = runningGlyph(buildWidgetLines([seededJob], theme, 180));
-		const unseededBeforeBoundary = runningGlyph(buildWidgetLines([unseededJob], theme, 180));
+		const seededFrame0 = runningGlyph(buildWidgetLines([seededJob], theme, 180, false, 0));
+		const unseededBefore = runningGlyph(buildWidgetLines([unseededJob], theme, 180));
 
 		Date.now = () => 1_125;
-		const seededAfterBoundary = runningGlyph(buildWidgetLines([seededJob], theme, 180));
-		const unseededAfterBoundary = runningGlyph(buildWidgetLines([unseededJob], theme, 180));
-
-		assert.notEqual(seededAfterBoundary, seededBeforeBoundary);
-		assert.equal(unseededAfterBoundary, unseededBeforeBoundary);
-		assert.equal(unseededBeforeBoundary, "●");
+		const seededSameFrame = runningGlyph(buildWidgetLines([seededJob], theme, 180, false, 0));
+		const unseededAfter = runningGlyph(buildWidgetLines([unseededJob], theme, 180));
+		const seededNextFrame = runningGlyph(buildWidgetLines([seededJob], theme, 180, false, 1));
+
+		assert.equal(seededSameFrame, seededFrame0);
+		assert.equal(unseededAfter, unseededBefore);
+		assert.equal(unseededBefore, "●");
+		assert.notEqual(seededNextFrame, seededFrame0);
 	} finally {
 		Date.now = originalNow;
 	}
@@ -324,6 +357,23 @@ test("compact chain rendering uses workflow graph labels and parallel groups", (
 	assert.match(text, /Step 3\/3: Writer/);
 });
 
+test("widget rendering reuses one staged workflow projection", () => {
+	let nodeReads = 0;
+	const lines = buildWidgetLines([countedWorkflowJob(() => nodeReads++)], theme as any, 120, false, 0);
+
+	assert.equal(nodeReads, 1);
+	assert.match(lines.join("\n"), /staged lane · stage 2\/2 · Review · reviewer · running/);
+	assert.match(lines.join("\n"), /Stage 2\/2: Review/);
+});
+
+test("widget render keys reuse one staged workflow projection", () => {
+	let nodeReads = 0;
+
+	widgetRenderKey(countedWorkflowJob(() => nodeReads++));
+
+	assert.equal(nodeReads, 1);
+});
+
 test("compact chain rendering shows failed zero-child dynamic fanout groups", () => {
 	const component = renderSubagentResult({
 		content: [{ type: "text", text: "failed" }],
@@ -507,4 +557,4 @@ test("main-window renderer config caps only collapsed rich result rows", () => {
 
 	assert.ok(expanded.length > 3);
 	assert.doesNotMatch(expanded.join("\n"), /rows hidden/);
-});
+});

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

@@ -31,4 +31,4 @@ describe("result delivery ownership", () => {
 		assert.equal(ownership.owns("session-0", OWNER), false);
 		assert.equal(ownership.owns("session-8", OWNER), true);
 	});
-});
+});

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

@@ -498,4 +498,4 @@ describe("result file indexes", () => {
 			fs.rmSync(resultsDir, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -255,4 +255,4 @@ describe("result intercom formatter", () => {
 		assert.equal(resolveSubagentResultStatus({ success: true }), "completed");
 		assert.equal(resolveSubagentResultStatus({ exitCode: 1 }), "failed");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/unit/retained-children.test.ts

@@ -188,4 +188,4 @@ describe("retained child roster", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -113,6 +113,10 @@ describe("subagent extension RPC bridge", () => {
 			(reply as { data: { capabilities?: { asyncStatusSnapshot?: unknown } } }).data.capabilities?.asyncStatusSnapshot,
 			{ kind: "pi-subagents.async-status-snapshot", version: 1 },
 		);
+		assert.deepEqual(
+			(reply as { data: { capabilities?: { statusProjection?: unknown } } }).data.capabilities?.statusProjection,
+			{ version: 1, untargeted: "in-memory-when-ready", targeted: "executor" },
+		);
 
 		bridge.dispose();
 	});
@@ -159,6 +163,7 @@ 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: { details?: unknown } }).data.details, { mode: "management", results: [] });
 		assert.deepEqual((reply as { data: { fleet?: unknown } }).data.fleet, {
 			version: 1, entries: [], totalActive: 0, topLevelAsyncCapacity: { used: 0, limit: 0 }, omitted: 0,
 		});
@@ -166,6 +171,98 @@ describe("subagent extension RPC bridge", () => {
 		bridge.dispose();
 	});
 
+	it("serves untargeted status from restored in-memory projections", async () => {
+		const events = new FakeEvents();
+		const state = {
+			currentSessionId: "session-123",
+			statusProjectionSessionId: "session-123",
+			foregroundControls: new Map(),
+			asyncJobs: new Map([[
+				"private-id",
+				{ asyncId: "private-id", sessionId: "session-123", status: "running", mode: "single", startedAt: 100, agents: ["worker"] },
+			]]),
+		} as any;
+		let executeCalls = 0;
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx("session-123", "session-123"),
+			state,
+			execute: async () => {
+				executeCalls += 1;
+				return assert.fail("restored untargeted status should not call executor");
+			},
+		});
+
+		const reply = await request(events, "status-memory", "status");
+
+		assert.equal(reply.success, true);
+		assert.equal(executeCalls, 0);
+		assert.equal((reply as { data: { text?: string } }).data.text, "In-memory subagent status: 1 active child.");
+		assert.deepEqual((reply as any).data.details, { mode: "management", results: [] });
+		assert.equal((reply as any).data.fleet.totalActive, 1);
+		assert.deepEqual((reply as any).data.asyncSnapshot.runs.map((run: { id: string }) => run.id), ["private-id"]);
+
+		bridge.dispose();
+	});
+
+	it("falls back to executor status when projections are not restored or session identity is stale", async () => {
+		const events = new FakeEvents();
+		const state = {
+			currentSessionId: "old-session",
+			statusProjectionSessionId: null,
+			foregroundControls: new Map(),
+			asyncJobs: new Map(),
+		} as any;
+		const executed: unknown[] = [];
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx("session-123", "session-123"),
+			state,
+			execute: async (_id, params) => {
+				executed.push(params);
+				return { content: [{ type: "text", text: "canonical status" }], details: { mode: "single", results: [] } } as any;
+			},
+		});
+
+		const reply = await request(events, "status-fallback", "status");
+
+		assert.equal(reply.success, true);
+		assert.deepEqual(executed, [{ action: "status" }]);
+		assert.equal((reply as { data: { text?: string } }).data.text, "canonical status");
+
+		state.currentSessionId = "session-123";
+		executed.length = 0;
+		const notRestored = await request(events, "status-not-restored", "status");
+		assert.equal(notRestored.success, true);
+		assert.deepEqual(executed, [{ action: "status" }]);
+
+		bridge.dispose();
+	});
+
+	it("forwards and validates status view, lines, and index through the executor", async () => {
+		const events = new FakeEvents();
+		const executed: unknown[] = [];
+		const bridge = registerSubagentRpcBridge({
+			events,
+			getContext: () => ctx(),
+			execute: async (_id, params) => {
+				executed.push(params);
+				return { content: [{ type: "text", text: "transcript" }], details: { mode: "single", results: [] } } as any;
+			},
+		});
+
+		const reply = await request(events, "status-transcript", "status", { id: "run-1", view: "transcript", lines: 25, index: 2 });
+		assert.equal(reply.success, true);
+		assert.deepEqual(executed, [{ action: "status", id: "run-1", index: 2, view: "transcript", lines: 25 }]);
+
+		const invalid = await request(events, "status-invalid-lines", "status", { lines: 0 });
+		assert.equal(invalid.success, false);
+		assert.equal((invalid as { error: { code: string } }).error.code, "invalid_params");
+		assert.equal(executed.length, 1);
+
+		bridge.dispose();
+	});
+
 	it("delegates allowlisted schedule management through the active session", async () => {
 		const events = new FakeEvents();
 		const executed: unknown[] = [];
@@ -1024,4 +1121,4 @@ describe("subagent extension RPC bridge", () => {
 			fs.rmSync(root, { recursive: true, force: true });
 		}
 	});
-});
+});

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

@@ -188,4 +188,4 @@ describe("run fan-out budget", () => {
 		directories.push(linked);
 		assert.throws(() => validateRunFanoutBudgetDescriptor({ ...descriptor, directory: linked }), /resolves outside/);
 	});
-});
+});

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

@@ -244,4 +244,4 @@ describe("subagent run id resolver", () => {
 		assert.throws(() => resolveSubagentRunId("a/b"), /safe id token/);
 		assert.throws(() => resolveSubagentRunId(""), /safe id token/);
 	});
-});
+});