@selesai/code 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.8.0] - 2026-08-11
+
+### Added
+- **Powerline footer upgraded through upstream 0.12.3.** The bundled workspace now has a file-backed queue/inbox (`# <idea>`, `/idea`, `/ideas`, and `/queue`), compaction-safe prompt delivery, session-aware `/cd`, configurable layout/placement/separators, currency and subagent cost display, git-host icons, and faster cached token statistics.
+- **Inline agent mentions work wherever they are intentional.** A known `#agent-name` can invoke an agent at the start, middle, or end of a message; ordinary mid-message hashes such as `issue #42` still pass through.
+- **Agent Browser setup is bundled.** Selesai can guide and, after confirmation, provision the external browser-automation CLI without blocking startup.
+
+### Fixed
+- **Reliable `#`/`$` inline autocomplete (also fixes WSL).** The `#` agent picker no longer runs full agent discovery (builtin/user/project/package dirs plus node_modules walks) synchronously on every keystroke — results are cached per cwd with a short TTL. This matters especially under WSL: running from a Linux-side directory gives the app a `\\wsl.localhost\...` UNC cwd, where the discovery walk costs ~1s per keystroke and the editor's serialized request pipeline then drops/delays `#` (and queued `$`/`@`) suggestions while typing. A failed discovery or `getCommands` error now also falls back to the base provider instead of rejecting the editor's shared autocomplete request chain, which previously permanently disabled `#`, `$`, `@`, and Tab completion for the rest of the session.
+- **No startup-blocking tool downloads.** The `rtk` extension previously ran `ensureTool("rtk")` inside its extension factory, so a missing/mismatched rtk binary triggered a GitHub download (with 120s timeouts) that blocked the entire startup — repeated every launch while the managed binary failed to install. Provisioning now runs after startup completes; bash commands issued before the hook is ready pass through un-rewritten. `fd`/`rg` provisioning at interactive init (pre-existing) remains the only awaited download.
+
 ## [0.7.0] - 2026-08-07
 
 ### Added

package/README.md

@@ -90,10 +90,11 @@ The bundled `pi-powerline-footer` improves the interactive display with:
 
 - a powerline status bar for model, thinking level, path, git state, context, tokens, cost, cache, and session data
 - a fixed-editor layout that keeps the editor and status area visible while chat scrolls
+- a file-backed queue/inbox for deferred ideas and compaction-safe prompts (`# <idea>`, `/idea`, `/ideas`, and `/queue`), plus session-aware `/cd`
 - a recurring `/guide` tour with compact and remembered-dismissal modes, covering workflows, delegation/research prompts, skills, handoff, and recovery
 - persistent bash mode with shell state, transcript output, history, and ghost suggestions
 - editor stash/restore, prompt history, clipboard shortcuts, and message-jump shortcuts
-- themed working-vibe messages, Nerd Font detection, and configurable presets
+- themed working-vibe messages, Nerd Font detection, configurable presets, layout, placement, and cost display
 
 ### Coordination between sessions
 
@@ -126,13 +127,14 @@ Skills are shipped with Selesai and loaded at boot. They include:
 
 - `ponytail` for minimal implementation mode and review helpers
 - `grill-me` for requirement and design stress-testing
+- `agent-browser` for browser-automation setup and CLI workflows
 - `planger` and `implanger` for decomposed planning and execution
 - `handoff` and `handoff-text` for session continuity
 - `improve-codebase` for architecture and maintainability reviews
 - `ponytail-review`, `ponytail-audit`, `ponytail-gain`, `ponytail-debt`, and `ponytail-help`
 - `workflow-creation` for building durable workflow modes
 
-Invoke one with `/skill:<name>`.
+Invoke one inline with `$skill-name` (for example, `$grill-me`).
 
 ## Why the extensions are bundled
 

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

@@ -73,6 +73,20 @@ describe("inline-skills", () => {
 		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", () => {
 		const dir = mkdtempSync(join(tmpdir(), "inline-skills-"));
 		tempDirs.push(dir);

package/dist/extensions/inline-skills.ts

@@ -34,13 +34,20 @@ export function createInlineSkillAutocompleteProvider(pi: ExtensionAPI, current:
 				return current.getSuggestions(lines, cursorLine, cursorCol, options);
 			}
 
-			const items: AutocompleteItem[] = getSkillCommands(pi)
-				.filter((command) => getSkillName(command).includes(token.toLowerCase()))
-				.map((command) => ({
-					value: `$${getSkillName(command)}`,
-					label: `$${getSkillName(command)}`,
-					description: command.description,
-				}));
+			let items: AutocompleteItem[];
+			try {
+				items = getSkillCommands(pi)
+					.filter((command) => getSkillName(command).includes(token.toLowerCase()))
+					.map((command) => ({
+						value: `$${getSkillName(command)}`,
+						label: `$${getSkillName(command)}`,
+						description: command.description,
+					}));
+			} catch {
+				// Never let a getCommands failure reject the editor's shared autocomplete
+				// request chain (a single rejection permanently disables all autocomplete).
+				return current.getSuggestions(lines, cursorLine, cursorCol, options);
+			}
 
 			return items.length > 0 ? { prefix: `$${token}`, items } : current.getSuggestions(lines, cursorLine, cursorCol, options);
 		},

package/dist/extensions/package.json

@@ -5,7 +5,8 @@
 	"description": "Built-in extensions shipped with @selesai/code, loaded via additionalExtensionPaths at boot.",
 	"pi": {
 		"extensions": [
-			"./copy-turn.ts",
+			"./agent-browser.ts",
+		"./copy-turn.ts",
 			"./context-compaction-reminder.ts",
 			"./pi-intercom/index.ts",
 			"./ponytail/index.js",

package/dist/extensions/pi-powerline-footer/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: test (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+      - name: Install devDependencies
+        run: npm ci --ignore-scripts
+      - name: Typecheck
+        run: npm run typecheck
+      - name: Unit tests
+        run: npm test