@selesai/code 0.5.28 → 0.6.1

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

@@ -53,7 +53,7 @@ describe("agent management config parsing", () => {
 		);
 
 		assert.equal(result.isError, false);
-		assert.match(readText(result), /- scout \(project\): Project scout override/);
+		assert.match(readText(result), /- scout \(project, context: fresh\): Project scout override/);
 		assert.doesNotMatch(readText(result), /- scout \(builtin/);
 	});
 
@@ -722,6 +722,126 @@ Drive the failing test first.
 		assert.match(content, /inheritSkills: false/);
 	});
 
+	it("exposes a rich human and machine catalog for a custom project agent and chain", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		const created = handleCreate(
+			{
+				config: {
+					name: "Catalog Writer",
+					description: "Scoped catalog writer",
+					scope: "project",
+					aliases: "catw",
+					acceptanceRole: "writer",
+					defaultContext: "fork",
+					tools: "read, grep, find, ls, bash, edit, write, mcp:fixture_search",
+					systemPrompt: "Implement scoped changes.",
+				},
+			},
+			ctx,
+		);
+		assert.equal(created.isError, false);
+
+		const chainCreated = handleCreate(
+			{ config: { name: "Review Flow", description: "Catalog review flow", scope: "project", steps: [{ agent: "catalog-writer", task: "Inspect" }] } },
+			ctx,
+		);
+		assert.equal(chainCreated.isError, false);
+
+		const listed = handleManagementAction("list", {}, ctx);
+		assert.equal(listed.isError, false);
+		const text = readText(listed);
+		assert.match(text, /Executable agents:/);
+		assert.match(
+			text,
+			/- catalog-writer \(project, context: fork, role: writer, aliases: catw, tools: read, grep, find, ls, bash, edit, write, mcp:fixture_search\): Scoped catalog writer/,
+		);
+		assert.match(text, /Chains:\n- review-flow \(project\): Catalog review flow/);
+
+		const details = (listed as { details: { catalog: unknown } }).details.catalog as {
+			version: number;
+			agents: Array<{
+				name: string;
+				source: string;
+				description: string;
+				executable: boolean;
+				aliases?: string[];
+				defaultContext: string;
+				acceptanceRole?: string;
+				tools?: string[];
+			}>;
+			chains: Array<{ name: string; source: string; description: string }>;
+		};
+		assert.equal(details.version, 1);
+		const entry = details.agents.find((agent) => agent.name === "catalog-writer");
+		assert.ok(entry, "catalog must include the custom project agent");
+		assert.equal(entry.source, "project");
+		assert.equal(entry.description, "Scoped catalog writer");
+		assert.equal(entry.executable, true);
+		assert.deepEqual(entry.aliases, ["catw"]);
+		assert.equal(entry.defaultContext, "fork");
+		assert.equal(entry.acceptanceRole, "writer");
+		assert.deepEqual(entry.tools, ["read", "grep", "find", "ls", "bash", "edit", "write", "mcp:fixture_search"]);
+		assert.deepEqual(details.chains, [{ name: "review-flow", source: "project", description: "Catalog review flow" }]);
+	});
+
+	it("normalizes unset defaultContext to fresh in the machine catalog", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		const created = handleCreate(
+			{ config: { name: "No Context", description: "No explicit context", scope: "project", systemPrompt: "Work" } },
+			ctx,
+		);
+		assert.equal(created.isError, false);
+
+		const listed = handleManagementAction("list", {}, ctx);
+		const details = (listed as { details: { catalog: unknown } }).details.catalog as {
+			agents: Array<{ name: string; defaultContext: string }>;
+		};
+		const entry = details.agents.find((agent) => agent.name === "no-context");
+		assert.ok(entry);
+		assert.equal(entry.defaultContext, "fresh");
+		assert.match(readText(listed), /- no-context \(project, context: fresh\)/);
+	});
+
+	it("omits disabled agents from both human text and machine catalog metadata", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		const created = handleCreate(
+			{ config: { name: "Hidden Writer", description: "Should stay hidden", scope: "project", systemPrompt: "Work" } },
+			ctx,
+		);
+		assert.equal(created.isError, false);
+
+		const disabled = handleManagementAction("disable", { agent: "hidden-writer" }, ctx);
+		assert.equal(disabled.isError, false);
+
+		const listed = handleManagementAction("list", {}, ctx);
+		assert.equal(listed.isError, false);
+		assert.doesNotMatch(readText(listed), /hidden-writer/);
+		const details = (listed as { details: { catalog: unknown } }).details.catalog as {
+			agents: Array<{ name: string }>;
+		};
+		assert.equal(details.agents.some((agent) => agent.name === "hidden-writer"), false);
+	});
+
+	it("returns (none) text and an empty versioned catalog when no agents are discovered", () => {
+		fs.mkdirSync(path.join(tempDir, "agent-home"), { recursive: true });
+		fs.writeFileSync(
+			path.join(tempDir, "agent-home", "settings.json"),
+			JSON.stringify({ subagents: { disableBuiltins: true } }, null, 2),
+			"utf-8",
+		);
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		const listed = handleManagementAction("list", {}, ctx);
+		assert.equal(listed.isError, false);
+		const text = readText(listed);
+		assert.match(text, /Executable agents:\n- \(none\)/);
+		assert.match(text, /Chains:\n- \(none\)/);
+		assert.deepEqual((listed as { details: { catalog: unknown } }).details.catalog, {
+			version: 1,
+			agents: [],
+			chains: [],
+		});
+	});
+
 	it("lists proactive skill subagent suggestions from repeated configured skill use", () => {
 		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
 		fs.mkdirSync(path.join(tempDir, ".selesai", "agents"), { recursive: true });
@@ -774,4 +894,44 @@ Inspect cleanup.
 		assert.doesNotMatch(readText(listed), /Proactive skill subagent suggestions:/);
 	});
 
+	it("appends explicit-only task-aware advisory routing to list output when task is provided", () => {
+		const ctx = { cwd: tempDir, modelRegistry: { getAvailable: () => [] } };
+		handleCreate(
+			{ config: { name: "Code Reviewer", description: "Reviews without editing", scope: "project", acceptanceRole: "read-only", tools: "read, grep, find, ls", systemPrompt: "Review." } },
+			ctx,
+		);
+		handleCreate(
+			{ config: { name: "Fixer", description: "Implements changes", scope: "project", acceptanceRole: "writer", tools: "read, grep, bash, edit, write", systemPrompt: "Fix." } },
+			ctx,
+		);
+
+		const implementation = handleManagementAction("list", { task: "Implement the fix" }, ctx);
+		assert.equal(implementation.isError, false);
+		assert.deepEqual((implementation as { details: { results: unknown[] } }).details.results, []);
+		const implementationText = readText(implementation);
+		assert.match(implementationText, /Task-aware advisory routing:/);
+		assert.match(implementationText, /- Intent: implementation/);
+		assert.match(implementationText, /- Recommended: fixer \(project\)/);
+		assert.match(implementationText, /- Advisory only: no subagent was launched\. To proceed, explicitly call subagent with this canonical agent name and the task\./);
+
+		const review = handleManagementAction("list", { task: "Review only; do not edit files" }, ctx);
+		assert.equal(review.isError, false);
+		const reviewText = readText(review);
+		assert.match(reviewText, /- Intent: read-only/);
+		assert.match(reviewText, /- Recommended: code-reviewer \(project\)/);
+
+		const vague = handleManagementAction("list", { task: "Look into this" }, ctx);
+		assert.equal(vague.isError, false);
+		const vagueText = readText(vague);
+		assert.match(vagueText, /- Intent: unknown/);
+		assert.match(vagueText, /- Recommendation: none/);
+		assert.match(vagueText, /Clarify whether the task is read-only analysis\/review or implementation allowed to edit files\./);
+
+		for (const noTaskParams of [{}, { task: "   " }]) {
+			const noTask = handleManagementAction("list", noTaskParams, ctx);
+			assert.equal(noTask.isError, false);
+			assert.doesNotMatch(readText(noTask), /Task-aware advisory routing:/);
+		}
+	});
+
 });

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

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { afterEach, beforeEach, describe, it } from "node:test";
-import { buildBuiltinOverrideConfig, discoverAgents, discoverAgentsAll, removeBuiltinAgentOverride } from "../../src/agents/agents.ts";
+import { buildBuiltinOverrideConfig, discoverAgents, discoverAgentsAll, removeBuiltinAgentOverride, saveBuiltinAgentOverride } from "../../src/agents/agents.ts";
 
 let tempHome = "";
 let tempProject = "";
@@ -178,6 +178,22 @@ describe("builtin agent overrides", () => {
 		assert.equal(agents.find((agent) => agent.name === "architect-copy")?.model, "deepseek-v4-flash");
 	});
 
+	it("overrides builtin and custom agent descriptions from settings", () => {
+		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
+			subagents: {
+				agentOverrides: {
+					commentator: { description: " Priced commentator " },
+					implementer: { description: "Priced implementer" },
+				},
+			},
+		});
+		writeProjectAgent(tempProject, "implementer", `---\nname: implementer\ndescription: Original implementer\n---\n\nImplement it.\n`);
+
+		const agents = discoverAgents(tempProject, "both").agents;
+		assert.equal(agents.find((agent) => agent.name === "commentator")?.description, "Priced commentator");
+		assert.equal(agents.find((agent) => agent.name === "implementer")?.description, "Priced implementer");
+	});
+
 	it("applies user settings overrides to builtin agents", () => {
 		writeJson(path.join(tempHome, ".selesai", "agent", "settings.json"), {
 			subagents: {
@@ -625,6 +641,22 @@ describe("builtin agent overrides", () => {
 		);
 	});
 
+	it("surfaces malformed description override values", () => {
+		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
+		for (const description of ["", 42]) {
+			writeJson(settingsPath, {
+				subagents: { agentOverrides: { commentator: { description } } },
+			});
+			assert.throws(
+				() => discoverAgents(tempProject, "both"),
+				(error: unknown) => error instanceof Error
+					&& error.message.includes(settingsPath)
+					&& error.message.includes("commentator")
+					&& error.message.includes("description"),
+			);
+		}
+	});
+
 	it("surfaces malformed completion guard override values", () => {
 		const settingsPath = path.join(tempHome, ".selesai", "agent", "settings.json");
 		writeJson(settingsPath, {
@@ -646,9 +678,10 @@ describe("builtin agent overrides", () => {
 		);
 	});
 
-	it("builds false sentinels when an override clears builtin fields", () => {
+	it("builds description changes and false sentinels when an override clears builtin fields", () => {
 		const override = buildBuiltinOverrideConfig(
 			{
+				description: "Base description",
 				model: "openai-codex/gpt-5.4-mini",
 				fallbackModels: ["openai/gpt-5-mini"],
 				thinking: "high",
@@ -665,6 +698,7 @@ describe("builtin agent overrides", () => {
 				completionGuard: false,
 			},
 			{
+				description: "Override description",
 				model: undefined,
 				fallbackModels: undefined,
 				thinking: undefined,
@@ -683,6 +717,7 @@ describe("builtin agent overrides", () => {
 		);
 
 		assert.deepEqual(override, {
+			description: "Override description",
 			model: false,
 			fallbackModels: false,
 			thinking: false,
@@ -695,5 +730,15 @@ describe("builtin agent overrides", () => {
 			subagentOnlyExtensions: false,
 			completionGuard: true,
 		});
+		assert.ok(override);
+		fs.mkdirSync(path.join(tempProject, ".selesai"), { recursive: true });
+		saveBuiltinAgentOverride(tempProject, "commentator", "project", override);
+		assert.equal(discoverAgents(tempProject, "both").agents.find((agent) => agent.name === "commentator")?.description, "Override description");
+
+		const whitespaceDescription = buildBuiltinOverrideConfig(
+			{ description: "Base description" },
+			{ description: "   " } as Parameters<typeof buildBuiltinOverrideConfig>[1],
+		);
+		assert.equal(whitespaceDescription, undefined);
 	});
 });

package/dist/extensions/pi-subagents/test/unit/async-recovery-descriptor.test.ts

@@ -0,0 +1,60 @@
+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 { readAsyncRecoveryDescriptor } from "../../src/runs/background/async-resume.ts";
+
+describe("async recovery descriptor", () => {
+	it("accepts launchContractDigest written by async execution", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-digest-"));
+		try {
+			const digest = "launch-contract-digest";
+			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+				version: 1,
+				launchContractDigest: digest,
+				sourceRunId: "run-digest",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+				outputMode: "inline",
+				maxSubagentDepth: 2,
+				share: false,
+			}), "utf-8");
+
+			const descriptor = readAsyncRecoveryDescriptor(root);
+
+			assert.equal(descriptor?.launchContractDigest, digest);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+
+	it("rejects malformed launchContractDigest values", () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-async-recovery-bad-digest-"));
+		try {
+			fs.writeFileSync(path.join(root, "recovery-descriptor.json"), JSON.stringify({
+				version: 1,
+				launchContractDigest: {},
+				sourceRunId: "run-digest",
+				agent: "worker",
+				cwd: root,
+				systemPromptMode: "replace",
+				inheritProjectContext: false,
+				inheritSkills: false,
+				outputMode: "inline",
+				maxSubagentDepth: 2,
+				share: false,
+			}), "utf-8");
+
+			assert.throws(
+				() => readAsyncRecoveryDescriptor(root),
+				/launchContractDigest must be a non-empty string/,
+			);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/pi-subagents/test/unit/async-resume.test.ts

@@ -109,6 +109,14 @@ describe("async resume lookup", () => {
 			});
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /capabilityCeiling sources/);
 
+			writeJson(path.join(asyncDir, "recovery-descriptor.json"), {
+				...descriptor,
+				launchContractDigest: "launch-contract-digest",
+			});
+			const valid = resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir });
+			assert.equal(valid.launchContractDigest, "launch-contract-digest");
+			assert.equal(valid.recoveryDescriptor?.launchContractDigest, "launch-contract-digest");
+
 			writeJson(path.join(asyncDir, "recovery-descriptor.json"), { ...descriptor, sourceRunId: "another-run" });
 			assert.throws(() => resolveAsyncResumeTarget({ id: "run-descriptor" }, { asyncDirRoot: asyncRoot, resultsDir }), /different source run/);
 

package/dist/extensions/pi-subagents/test/unit/builtin-agent-documentation.test.ts

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { BUILTIN_AGENT_NAMES } from "../../src/agents/agents.ts";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+
+const README_PATH = path.join(packageRoot, "README.md");
+const PROMPTING_AND_ROLES_PATH = path.join(packageRoot, "skills", "pi-subagents", "references", "prompting-and-roles.md");
+
+const README_TABLE_HEADING = "## Builtin agents in plain English";
+const PROMPTING_AND_ROLES_TABLE_HEADING = "## Builtin Agents";
+
+/**
+ * Extracts the first-column agent names from every table row under the given
+ * markdown section heading. Skips the header row and the separator row.
+ */
+function tableFirstColumnNames(markdown: string, sectionHeading: string): string[] {
+	const lines = markdown.split(/\r?\n/);
+	const headingIndex = lines.findIndex((line) => line.trim() === sectionHeading);
+	assert.ok(headingIndex >= 0, `missing section heading: ${sectionHeading}`);
+
+	const names: string[] = [];
+	for (let i = headingIndex + 1; i < lines.length; i++) {
+		const line = lines[i]!.trim();
+		if (line.startsWith("#")) break;
+		if (!line.startsWith("|")) continue;
+
+		const cells = line.split("|").map((cell) => cell.trim());
+		const firstCell = (cells[1] ?? "").replaceAll("`", "").trim();
+		if (firstCell === "Agent") continue;
+		if (/^:?-+:?$/.test(firstCell)) continue;
+		if (firstCell.length === 0) continue;
+		names.push(firstCell);
+	}
+	return names;
+}
+
+function assertExactlySixBuiltins(tablePath: string, heading: string, markdown: string): void {
+	const names = tableFirstColumnNames(markdown, heading);
+
+	assert.equal(names.length, 6, `${path.basename(tablePath)}: role table must contain exactly six builtin rows`);
+	assert.equal(new Set(names).size, names.length, `${path.basename(tablePath)}: role table contains duplicate rows`);
+	assert.deepEqual(
+		[...names].sort(),
+		[...BUILTIN_AGENT_NAMES].sort(),
+		`${path.basename(tablePath)}: role table must list exactly ${BUILTIN_AGENT_NAMES.join(", ")} once each, with no aliases`,
+	);
+}
+
+describe("builtin agent documentation role tables", () => {
+	it("README lists exactly the six canonical builtins once, with no duplicates or aliases", () => {
+		const markdown = fs.readFileSync(README_PATH, "utf-8");
+		assertExactlySixBuiltins(README_PATH, README_TABLE_HEADING, markdown);
+	});
+
+	it("prompting-and-roles reference lists exactly the six canonical builtins once, with no duplicates or aliases", () => {
+		const markdown = fs.readFileSync(PROMPTING_AND_ROLES_PATH, "utf-8");
+		assertExactlySixBuiltins(PROMPTING_AND_ROLES_PATH, PROMPTING_AND_ROLES_TABLE_HEADING, markdown);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling-agent-allowlist.test.ts

@@ -0,0 +1,136 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { handleList } from "../../src/agents/agent-management.ts";
+import type { AgentConfig } from "../../src/agents/agents.ts";
+import { resolveSubagentLaunchContract } from "../../src/api/preflight.ts";
+import {
+	decodeSubagentCapabilityCeiling,
+	encodeSubagentCapabilityCeiling,
+	intersectSubagentCapabilityCeilings,
+	parseSubagentCapabilityCeiling,
+	registerSubagentCapabilityCeiling,
+} from "../../src/api/capability-ceiling.ts";
+import { runSync } from "../../src/runs/foreground/execution.ts";
+import { buildPiArgs } from "../../src/runs/shared/pi-args.ts";
+
+function agent(name: string): AgentConfig {
+	return {
+		name,
+		description: `${name} agent`,
+		systemPrompt: `${name} prompt`,
+		systemPromptMode: "replace",
+		inheritProjectContext: false,
+		inheritSkills: false,
+		source: "project",
+		filePath: `/tmp/${name}.md`,
+	};
+}
+
+describe("capability ceiling agent allowlist", () => {
+	it("parses, round-trips, and intersects allowedAgents", () => {
+		const parsed = parseSubagentCapabilityCeiling({ version: 1, allowedAgents: ["worker", "reviewer", "worker"], denyExtensions: false, sources: ["plan"] });
+		assert.deepEqual(parsed.allowedAgents, ["reviewer", "worker"]);
+		assert.deepEqual(decodeSubagentCapabilityCeiling(encodeSubagentCapabilityCeiling(parsed)), parsed);
+
+		assert.deepEqual(intersectSubagentCapabilityCeilings(
+			{ version: 1, allowedAgents: ["worker", "reviewer"], denyExtensions: false, sources: ["outer"] },
+			{ version: 1, allowedAgents: ["reviewer", "scout"], denyExtensions: true, sources: ["inner"] },
+		), {
+			version: 1,
+			allowedAgents: ["reviewer"],
+			denyExtensions: true,
+			sources: ["inner", "outer"],
+		});
+
+		assert.deepEqual(intersectSubagentCapabilityCeilings(
+			{ version: 1, allowedTools: ["read"], denyExtensions: false, sources: ["tools-only"] },
+			{ version: 1, allowedAgents: [], denyExtensions: false, sources: ["none"] },
+		)?.allowedAgents, []);
+	});
+
+	it("marks non-allowlisted agents as restricted in list output", () => {
+		const sessionId = `allowlist-list-${Date.now()}-${Math.random()}`;
+		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["commentator"] } });
+		try {
+			const result = handleList({}, { cwd: process.cwd(), currentSessionId: sessionId, modelRegistry: { getAvailable: () => [] } });
+			const text = result.content[0]?.text ?? "";
+			assert.match(text, /Executable agents:/);
+			assert.match(text, /- commentator /);
+			assert.match(text, /Restricted agents \(not executable in this session; capability ceiling: plan-mode\):/);
+			assert.match(text, /- builder /);
+
+			const catalog = (result as { details: { catalog?: unknown } }).details.catalog as
+				| undefined
+				| {
+					version: number;
+					agents: Array<{ name: string; executable: boolean; restrictionSources?: string[]; defaultContext: string }>;
+					capabilityCeilingSources?: string[];
+				};
+			assert.ok(catalog, "list result must include machine catalog metadata");
+			assert.equal(catalog.version, 1);
+			assert.deepEqual(catalog.capabilityCeilingSources, ["plan-mode"]);
+			const commentator = catalog.agents.find((entry) => entry.name === "commentator");
+			const builder = catalog.agents.find((entry) => entry.name === "builder");
+			assert.equal(commentator?.executable, true);
+			assert.equal(commentator?.restrictionSources, undefined);
+			assert.equal(commentator?.defaultContext, "fresh");
+			assert.equal(builder?.executable, false);
+			assert.deepEqual(builder?.restrictionSources, ["plan-mode"]);
+		} finally {
+			handle.dispose();
+		}
+	});
+
+	it("never recommends a capability-restricted writer for implementation list task advice", () => {
+		const sessionId = `allowlist-advice-${Date.now()}-${Math.random()}`;
+		const handle = registerSubagentCapabilityCeiling({ sessionId, source: "plan-mode", ceiling: { allowedAgents: ["commentator"] } });
+		try {
+			const result = handleList({ task: "Implement the fix" }, { cwd: process.cwd(), currentSessionId: sessionId, modelRegistry: { getAvailable: () => [] } });
+			assert.equal(result.isError, false);
+			const text = result.content[0]?.text ?? "";
+			assert.match(text, /Task-aware advisory routing:/);
+			assert.match(text, /- Intent: implementation/);
+			assert.match(text, /- Recommendation: none/);
+			assert.doesNotMatch(text, /- Recommended: /);
+		} finally {
+			handle.dispose();
+		}
+	});
+
+	it("rejects a non-allowlisted agent in preflight launch resolution", async () => {
+		const result = await resolveSubagentLaunchContract({
+			agent: "builder",
+			cwd: process.cwd(),
+			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], denyExtensions: false, sources: ["plan-mode"] },
+		});
+		assert.equal(result.ok, false);
+		assert.equal(result.code, "restricted_agent");
+		assert.match(result.message, /does not allow agent 'builder'/);
+		assert.match(result.message, /Allowed agents: commentator/);
+	});
+
+	it("rejects a non-allowlisted foreground launch before spawning", async () => {
+		const result = await runSync(process.cwd(), [agent("builder"), agent("commentator")], "builder", "Do work", {
+			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], denyExtensions: false, sources: ["plan-mode"] },
+		});
+		assert.equal(result.exitCode, 1);
+		assert.match(result.error ?? "", /does not allow agent 'builder'/);
+		assert.deepEqual(result.capabilityCeiling?.allowedAgents, ["commentator"]);
+	});
+
+	it("includes allowedAgents in propagated launch env and audit metadata", () => {
+		const { env, capabilityAudit } = buildPiArgs({
+			baseArgs: [],
+			task: "Review",
+			sessionEnabled: false,
+			inheritProjectContext: false,
+			inheritSkills: false,
+			childAgentName: "commentator",
+			capabilityCeiling: { version: 1, allowedAgents: ["commentator"], allowedTools: ["read"], denyExtensions: true, sources: ["plan-mode"] },
+		});
+		assert.equal(capabilityAudit?.agentAllowed, true);
+		assert.deepEqual(capabilityAudit?.agentRestrictionSources, ["plan-mode"]);
+		assert.ok(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1);
+		assert.deepEqual(decodeSubagentCapabilityCeiling(env.SELESAI_SUBAGENT_CAPABILITY_CEILING_V1)?.allowedAgents, ["commentator"]);
+	});
+});

package/dist/extensions/pi-subagents/test/unit/capability-ceiling.test.ts

@@ -33,7 +33,7 @@ describe("subagent capability ceiling", () => {
 	});
 
 	it("rejects malformed policy and disposed updates", () => {
-		assert.throws(() => registerSubagentCapabilityCeiling({ sessionId: "x", source: "x", ceiling: {} }), /allowedTools or denyExtensions/);
+		assert.throws(() => registerSubagentCapabilityCeiling({ sessionId: "x", source: "x", ceiling: {} }), /allowedTools, allowedAgents, or denyExtensions/);
 		const handle = registerSubagentCapabilityCeiling({ sessionId: "disposed", source: "test", ceiling: { denyExtensions: true } });
 		handle.dispose();
 		assert.throws(() => handle.update({ allowedTools: ["read"] }), /disposed/);

package/dist/extensions/pi-subagents/test/unit/chain-append.test.ts

@@ -198,6 +198,12 @@ describe("chain append requests", () => {
 			"reviewer:pending",
 			"auditor:pending",
 		]);
+		// Appended steps must carry their own bounded task description for fleet display.
+		assert.deepEqual(status.steps?.slice(1).map((step) => step.description), [
+			"Use {previous}",
+			"Use {previous}",
+			"Use {previous}",
+		]);
 		assert.deepEqual(status.parallelGroups, [{ start: 2, count: 2, stepIndex: 2 }]);
 		assert.equal(status.workflowGraph?.nodes[1]?.id, "step-1");
 		assert.equal(status.workflowGraph?.nodes[2]?.kind, "parallel-group");

package/dist/extensions/pi-subagents/test/unit/chain-validation.test.ts

@@ -285,7 +285,7 @@ describe("registered subagent tool prepareArguments", { skip: !schemasAvailable
 		const output = execFileSync(
 			process.execPath,
 			[
-				"--experimental-transform-types",
+				"--experimental-strip-types",
 				"--import",
 				"./test/support/register-loader.mjs",
 				"--input-type=module",