@selesai/code 0.6.3 → 0.8.0

package/dist/extensions/pi-subagents/test/unit/index-child-registration.test.ts

@@ -71,7 +71,7 @@ describe("subagent extension child mode", () => {
 		);
 	});
 
-	it("does not show async badge for explicit foreground clarify chain calls", () => {
+	it("renders only the public single and workflow execution modes", () => {
 		const script = String.raw`
 			import registerSubagentExtension from "./index.ts";
 			const events = { on() { return () => {}; }, emit() {} };
@@ -79,26 +79,95 @@ describe("subagent extension child mode", () => {
 			const fakePi = new Proxy({
 				events,
 				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
-				registerCommand() {},
-				registerShortcut() {},
-				registerMessageRenderer() {},
-				sendMessage() {},
-				getSessionName() { return undefined; },
-			}, {
-				get(target, prop) {
-					if (prop in target) return target[prop];
-					return () => undefined;
-				},
-			});
+				registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
 			registerSubagentExtension(fakePi);
 			if (!registeredTool) throw new Error("tool not registered");
 			const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
-			const asyncChain = registeredTool.renderCall({ chain: [{ agent: "worker" }, { agent: "reviewer" }], async: true }, theme).text;
-			const asyncParallel = registeredTool.renderCall({ tasks: [{ agent: "worker" }, { agent: "reviewer", count: 2 }], async: true }, theme).text;
-			const clarifyChain = registeredTool.renderCall({ chain: [{ agent: "worker" }, { agent: "reviewer" }], async: true, clarify: true }, theme).text;
-			if (!asyncChain.includes("[async]")) throw new Error("expected async chain badge, got " + asyncChain);
-			if (!asyncParallel.includes("parallel (3) [async]")) throw new Error("expected async parallel badge, got " + asyncParallel);
-			if (clarifyChain.includes("[async]")) throw new Error("unexpected clarify async badge: " + clarifyChain);
+			const single = registeredTool.renderCall({ agent: "builder", async: true }, theme).text;
+			const workflow = registeredTool.renderCall({
+				workflowScript: "const scan = await runs.run('scan', {agent:'builder'}); return runs.all([{key:'correctness',agent:'commentator'},{key:'tests',agent:'commentator'}]);",
+			}, theme).text;
+			const foregroundWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run('publish', {agent:'builder'});", async: false }, theme).text;
+			const clarifiedWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run('clarify', {agent:'builder'});", async: true, clarify: true }, theme).text;
+			const templateWorkflow = registeredTool.renderCall({ workflowScript: "return runs.run(\`template\`, {agent:'builder'});", async: false }, theme).text;
+			const commentedWorkflow = registeredTool.renderCall({ workflowScript: "// runs.run('ignored', {agent:'builder'})\nconst note = \"key: 'also-ignored'\"; return runs.run('real', {agent:'builder'});" }, theme).text;
+			const dynamicKeyWorkflow = registeredTool.renderCall({ workflowScript: "return runs.all([{key: 'review-' + item, agent: 'commentator'}]);" }, theme).text;
+			const ordinaryKeyWorkflow = registeredTool.renderCall({ workflowScript: "const config = {key: 'secret'}; return runs.all([{agent: 'commentator', config: {key: 'nested'}, key: 'review'}]);" }, theme).text;
+			if (!single.includes("builder [async]")) throw new Error("expected async single badge, got " + single);
+			if (!workflow.includes("background · 3 lanes: scan, correctness, tests")) throw new Error("expected workflow manifest, got " + workflow);
+			if (!foregroundWorkflow.includes("foreground · 1 lane: publish")) throw new Error("expected foreground workflow manifest, got " + foregroundWorkflow);
+			if (!clarifiedWorkflow.includes("rejected: clarify UI unsupported")) throw new Error("expected clarified workflow rejection, got " + clarifiedWorkflow);
+			if (!templateWorkflow.includes("foreground · 1 lane: template")) throw new Error("expected static template lane, got " + templateWorkflow);
+			if (!commentedWorkflow.includes("background · 1 lane: real")) throw new Error("expected lexical lane filtering, got " + commentedWorkflow);
+			if (!dynamicKeyWorkflow.includes("workflow script · background")) throw new Error("expected dynamic key fallback, got " + dynamicKeyWorkflow);
+			if (!ordinaryKeyWorkflow.includes("background · 1 lane: review") || ordinaryKeyWorkflow.includes("secret") || ordinaryKeyWorkflow.includes("nested")) throw new Error("expected only runs.all child key, got " + ordinaryKeyWorkflow);
+		`;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
+	});
+
+	it("shows omitted workflow async as background even when asyncByDefault is false", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-workflow-manifest-config-"));
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ asyncByDefault: false, forceTopLevelAsync: true }), "utf-8");
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				let registeredTool;
+				const fakePi = new Proxy({
+					events, registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+					registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
+				const result = registeredTool.renderCall({
+					workflowScript: "return runs.run('scan' /* stable lane */, {agent:'builder'});",
+				}, theme).text;
+				const explicitForeground = registeredTool.renderCall({
+					workflowScript: "return runs.run('publish', {agent:'builder'});",
+					async: false,
+				}, theme).text;
+				if (!result.includes("background · 1 lane: scan")) throw new Error("expected workflow executor background manifest, got " + result);
+				if (!explicitForeground.includes("foreground · 1 lane: publish")) throw new Error("expected workflow executor foreground manifest, got " + explicitForeground);
+			`;
+			const env = parentToolEnv();
+			env.SELESAI_CODING_AGENT_DIR = agentDir;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
+	it("keeps registered tool errors actionable while successful results stay collapsed", () => {
+		const script = String.raw`
+			import registerSubagentExtension from "./index.ts";
+			const events = { on() { return () => {}; }, emit() {} };
+			let registeredTool;
+			const fakePi = new Proxy({
+				events,
+				registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+				registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage() {}, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			registerSubagentExtension(fakePi);
+			if (!registeredTool) throw new Error("tool not registered");
+
+			const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
+			const render = (text, isError) => registeredTool.renderResult({
+				content: [{ type: "text", text }],
+				details: { mode: "management", results: [] },
+			}, { expanded: false }, theme, { isError, state: {} }).render(120).join("\n");
+
+			const error = render("Agent configuration is invalid.\nSet tools to an array.\nRetry the subagent call.", true);
+			if (!error.includes("Set tools to an array.")) throw new Error("error remediation was hidden: " + error);
+			if (!error.includes("Retry the subagent call.")) throw new Error("error retry guidance was hidden: " + error);
+			if (error.includes("3 lines")) throw new Error("error was collapsed: " + error);
+
+			const success = render("Managed agents:\n- commentator\n- writer", false);
+			if (!success.includes("Managed agents: · 3 lines")) throw new Error("success summary was not collapsed: " + success);
+			if (success.includes("- commentator") || success.includes("- writer")) throw new Error("success details were not collapsed: " + success);
 		`;
 
 		execFileSync(
@@ -139,9 +208,9 @@ describe("subagent extension child mode", () => {
 				details: {
 					mode: "single",
 					results: [{
-						agent: "worker", task: "quiet", exitCode: 0, messages: [],
+						agent: "builder", task: "quiet", exitCode: 0, messages: [],
 						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-						progress: { status: "running", index: 0, agent: "worker", toolCount: 0, tokens: 0, durationMs: 0 },
+						progress: { status: "running", index: 0, agent: "builder", toolCount: 0, tokens: 0, durationMs: 0 },
 					}],
 				},
 			}, { expanded: false }, { fg(_name, text) { return text; }, bold(text) { return text; } }, context);
@@ -166,6 +235,88 @@ describe("subagent extension child mode", () => {
 		);
 	});
 
+	it("keeps summary inline tool display to one stable row for every supported state", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-inline-display-config-"));
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ inlineToolDisplay: "summary" }), "utf-8");
+
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				const events = { on() { return () => {}; }, emit() {} };
+				let registeredTool;
+				const fakePi = new Proxy({
+					events,
+					registerTool(tool) { if (tool.name === "subagent") registeredTool = tool; },
+					registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {}, sendMessage() {}, getSessionName() {},
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				registerSubagentExtension(fakePi);
+				if (!registeredTool) throw new Error("tool not registered");
+				const theme = { fg(_name, text) { return text; }, bold(text) { return text; } };
+				const base = {
+					agent: "explorer", task: "quiet", messages: [],
+					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
+				};
+				const running = registeredTool.renderResult({
+					content: [{ type: "text", text: "partial output that must not appear" }],
+					details: { mode: "single", results: [{ ...base, exitCode: 0, progress: { status: "running", index: 0, agent: "explorer", toolCount: 2, tokens: 300, durationMs: 20_000 } }] },
+				}, { expanded: false, isPartial: true }, theme, { state: {} }).render(120);
+				const asyncSingle = registeredTool.renderResult({
+					content: [{ type: "text", text: "Async: explorer [single-run]" }],
+					details: { mode: "single", runId: "single-run", asyncId: "single-run", asyncDir: "/tmp/single-run", results: [] },
+				}, { expanded: false }, theme, { state: {} }).render(120);
+				const asyncChain = registeredTool.renderResult({
+					content: [{ type: "text", text: "Async chain [chain-run]" }],
+					details: { mode: "chain", runId: "chain-run", asyncId: "chain-run", asyncDir: "/tmp/chain-run", results: [] },
+				}, { expanded: false }, theme, { state: {} }).render(120);
+				const completed = registeredTool.renderResult({
+					content: [{ type: "text", text: "completed output that must not appear" }],
+					details: { mode: "single", results: [{ ...base, exitCode: 0 }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const stopped = registeredTool.renderResult({
+					content: [{ type: "text", text: "cancelled output that must not appear" }],
+					details: { mode: "single", results: [{ ...base, exitCode: 1, stopped: true, error: "Cancelled by user" }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const paused = registeredTool.renderResult({
+					content: [{ type: "text", text: "paused output that must not appear" }],
+					details: { mode: "single", results: [{ ...base, exitCode: 1, interrupted: true }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const failed = registeredTool.renderResult({
+					content: [{ type: "text", text: "failed output that must not appear" }],
+					details: { mode: "single", results: [{ ...base, exitCode: 1, stopped: false }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const failedWithPaused = registeredTool.renderResult({
+					content: [{ type: "text", text: "aggregate output that must not appear" }],
+					details: { mode: "parallel", results: [{ ...base, agent: "paused", exitCode: 1, interrupted: true }, { ...base, agent: "failed", exitCode: 1, stopped: false }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const failedWithStopped = registeredTool.renderResult({
+					content: [{ type: "text", text: "aggregate output that must not appear" }],
+					details: { mode: "parallel", results: [{ ...base, agent: "stopped", exitCode: 1, stopped: true }, { ...base, agent: "failed", exitCode: 1, stopped: false }] },
+				}, { expanded: true, isPartial: false }, theme, { state: {} }).render(120);
+				const contextError = registeredTool.renderResult({
+					content: [{ type: "text", text: "Agent configuration is invalid." }],
+					details: { mode: "management", results: [] },
+				}, { expanded: false, isPartial: false }, theme, { isError: true, state: {} }).render(120);
+				if (running.length !== 1 || running[0] !== "● explorer · running") throw new Error("unexpected running summary: " + JSON.stringify(running));
+				if (asyncSingle.length !== 1 || asyncSingle[0] !== "● single · running") throw new Error("unexpected async single summary: " + JSON.stringify(asyncSingle));
+				if (asyncChain.length !== 1 || asyncChain[0] !== "● chain · running") throw new Error("unexpected async chain summary: " + JSON.stringify(asyncChain));
+				if (completed.length !== 1 || completed[0] !== "✓ explorer · completed") throw new Error("unexpected completed summary: " + JSON.stringify(completed));
+				if (stopped.length !== 1 || stopped[0] !== "■ explorer · stopped") throw new Error("unexpected stopped summary: " + JSON.stringify(stopped));
+				if (paused.length !== 1 || paused[0] !== "■ explorer · paused") throw new Error("unexpected paused summary: " + JSON.stringify(paused));
+				if (failed.length !== 1 || failed[0] !== "✗ explorer · failed") throw new Error("unexpected failed summary: " + JSON.stringify(failed));
+				if (failedWithPaused.length !== 1 || failedWithPaused[0] !== "✗ parallel · failed") throw new Error("unexpected paused aggregate summary: " + JSON.stringify(failedWithPaused));
+				if (failedWithStopped.length !== 1 || failedWithStopped[0] !== "✗ parallel · failed") throw new Error("unexpected stopped aggregate summary: " + JSON.stringify(failedWithStopped));
+				if (contextError.length !== 1 || contextError[0] !== "✗ management · failed") throw new Error("unexpected context error summary: " + JSON.stringify(contextError));
+			`;
+			const env = parentToolEnv();
+			env.SELESAI_CODING_AGENT_DIR = agentDir;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
 	it("registers only subagent_wait and honors waitTool disabled config", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-wait-tool-config-"));
 		try {
@@ -249,7 +400,7 @@ describe("subagent extension child mode", () => {
 				registerSubagentExtension(fakePi);
 				handlers.get("session_start")({}, ctx);
 				widgets.length = 0;
-				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "single", agent: "worker", asyncDir: "/tmp/widget-run" });
+				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "single", agent: "builder", asyncDir: "/tmp/widget-run" });
 				handlers.get("tool_result")({ toolName: "subagent" }, ctx);
 				const asyncWidgets = widgets.filter((entry) => entry.key === "subagent-async");
 				if (asyncWidgets.length < 2 || asyncWidgets.some((entry) => entry.value !== undefined)) throw new Error("async widget rendered despite disabled config: " + JSON.stringify(asyncWidgets));
@@ -257,12 +408,96 @@ describe("subagent extension child mode", () => {
 			`;
 			const env = parentToolEnv();
 			env.SELESAI_CODING_AGENT_DIR = agentDir;
-			execFileSync(process.execPath, ["--experimental-transform-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
 		} finally {
 			fs.rmSync(agentDir, { recursive: true, force: true });
 		}
 	});
 
+	it("shows active async work in the under-editor widget when FleetView is enabled", () => {
+		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-async-widget-fleet-"));
+		try {
+			const configDir = path.join(agentDir, "extensions", "subagent");
+			fs.mkdirSync(configDir, { recursive: true });
+			fs.writeFileSync(path.join(configDir, "config.json"), JSON.stringify({ fleetView: true }), "utf-8");
+			const script = String.raw`
+				import registerSubagentExtension from "./index.ts";
+				const eventHandlers = new Map();
+				const handlers = new Map();
+				const events = { on(channel, handler) { eventHandlers.set(channel, handler); return () => {}; }, emit() {} };
+				const fakePi = new Proxy({
+					events,
+					on(channel, handler) { handlers.set(channel, handler); },
+					registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+					sendMessage() {}, getSessionName() { return undefined; },
+				}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+				const widgets = [];
+				const ctx = {
+					cwd: process.cwd(), hasUI: true,
+					ui: { setWidget(key, value) { widgets.push({ key, value }); }, requestRender() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } },
+					sessionManager: { getSessionId() { return "session-widget"; }, getSessionFile() { return null; }, getEntries() { return []; } },
+					modelRegistry: { getAvailable() { return []; } },
+				};
+				registerSubagentExtension(fakePi);
+				handlers.get("session_start")({}, ctx);
+				widgets.length = 0;
+				eventHandlers.get("subagent:async-started")({ id: "widget-run", pid: 1, sessionId: "session-widget", mode: "workflow", agent: "builder", asyncDir: "/tmp/widget-run" });
+				handlers.get("tool_result")({ toolName: "subagent" }, ctx);
+				const asyncWidgets = widgets.filter((entry) => entry.key === "subagent-async");
+				if (!asyncWidgets.some((entry) => entry.value !== undefined)) throw new Error("async widget was not rendered with FleetView enabled: " + JSON.stringify(asyncWidgets));
+				handlers.get("session_shutdown")();
+			`;
+			const env = parentToolEnv();
+			env.SELESAI_CODING_AGENT_DIR = agentDir;
+			execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
+		} finally {
+			fs.rmSync(agentDir, { recursive: true, force: true });
+		}
+	});
+
+	it("restores disk-backed active status after a management tool result", () => {
+		const script = String.raw`
+			import * as fs from "node:fs";
+			import * as path from "node:path";
+			import registerSubagentExtension from "./index.ts";
+			import { DIRS } from "./src/shared/types.ts";
+			const eventHandlers = new Map();
+			const handlers = new Map();
+			const events = { on(channel, handler) { eventHandlers.set(channel, handler); return () => {}; }, emit() {} };
+			const widgets = [];
+			const fakePi = new Proxy({
+				events,
+				on(channel, handler) { handlers.set(channel, handler); },
+				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
+				sendMessage() {}, getSessionName() { return undefined; },
+			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
+			const runId = "management-refresh-" + crypto.randomUUID();
+			const sessionId = "session-" + runId;
+			const ctx = {
+				cwd: process.cwd(), hasUI: true,
+				ui: { setWidget(key, value) { widgets.push({ key, value }); }, requestRender() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } },
+				sessionManager: { getSessionId() { return sessionId; }, getSessionFile() { return null; }, getEntries() { return []; } },
+				modelRegistry: { getAvailable() { return []; } },
+			};
+			const asyncDir = path.join(DIRS.async, runId);
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+			registerSubagentExtension(fakePi);
+			handlers.get("session_start")({}, ctx);
+			widgets.length = 0;
+			fs.mkdirSync(asyncDir, { recursive: true });
+			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
+				runId, sessionId, mode: "workflow", state: "running",
+				startedAt: Date.now(), lastUpdate: Date.now(), cwd: process.cwd(), pid: process.pid,
+			}), "utf-8");
+			handlers.get("tool_result")({ toolName: "subagent" }, ctx);
+			const fleetWidgets = widgets.filter((entry) => entry.key === "subagent-fleet-status");
+			if (!fleetWidgets.some((entry) => typeof entry.value === "function")) throw new Error("management result did not restore active fleet status: " + JSON.stringify(fleetWidgets));
+			handlers.get("session_shutdown")();
+			fs.rmSync(asyncDir, { recursive: true, force: true });
+		`;
+		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env: parentToolEnv(), stdio: "pipe" });
+	});
+
 	it("disposes pending completion notifications on session shutdown", () => {
 		const agentDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagents-notify-shutdown-"));
 		const configDir = path.join(agentDir, "extensions", "subagent");
@@ -309,7 +544,7 @@ describe("subagent extension child mode", () => {
 			handlers.get("session_start")({}, ctx);
 			sent.length = 0;
 			events.emit("subagent:async-complete", {
-				id: "shutdown-held-completion", agent: "worker", success: true, summary: "Done",
+				id: "shutdown-held-completion", agent: "builder", success: true, summary: "Done",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-shutdown-session",
 			});
 			if (sent.length !== 0) throw new Error("completion was not queued before shutdown");
@@ -387,7 +622,7 @@ describe("subagent extension child mode", () => {
 			oldRuntime.sent.length = 0;
 			const timersBeforeOldCompletion = new Set(pendingTimers.keys());
 			oldRuntime.events.emit("subagent:async-complete", {
-				id: "reload-held-completion", agent: "worker", success: true, summary: "Old",
+				id: "reload-held-completion", agent: "builder", success: true, summary: "Old",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-reload-old",
 			});
 			if (oldRuntime.sent.length !== 0) throw new Error("old completion was not queued before reload");
@@ -402,7 +637,7 @@ describe("subagent extension child mode", () => {
 
 			const timersBeforeNewCompletion = new Set(pendingTimers.keys());
 			newRuntime.events.emit("subagent:async-complete", {
-				id: "reload-new-completion", agent: "reviewer", success: true, summary: "New",
+				id: "reload-new-completion", agent: "commentator", success: true, summary: "New",
 				exitCode: 0, timestamp: Date.now(), sessionId: "notify-reload-new",
 			});
 			const newCompletionTimers = [...pendingTimers.entries()].filter(([token]) => !timersBeforeNewCompletion.has(token));
@@ -599,19 +834,14 @@ describe("subagent extension child mode", () => {
 			};
 			registerFanoutChildSubagentExtension(fakePi);
 			if (!registeredTool) throw new Error("tool not registered");
-			if (registeredTool.promptGuidelines !== undefined) {
-				throw new Error("child-safe fanout tool must not carry parent-only routing promptGuidelines");
-			}
 			const ctx = {
 				cwd: process.cwd(),
 				hasUI: false,
 				sessionManager: { getSessionId() { return "session-test"; }, getSessionFile() { return null; } },
 				modelRegistry: { getAvailable() { return []; } },
 			};
-			const list = await registeredTool.execute("list-check", { action: "list", task: "Review only; do not edit files" }, new AbortController().signal, undefined, ctx);
+			const list = await registeredTool.execute("list-check", { action: "list" }, new AbortController().signal, undefined, ctx);
 			if (list.isError) throw new Error("list should be allowed: " + JSON.stringify(list.content));
-			const listText = list.content?.[0]?.text ?? "";
-			if (!listText.includes("Task-aware advisory routing:")) throw new Error("list task advice missing in child mode: " + listText.slice(0, 200));
 			const create = await registeredTool.execute("create-check", { action: "create", config: { name: "x" } }, new AbortController().signal, undefined, ctx);
 			if (!create.isError) throw new Error("create should be blocked");
 			const text = create.content?.[0]?.text ?? "";

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

@@ -0,0 +1,127 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, describe, it } from "node:test";
+import { createInlineSubagentAutocompleteProvider, parseInlineSubagentInput } from "../../src/slash/inline-subagents.ts";
+
+const baseProvider = () => ({
+	getSuggestions: async () => null,
+	applyCompletion: () => ({}),
+	shouldTriggerFileCompletion: () => true,
+});
+
+describe("createInlineSubagentAutocompleteProvider", () => {
+	const cwd = mkdtempSync(join(tmpdir(), "inline-subagents-"));
+	after(() => rmSync(cwd, { recursive: true, force: true }));
+	const state = { baseCwd: cwd } as never;
+
+	it("suggests installed agents after # at message start", async () => {
+		const provider = createInlineSubagentAutocompleteProvider(state, baseProvider());
+		const result = await provider.getSuggestions(["#"], 0, 1, {} as never);
+		assert.ok(result);
+		assert.equal(result.prefix, "#");
+		// Builtin agents always exist, so the picker must not be empty.
+		assert.ok(result.items.length > 0);
+	});
+
+	it("suggests agents for # anywhere in the message, like the $ skill picker", async () => {
+		const base = baseProvider();
+		const provider = createInlineSubagentAutocompleteProvider(state, base);
+
+		// # mid-line.
+		const mid = await provider.getSuggestions(["see #arch"], 0, 9, {} as never);
+		assert.ok(mid);
+		assert.equal(mid.prefix, "#arch");
+		assert.ok(mid.items.some((item) => item.value === "#architect"));
+
+		// # on a later line.
+		const later = await provider.getSuggestions(["", "#arch"], 1, 5, {} as never);
+		assert.ok(later);
+		assert.equal(later.prefix, "#arch");
+		assert.ok(later.items.some((item) => item.value === "#architect"));
+	});
+
+	it("falls back to the base provider without a # token or before baseCwd", async () => {
+		const base = baseProvider();
+		const provider = createInlineSubagentAutocompleteProvider(state, base);
+
+		// No # token on the current line.
+		assert.equal(await provider.getSuggestions(["plain text"], 0, 10, {} as never), null);
+		// # mid-word (no boundary before it) is not a mention.
+		assert.equal(await provider.getSuggestions(["pre#arch"], 0, 9, {} as never), null);
+		// No baseCwd yet (session_start not processed) falls back too.
+		const noCwd = createInlineSubagentAutocompleteProvider({ baseCwd: "" } as never, base);
+		assert.equal(await noCwd.getSuggestions(["#"], 0, 1, {} as never), null);
+	});
+});
+
+describe("parseInlineSubagentInput", () => {
+	it("parses #agent-name with a task", () => {
+		assert.deepEqual(parseInlineSubagentInput("#architect review the plan"), {
+			agentName: "architect",
+			task: "review the plan",
+			atStart: true,
+		});
+	});
+
+	it("parses hyphenated agent names", () => {
+		assert.deepEqual(parseInlineSubagentInput("#batch-grill-me interview the user"), {
+			agentName: "batch-grill-me",
+			task: "interview the user",
+			atStart: true,
+		});
+	});
+
+	it("parses #agent-name with no task", () => {
+		assert.deepEqual(parseInlineSubagentInput("#architect"), { agentName: "architect", task: "", atStart: true });
+	});
+
+	it("is case-insensitive and lowercases the agent name", () => {
+		assert.deepEqual(parseInlineSubagentInput("#Architect plan"), { agentName: "architect", task: "plan", atStart: true });
+	});
+
+	it("allows leading whitespace", () => {
+		assert.deepEqual(parseInlineSubagentInput("  #architect plan"), {
+			agentName: "architect",
+			task: "plan",
+			atStart: true,
+		});
+	});
+
+	it("parses #agent-name mid-message and at the end, taking the text after the mention as the task", () => {
+		assert.deepEqual(parseInlineSubagentInput("can you #architect review the plan"), {
+			agentName: "architect",
+			task: "review the plan",
+			atStart: false,
+		});
+		assert.deepEqual(parseInlineSubagentInput("let's get #architect"), {
+			agentName: "architect",
+			task: "",
+			atStart: false,
+		});
+	});
+
+	it("returns null without a #mention", () => {
+		assert.equal(parseInlineSubagentInput("review the plan"), null);
+		assert.equal(parseInlineSubagentInput("pre#architect"), null);
+		assert.equal(parseInlineSubagentInput("#"), null);
+		assert.equal(parseInlineSubagentInput("#-architect"), null);
+	});
+
+	it("treats a run-on identifier as a single (possibly unknown) agent token", () => {
+		assert.deepEqual(parseInlineSubagentInput("#architectreview"), {
+			agentName: "architectreview",
+			task: "",
+			atStart: true,
+		});
+	});
+
+	it("trims the task text", () => {
+		assert.deepEqual(parseInlineSubagentInput("#architect   review the plan   "), {
+			agentName: "architect",
+			task: "review the plan",
+			atStart: true,
+		});
+	});
+});

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

@@ -17,14 +17,14 @@ import {
 
 function makeAgent(overrides: Partial<AgentConfig> = {}): AgentConfig {
 	return {
-		name: "worker",
-		description: "Test worker",
+		name: "builder",
+		description: "Test builder",
 		systemPrompt: "Base prompt",
 		systemPromptMode: "replace",
 		inheritProjectContext: false,
 		inheritSkills: false,
 		source: "user",
-		filePath: "/tmp/worker.md",
+		filePath: "/tmp/builder.md",
 		...overrides,
 	};
 }
@@ -44,7 +44,7 @@ describe("resolveIntercomBridgeMode", () => {
 
 describe("resolveIntercomSessionTarget", () => {
 	it("prefers an explicit session name", () => {
-		assert.equal(resolveIntercomSessionTarget("planner", "session-12345678", "session-stableabcdef"), "planner");
+		assert.equal(resolveIntercomSessionTarget("architect", "session-12345678", "session-stableabcdef"), "architect");
 	});
 
 	it("uses a runtime-only subagent chat alias when unnamed", () => {
@@ -58,7 +58,7 @@ describe("resolveIntercomSessionTarget", () => {
 
 describe("resolveSubagentIntercomTarget", () => {
 	it("builds stable child session targets from run metadata", () => {
-		assert.equal(resolveSubagentIntercomTarget("78f659a3", "worker"), "subagent-worker-78f659a3");
+		assert.equal(resolveSubagentIntercomTarget("78f659a3", "builder"), "subagent-builder-78f659a3");
 		assert.equal(resolveSubagentIntercomTarget("78f659a3", "senior executor", 1), "subagent-senior-executor-78f659a3-2");
 	});
 });
@@ -98,7 +98,7 @@ describe("resolveIntercomBridge", () => {
 		});
 
 		assert.equal(bridge.active, true);
-		assert.equal(bridge.resultDelivery, true);
+		assert.equal(bridge.resultDelivery, false);
 		assert.equal(bridge.orchestratorTarget, "main");
 		assert.equal(bridge.extensionDir, NATIVE_INTERCOM_EXTENSION_DIR);
 	});