@selesai/code 0.13.5 → 0.13.7

package/dist/extensions/pi-subagents/test/integration/render-widget.test.ts

@@ -1103,6 +1103,38 @@ describe("subagent async widget rendering", () => {
 		resetWidgetLayout();
 	});
 
+	it("updates component expansion state without reinstalling the widget", () => {
+		resetWidgetLayout();
+		withStdoutSize(20, 120, () => {
+			const ui = createUiContext();
+			let expanded = false;
+			ui.ctx.ui.getToolsExpanded = () => expanded;
+			renderWidget(ui.ctx as never, [{
+				asyncId: "run-toggle-expanded",
+				asyncDir: "/tmp/run-toggle-expanded",
+				status: "running",
+				mode: "parallel",
+				agents: ["reviewer"],
+				activeParallelGroup: true,
+				runningSteps: 1,
+				completedSteps: 0,
+				stepsTotal: 1,
+				steps: [{ index: 0, agent: "reviewer", status: "running", currentTool: "read" }],
+			}]);
+			const component = (ui.widgets.at(-1) as (_tui: unknown, widgetTheme: typeof theme) => { render(width: number): string[] })(undefined, theme);
+
+			const collapsed = component.render(180).join("\n");
+			expanded = true;
+			const expandedText = component.render(180).join("\n");
+
+			assert.match(collapsed, /subagents \(1\/1 running\)/);
+			assert.doesNotMatch(collapsed, /parallel group · 1 agent running/);
+			assert.match(expandedText, /parallel group · 1 agent running · 0\/1 done/);
+			assert.match(expandedText, /reviewer · running/);
+		});
+		resetWidgetLayout();
+	});
+
 	it("shows per-agent detail for active async parallel widget rows", () => {
 		const now = Date.now();
 		const lines = buildWidgetLines([
@@ -1894,7 +1926,7 @@ describe("subagent async widget rendering", () => {
 		);
 	});
 
-	it("advances running widget glyphs when the wall clock moves despite unchanged progress", () => {
+	it("keeps running widget glyphs stable across unrelated renders of the same frame", () => {
 		const originalNow = Date.now;
 		const job = {
 			asyncId: "run-stable",
@@ -1909,14 +1941,16 @@ describe("subagent async widget rendering", () => {
 		};
 		try {
 			Date.now = () => 1_000;
-			const first = buildWidgetLines([job], theme, 120);
+			const first = buildWidgetLines([job], theme, 120, false, 0);
 			Date.now = () => 1_125;
-			const second = buildWidgetLines([job], theme, 120);
+			const second = buildWidgetLines([job], theme, 120, false, 0);
+			const third = buildWidgetLines([job], theme, 120, false, 1);
 			const withoutRunningGlyphs = (lines: string[]) => lines.map((line) => line.replace(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/gu, ""));
 
-			assert.notDeepEqual(second, first);
-			assert.deepEqual(withoutRunningGlyphs(second), withoutRunningGlyphs(first), "only the running glyph should change");
-			assert.notEqual(firstGrapheme(first[1] ?? ""), firstGrapheme(second[1] ?? ""));
+			assert.deepEqual(second, first, "unrelated renders of the same frame must not retick the glyph");
+			assert.notDeepEqual(third, first);
+			assert.deepEqual(withoutRunningGlyphs(third), withoutRunningGlyphs(first), "only the running glyph should change");
+			assert.notEqual(firstGrapheme(first[1] ?? ""), firstGrapheme(third[1] ?? ""));
 		} finally {
 			Date.now = originalNow;
 		}
@@ -1974,6 +2008,40 @@ describe("subagent async widget rendering", () => {
 		}
 	});
 
+	it("memoizes component render output by width and animation frame", () => {
+		const originalNow = Date.now;
+		let themeCalls = 0;
+		const countingTheme = {
+			fg: (_name: string, text: string) => {
+				themeCalls += 1;
+				return text;
+			},
+			bold: (text: string) => text,
+		};
+		try {
+			Date.now = () => 1_000;
+			const ui = createUiContext();
+			renderWidget(ui.ctx as never, [{ asyncId: "run-stable", asyncDir: "/tmp/run", status: "running", agents: ["scout"], updatedAt: 1_000 }]);
+			const component = (ui.widgets.at(-1) as (_tui: unknown, widgetTheme: typeof theme) => { render(width: number): string[] })(undefined, countingTheme);
+			const first = component.render(180);
+			const callsAfterFirst = themeCalls;
+
+			assert.equal(component.render(180), first);
+			assert.equal(themeCalls, callsAfterFirst, "same width and frame should reuse the rendered lines");
+
+			component.render(120);
+			assert.ok(themeCalls > callsAfterFirst, "a width change should rebuild lines");
+			const callsAfterWidthChange = themeCalls;
+
+			Date.now = () => 2_000;
+			component.render(120);
+			assert.ok(themeCalls > callsAfterWidthChange, "an animation-frame change should rebuild lines");
+		} finally {
+			Date.now = originalNow;
+			renderWidget(createUiContext().ctx as never, []);
+		}
+	});
+
 	it("does not animate queued-only widgets", () => {
 		const originalNow = Date.now;
 		try {
@@ -2020,4 +2088,4 @@ describe("subagent async widget rendering", () => {
 		assert.equal(ui.widgets.length, afterClearCount, "cleared widget should stay quiet");
 		assert.equal(ui.widgets.at(-1), undefined);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/result-watcher.test.ts

@@ -2439,4 +2439,4 @@ describe("result watcher", () => {
 		});
 	});
 
-});
+});

package/dist/extensions/pi-subagents/test/integration/session-tokens.test.ts

@@ -59,4 +59,4 @@ describe("session tokens", { skip: !available ? "pi packages not available" : un
 			removeTempDir(sessionDir);
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/single-execution.test.ts

@@ -65,7 +65,7 @@ import { discardPreservedWorktrees } from "../../src/runs/shared/parallel-handof
 import { createWorktrees } from "../../src/runs/shared/worktree.ts";
 import { resolveAsyncResumeTarget } from "../../src/runs/background/async-resume.ts";
 import { createResultWatcher } from "../../src/runs/background/result-watcher.ts";
-import { clearExclusions } from "../../src/runs/shared/model-exclusions.ts";
+import { clearExclusions, recordModelFailure } from "../../src/runs/shared/model-exclusions.ts";
 import { createWorkflowChildPermit, workflowChildPermitConsumed } from "../../src/shared/workflow-child-permit.ts";
 import { toSubagentDelegationExecutionParams } from "../../src/slash/delegation-adapters.ts";
 
@@ -412,7 +412,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 	});
 
 	it("derives a child session name and passes it to the child env", async () => {
-		mockPi.onCall({ echoEnv: ["PI_SUBAGENT_SESSION_NAME"] });
+		mockPi.onCall({ echoEnv: ["SELESAI_SUBAGENT_SESSION_NAME"] });
 		const agents = makeAgentConfigs(["echo"]);
 
 		const result = await runSync(tempDir, agents, "echo", "Say hello to the world", {});
@@ -421,7 +421,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(result.sessionName, "echo: Say hello to the world");
 		assert.equal(result.progressSummary?.sessionName, "echo: Say hello to the world");
 		const echoed = JSON.parse(getFinalOutput(result.messages));
-		assert.equal(echoed.PI_SUBAGENT_SESSION_NAME, "echo: Say hello to the world");
+		assert.equal(echoed.SELESAI_SUBAGENT_SESSION_NAME, "echo: Say hello to the world");
 	});
 
 	it("rejects invalid foreground cwd before spawning Pi", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
@@ -754,9 +754,9 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		const text = result.content.map((part) => part.type === "text" ? part.text : "").join("\n");
 		assert.equal(result.details.results[0]?.detachedReason, "user request");
 		assert.match(text, /Detached at user request/);
-		assert.match(text, /subagent_wait\(\{ id: "[^"]+", nonBlocking: true \}\)/);
-		assert.doesNotMatch(text, /intercom coordination|supervisor request|Wait with subagent_wait/);
-		assert.doesNotMatch(text, /subagent_wait\(\{ id: "[^"]+" \}\)/);
+		assert.match(text, /bg_wait\(\{ id: "[^"]+", nonBlocking: true \}\)/);
+		assert.doesNotMatch(text, /intercom coordination|supervisor request|Wait with bg_wait/);
+		assert.doesNotMatch(text, /bg_wait\(\{ id: "[^"]+" \}\)/);
 
 		let terminalChild = state.foregroundRuns?.get(control.runId)?.children[0];
 		for (let attempt = 0; attempt < 250 && terminalChild?.status !== "completed"; attempt++) {
@@ -882,7 +882,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		const scriptPath = path.join(tempDir, "host-command.cjs");
 		fs.writeFileSync(scriptPath, `process.stdout.write("host command passed\\n");`);
 		const executor = makeExecutor([makeAgent("echo")]);
-		const result = await executor.executePublic(
+		const result = await executor.execute(
 			"host-command",
 			{
 				async: false,
@@ -903,7 +903,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 
 		const failedScriptPath = path.join(tempDir, "host-command-failed.cjs");
 		fs.writeFileSync(failedScriptPath, `process.stderr.write("host command failed\\n"); process.exit(4);`);
-		const failed = await executor.executePublic(
+		const failed = await executor.execute(
 			"host-command-failed",
 			{
 				async: false,
@@ -917,6 +917,74 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.deepEqual(failed.details.workflow?.receipt?.hostSteps?.map(({ state, reasonCode, exitCode }) => ({ state, reasonCode, exitCode })), [{ state: "error", reasonCode: "command_failed", exitCode: 4 }]);
 	});
 
+	it("resolves a named workflow resource internally and exposes its provenance", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({ output: "Named review completed" });
+		const result = await makeExecutor([makeAgent("reviewer")]).executePublic(
+			"named-review-resource",
+			{ workflow: "review", args: { task: "Review the change" }, async: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(result.isError, undefined, result.content[0]?.text ?? "named workflow failed");
+		assert.match(result.content[0]?.text ?? "", /Named review completed/);
+		assert.equal(result.details.workflow?.resource?.kind, "workflow");
+		assert.equal(result.details.workflow?.resource?.name, "review");
+		assert.equal(result.details.workflow?.resource?.invocation, "named");
+		assert.equal(result.details.workflow?.receipt?.resource?.id, result.details.workflow?.resource?.id);
+		assert.equal(mockPi.callCount(), 1);
+	});
+
+	it("denies host calls from raw public workflow scripts without resource authority", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const result = await makeExecutor([makeAgent("echo")]).executePublic(
+			"raw-host-denied",
+			{ workflowScript: `return await runs.host("ci", { kind: "command", command: "npm test", timeoutMs: 1000 });`, async: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /runs\.host is unavailable/);
+		assert.equal(result.details.workflow?.resource, undefined);
+		assert.equal(result.details.workflow?.receipt?.resource, undefined);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
+	it("denies host calls when scheduled raw workflows replay", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const markerPath = path.join(tempDir, "scheduled-host-marker.txt");
+		const script = `require("node:fs").writeFileSync(${JSON.stringify(markerPath)}, "ran");`;
+		const result = await makeExecutor([makeAgent("echo")]).executeScheduled(
+			"scheduled-raw-host-denied",
+			{
+				workflowScript: `return await runs.host("ci", { kind: "command", command: ${JSON.stringify(`${JSON.stringify(process.execPath)} -e ${JSON.stringify(script)}`)}, timeoutMs: 1000 });`,
+				async: false,
+				scheduleOrigin: { id: "nightly" },
+			},
+			new AbortController().signal,
+			makeMinimalCtx(tempDir),
+		);
+		assert.equal(result.isError, true);
+		assert.match(result.content[0]?.text ?? "", /runs\.host is unavailable/);
+		assert.equal(fs.existsSync(markerPath), false);
+		assert.equal(result.details.workflow?.resource, undefined);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
+	it("admits only the host command granted by a named workflow resource", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const result = await makeExecutor([makeAgent("echo")]).executePublic(
+			"named-ci-resource",
+			{ workflow: "run-ci", args: { command: "npm run typecheck", timeoutMs: 120_000 }, async: false },
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(path.resolve(".")),
+		);
+		assert.equal(result.isError, undefined, result.content[0]?.text ?? "named CI workflow failed");
+		assert.equal(result.details.workflow?.resource?.name, "run-ci");
+		assert.equal(result.details.workflow?.receipt?.resource?.name, "run-ci");
+		assert.deepEqual(result.details.workflow?.receipt?.hostSteps?.map(({ id, state, exitCode }) => ({ id, state, exitCode })), [{ id: "ci", state: "done", exitCode: 0 }]);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
 	it("explains the cwd workaround instead of launching a host step", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		const executor = makeExecutor([makeAgent("echo")]);
 		const result = await executor.executePublic(
@@ -940,7 +1008,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		fs.writeFileSync(scriptPath, `process.stdout.write("host owns output\\n");`);
 		const sharedOutput = path.join(tempDir, "reports", "shared.log");
 		const executor = makeExecutor([makeAgent("echo")]);
-		const result = await executor.executePublic(
+		const result = await executor.execute(
 			"host-output-collision",
 			{
 				async: false,
@@ -962,7 +1030,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		fs.symlinkSync(reportsDir, path.join(tempDir, "linked-reports"), "dir");
 		fs.writeFileSync(scriptPath, `process.stdout.write("host owns output alias\\n");`);
 		const executor = makeExecutor([makeAgent("echo")]);
-		const result = await executor.executePublic(
+		const result = await executor.execute(
 			"host-output-alias-collision",
 			{
 				async: false,
@@ -984,7 +1052,7 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		const aliasScriptPath = path.join(tempDir, "host-output-alias.cjs");
 		fs.writeFileSync(firstScriptPath, `process.stdout.write("first evidence\\n");`);
 		fs.writeFileSync(aliasScriptPath, `const fs = require("node:fs"); fs.rmSync(${JSON.stringify(path.join(tempDir, "late-link"))}, { recursive: true, force: true }); fs.symlinkSync(${JSON.stringify(reportsDir)}, ${JSON.stringify(path.join(tempDir, "late-link"))}, "dir"); process.stdout.write("second evidence\\n");`);
-		const result = await makeExecutor([makeAgent("echo")]).executePublic(
+		const result = await makeExecutor([makeAgent("echo")]).execute(
 			"host-output-late-alias-collision",
 			{
 				async: false,
@@ -2983,6 +3051,61 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.deepEqual(fs.readFileSync(sharedOutput), Buffer.from(usefulReport));
 	});
 
+	it("continues to a read-only review after malformed file-only acceptance metadata", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		const sharedOutput = path.join(tempDir, "implementation-report.md");
+		const malformed = `ACCEPTANCE_REPORT: ${JSON.stringify({ criteriaSatisfied: true, commandsRun: ["npm test"] })}`;
+		mockPi.onCall({
+			output: "Implementation report persisted.",
+			matchArgIncludes: "Write implementation report",
+			jsonl: [...events.completedWrite(sharedOutput, malformed), events.assistantMessage("Implementation report persisted.")],
+			writeFiles: [{ path: sharedOutput, content: malformed }],
+		});
+		mockPi.onCall({ output: "Read-only review completed.", matchArgIncludes: "Review the persisted implementation report without editing it" });
+		const executor = makeExecutor([
+			makeAgent("worker", { tools: ["read", "write"], completionGuard: false }),
+			makeAgent("reviewer", { tools: ["read"], completionGuard: false }),
+		]);
+
+		const result = await executor.execute(
+			"scripted-workflow-malformed-acceptance-recovery",
+			{
+				async: false,
+				workflowScript: `
+					const writer = await runs.run("writer", {
+						agent: "worker",
+						task: "Write implementation report",
+						output: ${JSON.stringify(sharedOutput)},
+						outputMode: "file-only",
+						acceptance: { level: "checked", criteria: ["Return the implementation report"] }
+					});
+					const review = await runs.run("review", {
+						agent: "reviewer",
+						task: "Review the persisted implementation report without editing it",
+						acceptance: false
+					});
+					return { writerOk: writer.ok, writerRecovery: writer.recovery, reviewOk: review.ok };
+				`,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined, result.content[0]?.text ?? "workflow failed");
+		const value = result.details.workflow?.value as { writerOk?: boolean; writerRecovery?: { status?: string; reason?: string; reportPath?: string; reportHash?: string }; reviewOk?: boolean };
+		assert.equal(value.writerOk, false);
+		assert.equal(value.writerRecovery?.status, "available-for-review");
+		assert.equal(value.writerRecovery?.reason, "acceptance-metadata-rejected");
+		assert.equal(value.writerRecovery?.reportPath, sharedOutput);
+		assert.match(value.writerRecovery?.reportHash ?? "", /^[0-9a-f]{64}$/);
+		assert.equal(value.reviewOk, true);
+		assert.equal(result.details.results[0]?.acceptance?.status, "rejected");
+		assert.equal(result.details.results[0]?.outputReference?.path, sharedOutput);
+		assert.equal(result.details.results[0]?.savedOutputPath, sharedOutput);
+		assert.equal(result.details.workflowChildren?.children.find((child) => child.childId === "writer")?.state, "rejected");
+		assert.deepEqual(fs.readFileSync(sharedOutput, "utf-8"), malformed);
+	});
+
 	it("identifies validation failures before any workflow child launches", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		const executor = makeExecutor([makeAgent("worker")]);
 		const workflowId = "scripted-workflow-invalid-nested-async";
@@ -3256,6 +3379,28 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		for (const child of children) assert.match(child.error ?? "", /workflow\[second\].*0\/1 used; 2 requested, 1 remaining/);
 	});
 
+	it("lets an explicit workflow spawn override exceed config", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
+		mockPi.onCall({ output: "first child completed" });
+		mockPi.onCall({ output: "second child completed" });
+		const result = await makeExecutor([makeAgent("echo")], { maxSubagentSpawnsPerRun: 1 }).execute(
+			"scripted-workflow-fanout-override",
+			{
+				async: false,
+				maxSubagentSpawnsPerRun: 2,
+				workflowScript: `return await runs.all([
+					{ key: "first", agent: "echo", task: "First task" },
+					{ key: "second", agent: "echo", task: "Second task" }
+				]);`,
+			},
+			new AbortController().signal,
+			undefined,
+			makeMinimalCtx(tempDir),
+		);
+
+		assert.equal(result.isError, undefined, result.content[0]?.text ?? "workflow failed");
+		assert.equal(mockPi.callCount(), 2);
+	});
+
 	it("runs a direct child gate as host-verified acceptance", { skip: !createSubagentExecutor ? "executor not importable" : undefined }, async () => {
 		const markerFile = "direct-gate.txt";
 		const markerPath = path.join(tempDir, markerFile);
@@ -5588,6 +5733,34 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(mockPi.callCount(), 1);
 	});
 
+	it("fails closed before spawn when cached exclusions leave zero launch candidates", async () => {
+		recordModelFailure({ modelId: "gpt-5-mini", provider: "openai", reason: "sk-secret-token-xyz" });
+		recordModelFailure({ modelId: "claude-sonnet-4", provider: "anthropic", reason: "sk-secret-token-xyz" });
+		mockPi.onCall({ output: "should not spawn" });
+		const agents = [makeAgent("worker", {
+			model: "openai/gpt-5-mini",
+			fallbackModels: ["anthropic/claude-sonnet-4"],
+		})];
+
+		await assert.rejects(
+			runSync(tempDir, agents, "worker", "Do work", {
+				runId: "cached-exclusion-zero-candidates",
+				acceptance: false,
+				availableModels: [
+					{ provider: "openai", id: "gpt-5-mini", fullId: "openai/gpt-5-mini" },
+					{ provider: "anthropic", id: "claude-sonnet-4", fullId: "anthropic/claude-sonnet-4" },
+				],
+			}),
+			(error: unknown) => {
+				assert.ok(error instanceof Error);
+				assert.match(error.message, /No usable subagent models remain after registry, scope, and cached-exclusion filtering/);
+				assert.equal(error.message.includes("sk-secret-token-xyz"), false);
+				return true;
+			},
+		);
+		assert.equal(mockPi.callCount(), 0);
+	});
+
 	it("retries a zero-activity startup exit on the same model", async () => {
 		mockPi.onCall({ exitCode: 1 });
 		mockPi.onCall({ output: "Recovered after startup race" });
@@ -6486,6 +6659,95 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.ok((runningUpdates.at(-1)?.durationMs ?? 0) > (runningUpdates[0]?.durationMs ?? 0), "expected heartbeat duration to advance");
 	});
 
+	it("suppresses unchanged delegated heartbeats without changing ordinary foreground updates", async () => {
+		const updates: Array<{ text: string; durationMs: number | undefined }> = [];
+		const releasePath = path.join(tempDir, "release-delegated-progress");
+		mockPi.onCall({ output: "Done", waitForPath: releasePath });
+
+		const runPromise = runSync!(tempDir, makeAgentConfigs(["echo"]), "echo", "Task", {
+			suppressUnchangedDelegationUpdates: true,
+			onUpdate: (update: { content: Array<{ type: string; text?: string }>; details?: { progress?: ProgressSummary[] } }) => {
+				updates.push({
+					text: update.content[0]?.text ?? "",
+					durationMs: update.details?.progress?.[0]?.durationMs,
+				});
+			},
+		});
+		const initialDeadline = Date.now() + 5_000;
+		while (updates.filter((update) => update.text === "(running...)").length < 1 && Date.now() < initialDeadline) {
+			await new Promise((resolve) => setTimeout(resolve, 50));
+		}
+		await new Promise((resolve) => setTimeout(resolve, 1_200));
+		assert.equal(updates.filter((update) => update.text === "(running...)").length, 1, "duration-only delegated heartbeats should be coalesced");
+
+		fs.writeFileSync(releasePath, "release", "utf-8");
+		const result = await runPromise;
+		assert.equal(result.exitCode, 0);
+		assert.ok(updates.some((update) => update.text === "Done"), "changed terminal output should still be delivered");
+	});
+
+	it("delivers delegated activity-state transitions despite heartbeat suppression", async () => {
+		const attentionUpdates: Array<{ details?: { progress?: ProgressSummary[] } }> = [];
+		const attentionReleasePath = path.join(tempDir, "release-delegated-attention");
+		mockPi.onCall({ output: "Done", waitForPath: attentionReleasePath });
+		const attentionRun = runSync!(tempDir, makeAgentConfigs(["echo"]), "echo", "Task", {
+			suppressUnchangedDelegationUpdates: true,
+			controlConfig: {
+				enabled: true,
+				needsAttentionAfterMs: 200,
+				activeNoticeAfterMs: 999_999,
+				activeNoticeAfterTurns: 999_999,
+				activeNoticeAfterTokens: 999_999,
+				notifyOn: ["needs_attention"],
+				notifyChannels: ["event"],
+			},
+			onUpdate: (update: { details?: { progress?: ProgressSummary[] } }) => attentionUpdates.push(update),
+		});
+		try {
+			const deadline = Date.now() + 5_000;
+			while (!attentionUpdates.some((update) => update.details?.progress?.[0]?.activityState === "needs_attention") && Date.now() < deadline) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+			}
+			assert.ok(attentionUpdates.some((update) => update.details?.progress?.[0]?.activityState === "needs_attention"), "needs_attention transition should not be coalesced");
+		} finally {
+			fs.writeFileSync(attentionReleasePath, "release", "utf-8");
+			await attentionRun;
+		}
+
+		const activeUpdates: Array<{ details?: { progress?: ProgressSummary[] } }> = [];
+		const activeReleasePath = path.join(tempDir, "release-delegated-active");
+		mockPi.onCall({
+			steps: [
+				{ jsonl: [events.toolStart("contact_supervisor", { message: "waiting" })] },
+				{ waitForPath: activeReleasePath, jsonl: [events.toolEnd("contact_supervisor"), events.toolResult("contact_supervisor", "done")] },
+				{ jsonl: [events.assistantMessage("Done")] },
+			],
+		});
+		const activeRun = runSync!(tempDir, makeAgentConfigs(["echo"]), "echo", "Task", {
+			suppressUnchangedDelegationUpdates: true,
+			controlConfig: {
+				enabled: true,
+				needsAttentionAfterMs: 999_999,
+				activeNoticeAfterMs: 200,
+				activeNoticeAfterTurns: 999_999,
+				activeNoticeAfterTokens: 999_999,
+				notifyOn: ["active_long_running"],
+				notifyChannels: ["event"],
+			},
+			onUpdate: (update: { details?: { progress?: ProgressSummary[] } }) => activeUpdates.push(update),
+		});
+		try {
+			const deadline = Date.now() + 5_000;
+			while (!activeUpdates.some((update) => update.details?.progress?.[0]?.activityState === "active_long_running") && Date.now() < deadline) {
+				await new Promise((resolve) => setTimeout(resolve, 50));
+			}
+			assert.ok(activeUpdates.some((update) => update.details?.progress?.[0]?.activityState === "active_long_running"), "active_long_running transition should not be coalesced");
+		} finally {
+			fs.writeFileSync(activeReleasePath, "release", "utf-8");
+			await activeRun;
+		}
+	});
+
 	it("reports foreground context window usage without changing cumulative spend", async () => {
 		mockPi.onCall({
 			jsonl: [{
@@ -8742,4 +9004,4 @@ describe("single sync execution", { skip: !available ? "pi packages not availabl
 		assert.equal(result.exitCode, 0);
 	});
 
-});
+});

package/dist/extensions/pi-subagents/test/integration/slash-commands.test.ts

@@ -1122,6 +1122,51 @@ describe("slash command custom message delivery", { skip: !available ? "slash-co
 		});
 	});
 
+	it("/subagents-models accepts discovered and runtime agent names", async () => {
+		await withTempProject("pi-slash-models-agent-", async (root) => {
+			fs.writeFileSync(path.join(root, ".selesai", "agents", "project-helper.md"), "---\nname: project-helper\ndescription: Project helper\n---\nProject helper.\n", "utf-8");
+			const runtimeRun = await captureSlashCommandParams("subagents-models", "runtime-helper", root, (pi) => {
+				registerAgent({
+					pi: pi as never,
+					name: "runtime-helper",
+					definition: { description: "Runtime helper", systemPrompt: "Help at runtime." },
+				});
+			});
+			assert.deepEqual(runtimeRun.params, { action: "models", agent: "runtime-helper" });
+
+			const projectRun = await captureSlashCommandParams("subagents-models", "project-helper", root);
+			assert.deepEqual(projectRun.params, { action: "models", agent: "project-helper" });
+
+			await withIsolatedHome(async () => {
+				const commands = new Map<string, RegisteredSlashCommand>();
+				const pi = {
+					events: createEventBus(),
+					on() { return () => {}; },
+					registerTool() {},
+					registerCommand(name: string, spec: RegisteredSlashCommand) { commands.set(name, spec); },
+					registerShortcut() {},
+					sendMessage() {},
+				};
+				const registration = registerAgent({
+					pi: pi as never,
+					name: "runtime-helper",
+					definition: { description: "Runtime helper", systemPrompt: "Help at runtime." },
+				});
+				try {
+					const disposer = registerSlashCommands!(pi, createState(root));
+					try {
+						const completions = commands.get("subagents-models")!.getArgumentCompletions!("runtime-") as Array<{ value: string }>;
+						assert.deepEqual(completions.map(({ value }) => value), ["runtime-helper"]);
+					} finally {
+						disposer.dispose();
+					}
+				} finally {
+					registration.dispose();
+				}
+			});
+		});
+	});
+
 	it("/run preserves existing relative reads and omits missing reads", async () => {
 		await withTempProject("pi-slash-reads-", async (root) => {
 			fs.writeFileSync(path.join(root, ".selesai", "agents", "scout.md"), `---
@@ -1468,4 +1513,4 @@ describe("subagents-inspect-rpc command", { skip: !available ? "slash-commands.t
 		assert.equal(widgetCalls.length, 0);
 		assert.match(notifications[0] ?? "", /RPC surfaces/);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/slash-live-state.test.ts

@@ -163,4 +163,4 @@ describe("slash live state", { skip: !available ? "slash-live-state.ts not impor
 		const restored = getSlashRenderableSnapshot!(details);
 		assert.equal((restored.result.content[0] as { text: string }).text, "Done.");
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/template-resolution.test.ts

@@ -341,4 +341,4 @@ describe("createChainDir", { skip: !available ? "pi packages not available" : un
 			removeTempDir(base);
 		}
 	});
-});
+});

package/dist/extensions/pi-subagents/test/integration/top-level-async.test.ts

@@ -40,4 +40,4 @@ describe("force top-level async helper", { skip: !available ? "pi packages not a
 		const next = mod!.applyForceTopLevelAsyncOverride(params, 0, false);
 		assert.equal(next, params);
 	});
-});
+});

package/dist/extensions/pi-subagents/test/support/cursor-smoke-inputs.ts

@@ -26,11 +26,11 @@ function pathWithin(parent: string, child: string): boolean {
 }
 
 export function cursorSmokeInputs(env: NodeJS.ProcessEnv): CursorSmokeInputs {
-	if (env.PI_SUBAGENTS_CURSOR_SMOKE_DISPOSABLE !== "1") {
-		throw new Error("PI_SUBAGENTS_CURSOR_SMOKE_DISPOSABLE=1 is required to attest that the operator-managed workspace is disposable.");
+	if (env.SELESAI_SUBAGENTS_CURSOR_SMOKE_DISPOSABLE !== "1") {
+		throw new Error("SELESAI_SUBAGENTS_CURSOR_SMOKE_DISPOSABLE=1 is required to attest that the operator-managed workspace is disposable.");
 	}
-	const workspace = existingDirectory(env.PI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE, "PI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE");
-	const stateRoot = existingDirectory(env.PI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT, "PI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT");
+	const workspace = existingDirectory(env.SELESAI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE, "SELESAI_SUBAGENTS_CURSOR_SMOKE_WORKSPACE");
+	const stateRoot = existingDirectory(env.SELESAI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT, "SELESAI_SUBAGENTS_CURSOR_SMOKE_STATE_ROOT");
 	if (pathWithin(workspace, stateRoot) || pathWithin(stateRoot, workspace)) {
 		throw new Error("Cursor smoke workspace and state root must be separate directories so the production --add-dir launch shape is exercised.");
 	}
@@ -48,4 +48,4 @@ export function cursorSmokeInputs(env: NodeJS.ProcessEnv): CursorSmokeInputs {
 	}
 	if (fs.readdirSync(promptDirectory).length > 0) throw new Error(`Cursor smoke prompt directory must be empty before launch: ${promptDirectory}`);
 	return { workspace, stateRoot, canaryPath, promptDirectory };
-}
+}

package/dist/extensions/pi-subagents/test/support/helpers.ts

@@ -222,4 +222,4 @@ export const events = {
 			},
 		};
 	},
-};
+};

package/dist/extensions/pi-subagents/test/support/isolated-temp-root.mjs

@@ -6,4 +6,4 @@ if (!process.env.SELESAI_SUBAGENTS_TEMP_ROOT) {
 	const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-test-root-"));
 	process.env.SELESAI_SUBAGENTS_TEMP_ROOT = tempRoot;
 	process.on("exit", () => fs.rmSync(tempRoot, { recursive: true, force: true }));
-}
+}

package/dist/extensions/pi-subagents/test/support/mock-pi-script.mjs

@@ -429,4 +429,4 @@ async function main() {
 
 main().catch((error) => {
 	fail(error instanceof Error ? error.message : String(error));
-});
+});

package/dist/extensions/pi-subagents/test/support/mock-pi.ts

@@ -156,4 +156,4 @@ export function createMockPi(): MockPi {
 			return listQueueFiles(queueDir, CALL_PREFIX).length;
 		},
 	};
-}
+}

package/dist/extensions/pi-subagents/test/support/node-command.ts

@@ -12,4 +12,4 @@ export function writeNodeCommand(directory: string, name: string, source: string
 	const commandPath = path.join(directory, name);
 	fs.writeFileSync(commandPath, `#!/usr/bin/env node\n${source}\n`, { encoding: "utf-8", mode: 0o755 });
 	return commandPath;
-}
+}

package/dist/extensions/pi-subagents/test/support/real-session-child-cli.mjs

@@ -182,4 +182,4 @@ async function main() {
 main().catch((error) => {
 	process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
 	process.exit(1);
-});
+});