@selesai/code 0.6.3 → 0.8.0

package/dist/core/tools/index.js

@@ -109,4 +109,3 @@ export function createAllTools(cwd, options) {
         ls: createLsTool(cwd, options?.ls),
     };
 }
-//# sourceMappingURL=index.js.map

package/dist/core/tools/ls.d.ts

@@ -34,4 +34,3 @@ export interface LsToolOptions {
 export declare function createLsToolDefinition(cwd: string, options?: LsToolOptions): ToolDefinition<typeof lsSchema, LsToolDetails | undefined>;
 export declare function createLsTool(cwd: string, options?: LsToolOptions): AgentTool<typeof lsSchema>;
 export {};
-//# sourceMappingURL=ls.d.ts.map

package/dist/core/tools/ls.js

@@ -164,4 +164,3 @@ export function createLsToolDefinition(cwd, options) {
 export function createLsTool(cwd, options) {
     return wrapToolDefinition(createLsToolDefinition(cwd, options));
 }
-//# sourceMappingURL=ls.js.map

package/dist/core/tools/output-accumulator.d.ts

@@ -49,4 +49,3 @@ export declare class OutputAccumulator {
     private shouldUseTempFile;
     private ensureTempFile;
 }
-//# sourceMappingURL=output-accumulator.d.ts.map

package/dist/core/tools/output-accumulator.js

@@ -181,4 +181,3 @@ export class OutputAccumulator {
         this.rawChunks = [];
     }
 }
-//# sourceMappingURL=output-accumulator.js.map

package/dist/core/tools/path-utils.d.ts

@@ -7,4 +7,3 @@ export declare function expandPath(filePath: string): string;
 export declare function resolveToCwd(filePath: string, cwd: string): string;
 export declare function resolveReadPath(filePath: string, cwd: string): string;
 export declare function resolveReadPathAsync(filePath: string, cwd: string): Promise<string>;
-//# sourceMappingURL=path-utils.d.ts.map

package/dist/core/tools/path-utils.js

@@ -96,4 +96,3 @@ export async function resolveReadPathAsync(filePath, cwd) {
     }
     return resolved;
 }
-//# sourceMappingURL=path-utils.js.map

package/dist/core/tools/read.d.ts

@@ -32,4 +32,3 @@ export interface ReadToolOptions {
 export declare function createReadToolDefinition(cwd: string, options?: ReadToolOptions): ToolDefinition<typeof readSchema, ReadToolDetails | undefined>;
 export declare function createReadTool(cwd: string, options?: ReadToolOptions): AgentTool<typeof readSchema>;
 export {};
-//# sourceMappingURL=read.d.ts.map

package/dist/core/tools/read.js

@@ -273,4 +273,3 @@ export function createReadToolDefinition(cwd, options) {
 export function createReadTool(cwd, options) {
     return wrapToolDefinition(createReadToolDefinition(cwd, options));
 }
-//# sourceMappingURL=read.js.map

package/dist/core/tools/render-utils.d.ts

@@ -21,4 +21,3 @@ export declare function invalidArgText(theme: Theme): string;
 export declare function renderToolPath(rawPath: string | null, theme: Theme, cwd: string, options?: {
     emptyFallback?: string;
 }): string;
-//# sourceMappingURL=render-utils.d.ts.map

package/dist/core/tools/render-utils.js

@@ -62,4 +62,3 @@ export function renderToolPath(rawPath, theme, cwd, options) {
         return theme.fg("toolOutput", "...");
     return linkPath(theme.fg("accent", shortenPath(value)), value, cwd);
 }
-//# sourceMappingURL=render-utils.js.map

package/dist/core/tools/tool-definition-wrapper.d.ts

@@ -11,4 +11,3 @@ export declare function wrapToolDefinitions(definitions: ToolDefinition<any, any
  * provides plain AgentTool overrides that do not include prompt metadata or renderers.
  */
 export declare function createToolDefinitionFromAgentTool(tool: AgentTool<any>): ToolDefinition<any, unknown>;
-//# sourceMappingURL=tool-definition-wrapper.d.ts.map

package/dist/core/tools/tool-definition-wrapper.js

@@ -33,4 +33,3 @@ export function createToolDefinitionFromAgentTool(tool) {
         execute: async (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
     };
 }
-//# sourceMappingURL=tool-definition-wrapper.js.map

package/dist/core/tools/truncate.d.ts

@@ -67,4 +67,3 @@ export declare function truncateLine(line: string, maxChars?: number): {
     text: string;
     wasTruncated: boolean;
 };
-//# sourceMappingURL=truncate.d.ts.map

package/dist/core/tools/truncate.js

@@ -212,4 +212,3 @@ export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
     }
     return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
 }
-//# sourceMappingURL=truncate.js.map

package/dist/core/tools/write.d.ts

@@ -23,4 +23,3 @@ export interface WriteToolOptions {
 export declare function createWriteToolDefinition(cwd: string, options?: WriteToolOptions): ToolDefinition<typeof writeSchema, undefined>;
 export declare function createWriteTool(cwd: string, options?: WriteToolOptions): AgentTool<typeof writeSchema>;
 export {};
-//# sourceMappingURL=write.d.ts.map

package/dist/core/tools/write.js

@@ -194,4 +194,3 @@ export function createWriteToolDefinition(cwd, options) {
 export function createWriteTool(cwd, options) {
     return wrapToolDefinition(createWriteToolDefinition(cwd, options));
 }
-//# sourceMappingURL=write.js.map

package/dist/core/trust-manager.d.ts

@@ -33,4 +33,3 @@ export declare class ProjectTrustStore {
     set(cwd: string, decision: ProjectTrustDecision): void;
     setMany(decisions: ProjectTrustUpdate[]): void;
 }
-//# sourceMappingURL=trust-manager.d.ts.map

package/dist/core/trust-manager.js

@@ -199,4 +199,3 @@ export class ProjectTrustStore {
         });
     }
 }
-//# sourceMappingURL=trust-manager.js.map

package/dist/core/usage-totals.d.ts

@@ -16,4 +16,3 @@ export interface UsageCostBreakdownEntry {
 }
 /** Group attributable assistant usage by model and all other usage into a separate bucket. */
 export declare function getUsageCostBreakdown(entries: SessionEntry[]): UsageCostBreakdownEntry[];
-//# sourceMappingURL=usage-totals.d.ts.map

package/dist/core/usage-totals.js

@@ -49,4 +49,3 @@ export function getUsageCostBreakdown(entries) {
         .filter((entry) => entry.cost > 0 || entry.tokens > 0)
         .sort((a, b) => b.cost - a.cost);
 }
-//# sourceMappingURL=usage-totals.js.map

package/dist/defaults/models.json

@@ -22,6 +22,14 @@
             "cacheRead": 0.003,
             "cacheWrite": 0
           },
+          "thinkingLevelMap": {
+            "minimal": null,
+            "low": null,
+            "medium": null,
+            "high": null,
+            "xhigh": null,
+            "max": "max"
+          },
           "compat": {
             "supportsDeveloperRole": false,
             "requiresReasoningContentOnAssistantMessages": true,

package/dist/defaults/settings.json

@@ -16,7 +16,6 @@
   "editorPaddingX": 0,
   "outputPad": 0,
   "showCacheMissNotices": true,
-  "enableSkillCommands": true,
   "followUpMode": "one-at-a-time",
   "hideThinkingBlock": false,
   "images": {
@@ -40,22 +39,22 @@
   "subagents": {
     "agentOverrides": {
       "architect": {
-        "model": "tokenin/kimi-k3"
+        "model": "tokenin/kimi-k3:high"
       },
       "builder": {
-        "model": "tokenin/deepseek-v4-flash"
+        "model": "tokenin/deepseek-v4-flash:max"
       },
       "commentator": {
-        "model": "tokenin/glm-5.2"
+        "model": "tokenin/deepseek-v4-flash:max"
       },
       "explorer": {
-        "model": "tokenin/deepseek-v4-flash"
+        "model": "tokenin/deepseek-v4-flash:max"
       },
       "recapper": {
-        "model": "tokenin/deepseek-v4-flash"
+        "model": "tokenin/deepseek-v4-flash:max"
       },
       "researcher": {
-        "model": "tokenin/deepseek-v4-flash"
+        "model": "tokenin/deepseek-v4-flash:max"
       }
     }
   },

package/dist/extensions/agent-browser.test.ts

@@ -0,0 +1,195 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import agentBrowserSetupExtension, {
+	DECLINED_MARKER_NAME,
+	ensureAgentBrowser,
+	getDeclinedMarkerPath,
+	INSTALL_COMMAND,
+	isAgentBrowserInstalled,
+	SKIP_ENV,
+} from "./agent-browser.ts";
+
+type ExecResult = { code: number; stdout: string; stderr: string; killed: boolean };
+
+function makePi(execImpl?: (command: string, args: string[], opts?: { timeout?: number }) => Promise<ExecResult>) {
+	const handlers = new Map<string, Function[]>();
+	const commands = new Map<string, any>();
+	const exec = vi.fn(
+		execImpl ?? (async () => ({ code: 0, stdout: "", stderr: "", killed: false }) as ExecResult),
+	);
+	const pi = {
+		exec,
+		on: (evt: string, h: Function) => {
+			handlers.set(evt, [...(handlers.get(evt) ?? []), h]);
+		},
+		registerCommand: (name: string, options: any) => {
+			commands.set(name, options);
+		},
+	};
+	return { pi: pi as any, handlers, commands, exec };
+}
+
+function makeCtx(overrides?: Partial<{ hasUI: boolean; confirmResult: boolean }>) {
+	const ui = {
+		confirm: vi.fn(async () => overrides?.confirmResult ?? true),
+		notify: vi.fn(),
+	};
+	return { hasUI: overrides?.hasUI ?? true, ui } as any;
+}
+
+function getSessionStartHandler(handlers: Map<string, Function[]>): Function {
+	const handler = handlers.get("session_start")?.[0];
+	if (!handler) throw new Error("no session_start handler registered");
+	return handler;
+}
+
+const ok: ExecResult = { code: 0, stdout: "", stderr: "", killed: false };
+const fail: ExecResult = { code: 1, stdout: "", stderr: "command not found", killed: false };
+
+let tmpDir: string;
+
+beforeAll(() => {
+	tmpDir = mkdtempSync(join(tmpdir(), "agent-browser-test-"));
+	process.env.SELESAI_CODING_AGENT_DIR = tmpDir;
+	process.env.PI_CODING_AGENT_DIR = tmpDir;
+});
+
+afterEach(() => {
+	vi.restoreAllMocks();
+	// The decline marker persists in the shared temp agent dir; remove it so
+	// later tests (no-UI, npm-failure) don't short-circuit on isDeclined().
+	rmSync(getDeclinedMarkerPath(), { force: true });
+});
+
+afterAll(() => {
+	delete process.env.SELESAI_CODING_AGENT_DIR;
+	delete process.env.PI_CODING_AGENT_DIR;
+	rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("agent-browser setup extension", () => {
+	it("registers a session_start hook and the setup-agent-browser command", async () => {
+		const { pi, handlers, commands } = makePi();
+		await agentBrowserSetupExtension(pi);
+		expect(handlers.has("session_start")).toBe(true);
+		expect(commands.has("setup-agent-browser")).toBe(true);
+	});
+
+	it("skips probing when the opt-out env var is set or session is not a startup", async () => {
+		process.env[SKIP_ENV] = "1";
+		try {
+			const { pi, handlers, exec } = makePi();
+			await agentBrowserSetupExtension(pi);
+			await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, makeCtx());
+			expect(exec).not.toHaveBeenCalled();
+		} finally {
+			delete process.env[SKIP_ENV];
+		}
+
+		const { pi, handlers, exec } = makePi();
+		await agentBrowserSetupExtension(pi);
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "reload" }, makeCtx());
+		expect(exec).not.toHaveBeenCalled();
+	});
+
+	it("does not prompt when the CLI is already installed", async () => {
+		const { pi, handlers, exec } = makePi();
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(exec).toHaveBeenCalledTimes(1);
+		const args = exec.mock.calls[0][1] as string[];
+		expect(args.join(" ")).toContain("--version");
+		expect(ctx.ui.confirm).not.toHaveBeenCalled();
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("already installed"), "info");
+	});
+
+	it("installs via npm when the user confirms, then provisions the browser", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe: missing
+			.mockResolvedValueOnce(ok) // npm i -g agent-browser
+			.mockResolvedValueOnce(ok) // probe: now present
+			.mockResolvedValueOnce(ok); // agent-browser install
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.confirm).toHaveBeenCalledWith(expect.stringContaining("Install agent-browser?"), expect.any(String));
+		expect(exec).toHaveBeenCalledTimes(4);
+		const calls = exec.mock.calls.map(([command, args]) => [command, ...(args as string[])].join(" "));
+		expect(calls[0]).toContain("--version");
+		expect(calls[1]).toContain("npm");
+		expect(calls[1]).toContain("agent-browser");
+		expect(calls[2]).toContain("--version");
+		expect(calls[3]).toBe(`${process.platform === "win32" ? "cmd /c " : ""}agent-browser install`);
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("browser provisioned"), "info");
+	});
+
+	it("records a decline marker and notifies when the user says no", async () => {
+		const execImpl = vi.fn().mockResolvedValue(fail);
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx({ confirmResult: false });
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(exec).toHaveBeenCalledTimes(1); // probe only
+		expect(existsSync(getDeclinedMarkerPath())).toBe(true);
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("Skipped"), "info");
+	});
+
+	it("warns with install instructions when there is no UI", async () => {
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+		const execImpl = vi.fn().mockResolvedValue(fail);
+		const { pi, handlers } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx({ hasUI: false });
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.confirm).not.toHaveBeenCalled();
+		expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(INSTALL_COMMAND));
+	});
+
+	it("reports a failed npm install and skips browser provisioning", async () => {
+		const execImpl = vi
+			.fn()
+			.mockResolvedValueOnce(fail) // probe
+			.mockResolvedValueOnce({ code: 1, stdout: "", stderr: "EACCES", killed: false }); // npm fails
+		const { pi, handlers, exec } = makePi(execImpl as any);
+		await agentBrowserSetupExtension(pi);
+		const ctx = makeCtx();
+		await getSessionStartHandler(handlers)({ type: "session_start", reason: "startup" }, ctx);
+
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("failed"), "error");
+		expect(exec).toHaveBeenCalledTimes(2);
+		expect(exec.mock.calls.some((c) => (c[1] as string[]).join(" ").endsWith("agent-browser install"))).toBe(false);
+	});
+
+	it("isAgentBrowserInstalled reports the probe result", async () => {
+		const { pi, exec } = makePi(async () => ok);
+		expect(await isAgentBrowserInstalled(pi)).toBe(true);
+		expect(exec).toHaveBeenCalledTimes(1);
+
+		const { pi: pi2, exec: exec2 } = makePi(async () => fail);
+		expect(await isAgentBrowserInstalled(pi2)).toBe(false);
+		expect(exec2).toHaveBeenCalledTimes(1);
+	});
+
+	it("setup-agent-browser command re-runs the flow", async () => {
+		const { pi, commands } = makePi(async () => ok);
+		await agentBrowserSetupExtension(pi);
+		const command = commands.get("setup-agent-browser");
+		expect(command).toBeDefined();
+		const ctx = makeCtx();
+		await command.handler("", ctx);
+		expect(ctx.ui.notify).toHaveBeenCalledWith(expect.stringContaining("already installed"), "info");
+	});
+
+	it("declined marker path lives in the agent dir", () => {
+		expect(getDeclinedMarkerPath()).toBe(join(tmpDir, DECLINED_MARKER_NAME));
+	});
+});

package/dist/extensions/agent-browser.ts

@@ -0,0 +1,158 @@
+/**
+ * agent-browser setup extension.
+ *
+ * The bundled `agent-browser` skill needs the `agent-browser` CLI (npm package)
+ * installed (`npm i -g agent-browser && agent-browser install`). This extension
+ * makes sure the user installs it when it is missing:
+ *
+ * - On the first startup where the CLI is not on PATH, ask the user to install
+ *   it globally via npm and run the documented install steps when they agree.
+ * - Declining records a marker in the agent dir so we don't nag on every
+ *   startup; the `/setup-agent-browser` command re-runs the flow any time.
+ * - With no UI (headless/CI), fall back to a console warning with the install
+ *   command, mirroring the rtk extension's fail-open behavior.
+ *
+ * Mirrors src/extensions/rtk.ts (probe, opt-out env var, fail-open warning)
+ * and src/extensions/web-agent-onboarding.ts (confirm -> act -> marker).
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "@selesai/code";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, SessionStartEvent } from "@selesai/code";
+
+const PROBE_TIMEOUT_MS = 2_000;
+const INSTALL_TIMEOUT_MS = 180_000; // `npm i -g` can be slow on a cold cache
+const BROWSER_INSTALL_TIMEOUT_MS = 600_000; // `agent-browser install` provisions a browser
+
+/** Set to "1" to skip the automated setup prompt (the skill still works if installed). */
+export const SKIP_ENV = "SELESAI_SKIP_AGENT_BROWSER_SETUP";
+export const DECLINED_MARKER_NAME = ".agentBrowserSetupDeclined";
+
+export const INSTALL_COMMAND = "npm i -g agent-browser && agent-browser install";
+
+// `pi.exec` spawns without a shell, so on Windows npm/agent-browser are .cmd
+// shims that must be launched through cmd.exe.
+function cliCommand(args: string[]): { command: string; args: string[] } {
+	if (process.platform === "win32") {
+		return { command: "cmd", args: ["/c", ...args] };
+	}
+	return { command: args[0]!, args: args.slice(1) };
+}
+
+export function getDeclinedMarkerPath(agentDir: string = getAgentDir()): string {
+	return join(agentDir, DECLINED_MARKER_NAME);
+}
+
+function isDeclined(agentDir: string = getAgentDir()): boolean {
+	return existsSync(getDeclinedMarkerPath(agentDir));
+}
+
+function markDeclined(agentDir: string = getAgentDir()): void {
+	const markerPath = getDeclinedMarkerPath(agentDir);
+	mkdirSync(dirname(markerPath), { recursive: true });
+	writeFileSync(markerPath, "1", "utf-8");
+}
+
+function notify(ctx: ExtensionContext, message: string, type?: "info" | "warning" | "error"): void {
+	if (ctx.hasUI) ctx.ui.notify(message, type);
+}
+
+/** True when the `agent-browser` CLI is on PATH and answers `--version`. */
+export async function isAgentBrowserInstalled(pi: ExtensionAPI): Promise<boolean> {
+	const { command, args } = cliCommand(["agent-browser", "--version"]);
+	try {
+		const result = await pi.exec(command, args, { timeout: PROBE_TIMEOUT_MS });
+		return !result.killed && result.code === 0;
+	} catch {
+		return false;
+	}
+}
+
+/** Run `npm i -g agent-browser`; returns an error message or null on success. */
+async function runNpmInstall(pi: ExtensionAPI): Promise<string | null> {
+	const { command, args } = cliCommand(["npm", "i", "-g", "agent-browser"]);
+	const result = await pi.exec(command, args, { timeout: INSTALL_TIMEOUT_MS });
+	if (result.killed) return "npm install timed out";
+	if (result.code !== 0) {
+		return (result.stderr || result.stdout || `exit status ${result.code}`).trim() || "npm install failed";
+	}
+	return null;
+}
+
+/** Best-effort `agent-browser install` (provisions the browser). Non-fatal. */
+async function provisionBrowser(pi: ExtensionAPI): Promise<boolean> {
+	const { command, args } = cliCommand(["agent-browser", "install"]);
+	try {
+		const result = await pi.exec(command, args, { timeout: BROWSER_INSTALL_TIMEOUT_MS });
+		return !result.killed && result.code === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Probe for the CLI; when missing, ask the user to install it via npm and run
+ * the documented install steps if they agree. Returns whether the CLI is
+ * available afterwards.
+ */
+export async function ensureAgentBrowser(pi: ExtensionAPI, ctx: ExtensionContext): Promise<boolean> {
+	if (await isAgentBrowserInstalled(pi)) {
+		notify(ctx, "agent-browser CLI is already installed.", "info");
+		return true;
+	}
+
+	// No dialog UI (headless/CI): warn with the install command, like rtk does.
+	if (!ctx.hasUI) {
+		console.warn(`[agent-browser] CLI not found; install with: ${INSTALL_COMMAND}`);
+		return false;
+	}
+
+	const wantsInstall = await ctx.ui.confirm(
+		"Install agent-browser?",
+		`The agent-browser skill needs the agent-browser CLI. Install it globally via npm?\n\n${INSTALL_COMMAND}`,
+	);
+	if (!wantsInstall) {
+		markDeclined();
+		ctx.ui.notify(`Skipped. Run /setup-agent-browser later or install manually: ${INSTALL_COMMAND}`, "info");
+		return false;
+	}
+
+	ctx.ui.notify("Installing agent-browser via npm…", "info");
+	const error = await runNpmInstall(pi);
+	if (error) {
+		ctx.ui.notify(`agent-browser install failed: ${error}`, "error");
+		ctx.ui.notify(`Install manually: ${INSTALL_COMMAND}`, "warning");
+		return false;
+	}
+
+	if (!(await isAgentBrowserInstalled(pi))) {
+		ctx.ui.notify("npm reported success, but agent-browser is still not on PATH.", "warning");
+		ctx.ui.notify(`Try running: ${INSTALL_COMMAND}`, "info");
+		return false;
+	}
+
+	if (await provisionBrowser(pi)) {
+		ctx.ui.notify("agent-browser installed and browser provisioned.", "info");
+	} else {
+		ctx.ui.notify("agent-browser installed. Run `agent-browser install` to provision the browser.", "info");
+	}
+	return true;
+}
+
+export default function agentBrowserSetupExtension(pi: ExtensionAPI): void {
+	pi.on("session_start", async (event: SessionStartEvent, ctx: ExtensionContext) => {
+		if (event.reason !== "startup") return;
+		if (process.env[SKIP_ENV] === "1") return;
+		if (isDeclined()) return;
+		await ensureAgentBrowser(pi, ctx);
+	});
+
+	// Manual re-run; also the escape hatch after a decline.
+	pi.registerCommand("setup-agent-browser", {
+		description: "Install the agent-browser CLI (npm) if missing, or re-check",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			await ensureAgentBrowser(pi, ctx);
+		},
+	});
+}

package/dist/extensions/inline-skills.test.ts

@@ -22,14 +22,14 @@ describe("inline-skills", () => {
 		for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
 	});
 
-	it("suggests skills after # anywhere in a line", async () => {
+	it("suggests skills after $ anywhere in a line", async () => {
 		const pi = createPi([skill("research", "/skills/research/SKILL.md"), skill("review", "/skills/review/SKILL.md")]);
 		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
 		const provider = createInlineSkillAutocompleteProvider(pi, base);
 
-		expect(await provider.getSuggestions(["Draft #res"], 0, 10, {} as any)).toEqual({
-			prefix: "#res",
-			items: [{ value: "#research", label: "#research", description: "research description" }],
+		expect(await provider.getSuggestions(["Draft $res"], 0, 10, {} as any)).toEqual({
+			prefix: "$res",
+			items: [{ value: "$research", label: "$research", description: "research description" }],
 		});
 	});
 
@@ -38,9 +38,9 @@ describe("inline-skills", () => {
 		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
 		const provider = createInlineSkillAutocompleteProvider(pi, base);
 
-		expect(await provider.getSuggestions(["#grill"], 0, 6, {} as any)).toEqual({
-			prefix: "#grill",
-			items: [{ value: "#batch-grill-me", label: "#batch-grill-me", description: "batch-grill-me description" }],
+		expect(await provider.getSuggestions(["$grill"], 0, 6, {} as any)).toEqual({
+			prefix: "$grill",
+			items: [{ value: "$batch-grill-me", label: "$batch-grill-me", description: "batch-grill-me description" }],
 		});
 	});
 
@@ -52,7 +52,7 @@ describe("inline-skills", () => {
 		writeFileSync(research, "---\nname: research\ndescription: Research\n---\nResearch instructions.\n");
 		writeFileSync(grill, "---\nname: batch-grill-me\ndescription: Grill\n---\nGrill instructions.\n");
 		const pi = createPi([skill("research", research), skill("batch-grill-me", grill)]);
-		const prompt = "Plan with #research and #batch-grill-me; keep #unknown.";
+		const prompt = "Plan with $research and $batch-grill-me; keep $unknown.";
 
 		const text = expandInlineSkills(prompt, pi);
 
@@ -67,10 +67,24 @@ describe("inline-skills", () => {
 		tempDirs.push(dir);
 		const file = join(dir, "research.md");
 		writeFileSync(file, "---\ndescription: Research\n---\nResearch instructions.\n");
-		const text = expandInlineSkills("Use #research, then #research again", createPi([skill("research", file)]));
+		const text = expandInlineSkills("Use $research, then $research again", createPi([skill("research", file)]));
 
 		expect(text.match(/<skill name=/g)).toHaveLength(1);
-		expect(text.endsWith("Use #research, then #research again")).toBe(true);
+		expect(text.endsWith("Use $research, then $research again")).toBe(true);
+	});
+
+	it("falls back to the base provider instead of rejecting when getCommands throws", async () => {
+		const pi = {
+			getCommands: vi.fn(() => {
+				throw new Error("getCommands failed");
+			}),
+			on: vi.fn(),
+		} as unknown as ExtensionAPI;
+		const base = { getSuggestions: vi.fn(async () => null), applyCompletion: vi.fn() } as any;
+		const provider = createInlineSkillAutocompleteProvider(pi, base);
+
+		await expect(provider.getSuggestions(["$res"], 0, 4, {} as any)).resolves.toBeNull();
+		expect(base.getSuggestions).toHaveBeenCalled();
 	});
 
 	it("registers autocomplete and transforms interactive input", () => {
@@ -87,10 +101,10 @@ describe("inline-skills", () => {
 
 		inlineSkillsExtension(pi);
 		handlers.get("session_start")!({}, { ui: { addAutocompleteProvider } } as unknown as ExtensionContext);
-		const result = handlers.get("input")!({ text: "Use #research now", source: "interactive" });
+		const result = handlers.get("input")!({ text: "Use $research now", source: "interactive" });
 
 		expect(addAutocompleteProvider).toHaveBeenCalledOnce();
-		expect(result).toMatchObject({ action: "transform", text: expect.stringMatching(/<skill[\s\S]*Use #research now$/) });
-		expect(handlers.get("input")!({ text: "#research", source: "extension" })).toEqual({ action: "continue" });
+		expect(result).toMatchObject({ action: "transform", text: expect.stringMatching(/<skill[\s\S]*Use \$research now$/) });
+		expect(handlers.get("input")!({ text: "$research", source: "extension" })).toEqual({ action: "continue" });
 	});
 });