@selesai/code 0.9.10 → 0.9.12

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

@@ -1,63 +0,0 @@
-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";
-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 assertExactlyBuiltins(tablePath: string, heading: string, markdown: string): void {
-	const names = tableFirstColumnNames(markdown, heading);
-
-	assert.equal(names.length, BUILTIN_AGENT_NAMES.length, `${path.basename(tablePath)}: role table must contain exactly ${BUILTIN_AGENT_NAMES.length} 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 canonical builtins once, with no duplicates or aliases", () => {
-		const markdown = fs.readFileSync(README_PATH, "utf-8");
-		assertExactlyBuiltins(README_PATH, README_TABLE_HEADING, markdown);
-	});
-
-	it("prompting-and-roles reference lists exactly the canonical builtins once, with no duplicates or aliases", () => {
-		const markdown = fs.readFileSync(PROMPTING_AND_ROLES_PATH, "utf-8");
-		assertExactlyBuiltins(PROMPTING_AND_ROLES_PATH, PROMPTING_AND_ROLES_TABLE_HEADING, markdown);
-	});
-});

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

@@ -1,326 +0,0 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, it } from "node:test";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../../src/runs/shared/pi-args.ts";
-import { WAIT_TOOL_ENABLED_ENV } from "../../src/runs/background/subagent-wait.ts";
-
-type JsonSchemaNode = Record<string, unknown>;
-
-const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-function parentToolEnv(): NodeJS.ProcessEnv {
-	const env = { ...process.env };
-	delete env[SUBAGENT_CHILD_ENV];
-	delete env[SUBAGENT_FANOUT_CHILD_ENV];
-	delete env[WAIT_TOOL_ENABLED_ENV];
-	return env;
-}
-
-function missingPackageName(error: unknown): string | undefined {
-	const message = error instanceof Error ? error.message : String(error);
-	return message.match(/Cannot find package ['"]([^'"]+)['"]/i)?.[1];
-}
-
-let validateChainInput: (args: unknown) => void = () => {};
-let validateSubagentParams: (args: unknown) => boolean = () => true;
-let chainItemProperties: Record<string, unknown> | undefined;
-let dynamicTemplateProperties: Record<string, unknown> | undefined;
-let schemasAvailable = true;
-try {
-	const mod = await import("../../src/extension/chain-validation.ts") as {
-		validateChainInput: (args: unknown) => void;
-		CHAIN_STEP_KEYS: string[];
-		PARALLEL_TASK_KEYS: string[];
-		DYNAMIC_TEMPLATE_KEYS: string[];
-	};
-	validateChainInput = mod.validateChainInput;
-	const schemas = await import("../../src/extension/schemas.ts") as {
-		ChainItem: JsonSchemaNode;
-		DynamicParallelTemplateSchema: JsonSchemaNode;
-		SubagentParams: JsonSchemaNode;
-	};
-	const { Compile } = await import("typebox/compile") as unknown as {
-		Compile: (schema: JsonSchemaNode) => { Check(value: unknown): boolean };
-	};
-	const subagentParamsValidator = Compile(schemas.SubagentParams);
-	validateSubagentParams = (args) => subagentParamsValidator.Check(args);
-	chainItemProperties = schemas.ChainItem.properties as Record<string, unknown> | undefined;
-	dynamicTemplateProperties = schemas.DynamicParallelTemplateSchema.properties as Record<string, unknown> | undefined;
-} catch (error) {
-	if (missingPackageName(error) !== "typebox") throw error;
-	schemasAvailable = false;
-}
-
-function expectInvalid(args: unknown, ...patterns: RegExp[]): void {
-	assert.throws(
-		() => validateChainInput(args),
-		(error) => {
-			assert.ok(error instanceof Error, "validation should throw an Error");
-			const message = error.message;
-			for (const pattern of patterns) {
-				assert.match(message, pattern, `expected message to match ${pattern}; got: ${message}`);
-			}
-			return true;
-		},
-		`expected validation to fail for ${JSON.stringify(args)}`,
-	);
-}
-
-describe("chain input validation", { skip: !schemasAvailable ? "typebox not available" : undefined }, () => {
-	it("is a no-op when chain is absent or not an array", () => {
-		assert.doesNotThrow(() => validateChainInput({}));
-		assert.doesNotThrow(() => validateChainInput({ agent: "worker", task: "do X" }));
-		assert.doesNotThrow(() => validateChainInput({ chain: "not-an-array" }));
-		assert.doesNotThrow(() => validateChainInput({ action: "status" }));
-		assert.doesNotThrow(() => validateChainInput(undefined));
-		assert.doesNotThrow(() => validateChainInput(null));
-	});
-
-	it("accepts valid chain steps without throwing", () => {
-		assert.doesNotThrow(() => validateChainInput({ chain: [{ agent: "worker", task: "do X" }] }));
-		assert.doesNotThrow(() =>
-			validateChainInput({ chain: [{ agent: "worker", task: "do X", parallel: [{ agent: "reviewer", task: "review" }] }] }),
-		);
-		assert.doesNotThrow(() =>
-			validateChainInput({
-				chain: [{
-					expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-					parallel: { agent: "reviewer", task: "Review {item.path}" },
-					collect: { as: "reviews" },
-				}],
-			}),
-		);
-	});
-
-	it("names the disallowed property and lists allowed properties for a chain step", () => {
-		expectInvalid(
-			{ chain: [{ agent: "worker", task: "do X", bogus: true }] },
-			/chain\[0\]/,
-			/"bogus" is not allowed/,
-			/Allowed properties:/,
-			/Example:/,
-		);
-	});
-
-	it("lists every allowed chain step property from the schema", () => {
-		const allowed = Object.keys(chainItemProperties ?? {});
-		assert.ok(allowed.includes("agent"));
-		assert.ok(allowed.includes("parallel"));
-		assert.ok(allowed.includes("expand"));
-		try {
-			validateChainInput({ chain: [{ notReal: 1 }] });
-			assert.fail("should have thrown");
-		} catch (error) {
-			assert.ok(error instanceof Error);
-			for (const key of allowed) {
-				assert.match(error.message, new RegExp(`\\b${key}\\b`), `allowed key ${key} should appear in message: ${error.message}`);
-			}
-		}
-	});
-
-	it("reports multiple disallowed properties at once", () => {
-		expectInvalid(
-			{ chain: [{ agent: "worker", foo: 1, bar: 2 }] },
-			/chain\[0\]/,
-			/"foo"/,
-			/"bar"/,
-		);
-	});
-
-	it("explains expected shape when a chain step is not an object", () => {
-		expectInvalid(
-			{ chain: ["not-an-object"] },
-			/chain\[0\]/,
-			/expected an object/,
-			/string/,
-			/Allowed properties:/,
-			/Example:/,
-		);
-		expectInvalid(
-			{ chain: [42] },
-			/chain\[0\]/,
-			/expected an object/,
-			/number/,
-		);
-	});
-
-	it("preserves static parallel extra properties accepted by the TypeBox schema", () => {
-		const args = { chain: [{ parallel: [{ agent: "worker", extensionField: true }] }] };
-		assert.equal(validateSubagentParams(args), true);
-		assert.doesNotThrow(() => validateChainInput(args));
-	});
-
-	it("names disallowed properties on a dynamic fanout template", () => {
-		expectInvalid(
-			{
-				chain: [{
-					expand: { from: { output: "targets", path: "/items" }, maxItems: 4 },
-					parallel: { agent: "worker", bogus: true },
-					collect: { as: "reviews" },
-				}],
-			},
-			/chain\[0\]\.parallel/,
-			/"bogus" is not allowed/,
-			/Allowed properties:/,
-		);
-	});
-
-	it("lists every allowed dynamic template property from the schema", () => {
-		const allowed = Object.keys(dynamicTemplateProperties ?? {});
-		assert.ok(allowed.includes("agent"));
-		assert.ok(allowed.includes("outputSchema"));
-		try {
-			validateChainInput({
-				chain: [{
-					expand: { from: { output: "x", path: "/items" }, maxItems: 4 },
-					parallel: { notReal: 1 },
-					collect: { as: "reviews" },
-				}],
-			});
-			assert.fail("should have thrown");
-		} catch (error) {
-			assert.ok(error instanceof Error);
-			for (const key of allowed) {
-				assert.match(error.message, new RegExp(`\\b${key}\\b`), `allowed key ${key} should appear: ${error.message}`);
-			}
-		}
-	});
-
-	it("guides the agent when parallel is neither an array nor an object", () => {
-		expectInvalid(
-			{ chain: [{ parallel: "nope" }] },
-			/chain\[0\]\.parallel/,
-			/expected an array of task objects or a dynamic fanout template object/,
-			/string/,
-		);
-	});
-
-	it("names disallowed properties on expand", () => {
-		expectInvalid(
-			{
-				chain: [{
-					expand: { from: { output: "x", path: "/items" }, maxItems: 4, bogus: true },
-					parallel: { agent: "worker" },
-					collect: { as: "reviews" },
-				}],
-			},
-			/chain\[0\]\.expand/,
-			/"bogus" is not allowed/,
-			/Allowed properties:/,
-		);
-	});
-
-	it("names disallowed properties on expand.from", () => {
-		expectInvalid(
-			{
-				chain: [{
-					expand: { from: { output: "x", path: "/items", bogus: true }, maxItems: 4 },
-					parallel: { agent: "worker" },
-					collect: { as: "reviews" },
-				}],
-			},
-			/chain\[0\]\.expand\.from/,
-			/"bogus" is not allowed/,
-			/Allowed properties:/,
-		);
-	});
-
-	it("names disallowed properties on collect", () => {
-		expectInvalid(
-			{
-				chain: [{
-					expand: { from: { output: "x", path: "/items" }, maxItems: 4 },
-					parallel: { agent: "worker" },
-					collect: { as: "reviews", bogus: true },
-				}],
-			},
-			/chain\[0\]\.collect/,
-			/"bogus" is not allowed/,
-			/Allowed properties:/,
-		);
-	});
-
-	it("reports the correct chain index for multi-step chains", () => {
-		expectInvalid(
-			{ chain: [{ agent: "worker", task: "ok" }, { agent: "worker", bogus: true }] },
-			/chain\[1\]/,
-			/"bogus" is not allowed/,
-		);
-	});
-});
-
-describe("registered subagent tool prepareArguments", { skip: !schemasAvailable ? "typebox not available" : undefined }, () => {
-	function runPrepare(args: unknown): { error?: string; ok: true } | { error: string; ok: false } {
-		const script = String.raw`
-			import registerSubagentExtension from "./src/extension/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) {
-					if (prop in target) return target[prop];
-					return () => undefined;
-				},
-			});
-			registerSubagentExtension(fakePi);
-			if (!registeredTool) throw new Error("tool not registered");
-			if (typeof registeredTool.prepareArguments !== "function") throw new Error("prepareArguments not attached");
-			const args = JSON.parse(process.argv[process.argv.length - 1] ?? "{}");
-			try {
-				registeredTool.prepareArguments(args);
-				process.stdout.write(JSON.stringify({ ok: true }));
-			} catch (error) {
-				process.stdout.write(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : String(error) }));
-			}
-		`;
-		const output = execFileSync(
-			process.execPath,
-			[
-				"--experimental-strip-types",
-				"--import",
-				"./test/support/register-loader.mjs",
-				"--input-type=module",
-				"--eval",
-				script,
-				"--",
-				JSON.stringify(args),
-			],
-			{ cwd: projectRoot, env: parentToolEnv(), encoding: "utf-8", stdio: "pipe" },
-		);
-		return JSON.parse(output) as { error?: string; ok: boolean };
-	}
-
-	it("throws a friendly chain error before schema validation when a step has a disallowed property", () => {
-		const result = runPrepare({ chain: [{ agent: "worker", task: "do X", bogus: true }] });
-		assert.equal(result.ok, false);
-		assert.match(result.error ?? "", /chain\[0\]/);
-		assert.match(result.error ?? "", /"bogus" is not allowed/);
-		assert.match(result.error ?? "", /Allowed properties:/);
-		assert.match(result.error ?? "", /Example:/);
-	});
-
-	it("passes valid chain arguments through unchanged", () => {
-		const result = runPrepare({ chain: [{ agent: "worker", task: "do X" }] });
-		assert.equal(result.ok, true);
-	});
-
-	it("preserves static parallel extra properties accepted by the registered schema", () => {
-		const result = runPrepare({ chain: [{ parallel: [{ agent: "worker", extensionField: true }] }] });
-		assert.equal(result.ok, true);
-	});
-
-	it("is a no-op for management actions and single/parallel calls", () => {
-		assert.equal(runPrepare({ action: "status" }).ok, true);
-		assert.equal(runPrepare({ agent: "worker", task: "do X" }).ok, true);
-		assert.equal(runPrepare({ tasks: [{ agent: "worker", task: "do X" }] }).ok, true);
-	});
-});

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

@@ -1,103 +0,0 @@
-import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-import { describe, it } from "node:test";
-
-const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-describe("handoff workflow carry-over", () => {
-	it("adopts the previous session's active async workflows and tells the agent", () => {
-		const script = String.raw`
-			import os from "node:os";
-			import path from "node:path";
-			import fs from "node:fs";
-			import { DIRS } from "./src/shared/types.ts";
-			import registerSubagentExtension from "./index.ts";
-			const handlers = new Map();
-			const events = { listeners: new Map(), on(name, handler) { this.listeners.set(name, handler); return () => this.listeners.delete(name); }, emit(name, payload) { this.listeners.get(name)?.(payload); } };
-			const sent = [];
-			const widgets = [];
-			const pi = new Proxy({
-				events,
-				on(name, handler) { handlers.set(name, handler); },
-				registerTool() {}, registerCommand() {}, registerShortcut() {}, registerMessageRenderer() {},
-				sendMessage(message, options) { sent.push({ message, options }); }, getSessionName() { return undefined; },
-			}, { get(target, prop) { return prop in target ? target[prop] : () => undefined; } });
-
-			const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "selesai-handoff-"));
-			const oldSession = path.join(tmp, "old-session.jsonl");
-			const newSession = path.join(tmp, "new-session.jsonl");
-			fs.writeFileSync(oldSession, JSON.stringify({ type: "session", version: 1, id: "old-session", timestamp: new Date().toISOString(), cwd: process.cwd() }) + "\n");
-			fs.writeFileSync(newSession, JSON.stringify({ type: "session", version: 1, id: "new-session", timestamp: new Date().toISOString(), cwd: process.cwd(), parentSession: oldSession }) + "\n");
-
-			// One active async workflow owned by the previous session.
-			const runId = "adopted-workflow-run";
-			const asyncDir = path.join(DIRS.async, runId);
-			fs.mkdirSync(asyncDir, { recursive: true });
-			fs.writeFileSync(path.join(asyncDir, "status.json"), JSON.stringify({
-				runId,
-				state: "running",
-				sessionId: oldSession,
-				mode: "workflow",
-				workflowKey: "task",
-				agent: "builder",
-				startedAt: Date.now(),
-				steps: [{ agent: "builder", status: "running", phase: "build-1", description: "Implement the carry-over plan" }],
-			}));
-			fs.mkdirSync(path.join(DIRS.async, ".active-runs"), { recursive: true });
-			fs.writeFileSync(path.join(DIRS.async, ".active-runs", runId), "");
-
-			// A result file for an old-session run written during the switch window.
-			const resultRunId = "adopted-completed-run";
-			const resultPath = path.join(DIRS.results, resultRunId + ".json");
-			fs.mkdirSync(DIRS.results, { recursive: true });
-			fs.writeFileSync(resultPath, JSON.stringify({ runId: resultRunId, sessionId: oldSession, agent: "explorer", summary: "done", success: true }));
-
-			const ctx = { cwd: process.cwd(), hasUI: true, ui: { setWidget(key, value) { widgets.push([key, value]); }, requestRender() {}, onTerminalInput() { return () => {}; }, getEditorText() { return ""; }, notify() {}, theme: { fg(_name, text) { return text; }, bg(_name, text) { return text; }, bold(text) { return text; } } }, sessionManager: { getSessionId() { return "new-session"; }, getSessionFile() { return newSession; }, getHeader() { return { parentSession: oldSession }; }, getEntries() { return []; } }, modelRegistry: { getAvailable() { return []; } } };
-
-			registerSubagentExtension(pi);
-			handlers.get("session_start")({ reason: "new", previousSessionFile: oldSession }, ctx);
-			sent.length = 0;
-
-			// No handoff notice until a turn settles.
-			if (sent.length !== 0) throw new Error("handoff notice sent before the first settled turn");
-
-			handlers.get("agent_settled")();
-			const handoff = sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume");
-			if (handoff.length !== 1) throw new Error(JSON.stringify(sent.map((entry) => entry.message)));
-			if (handoff[0].options?.triggerTurn !== true) throw new Error("handoff notice did not trigger a turn");
-			if (typeof handoff[0].message?.content !== "string" || !handoff[0].message.content.includes(runId) || !handoff[0].message.content.includes("carried over")) {
-				throw new Error("handoff notice lacks the adopted workflow: " + JSON.stringify(handoff[0].message));
-			}
-
-			// Only once per adoption.
-			handlers.get("agent_settled")();
-			if (sent.filter((entry) => entry.message?.customType === "subagent-handoff-resume").length !== 1) throw new Error("handoff notice repeated");
-
-			// Compaction resume message now lists the live workflows.
-			handlers.get("session_before_compact")({ reason: "threshold", signal: new AbortController().signal });
-			handlers.get("session_compact")({ reason: "threshold" });
-			const compaction = sent.filter((entry) => entry.message?.customType === "subagent-compaction-resume");
-			if (compaction.length !== 1) throw new Error("compaction resume missing: " + JSON.stringify(sent.map((entry) => entry.message?.customType)));
-			if (typeof compaction[0].message?.content !== "string" || !compaction[0].message.content.includes(runId)) {
-				throw new Error("compaction resume lacks the workflow manifest: " + JSON.stringify(compaction[0].message));
-			}
-
-			// Adopted old-session result gets delivered and cleaned up (batched
-			// notification debounces, so poll with a generous bound).
-			let delivered = false;
-			for (let attempt = 0; attempt < 40 && !delivered; attempt++) {
-				await new Promise((resolve) => setTimeout(resolve, 250));
-				delivered = !fs.existsSync(resultPath);
-			}
-			if (!delivered) throw new Error("adopted result file was not delivered");
-
-			await handlers.get("session_shutdown")();
-		`;
-		const env = { ...process.env };
-		delete env.SELESAI_SUBAGENT_CHILD;
-		execFileSync(process.execPath, ["--experimental-strip-types", "--import", "./test/support/register-loader.mjs", "--input-type=module", "--eval", script], { cwd: projectRoot, env, stdio: "pipe" });
-		assert.ok(true);
-	});
-});

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

@@ -1,127 +0,0 @@
-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,
-		});
-	});
-});