@selesai/code 0.7.0 → 0.8.0

package/dist/extensions/pi-powerline-footer/working-vibes.ts

@@ -2,13 +2,35 @@
 // AI-generated contextual working messages that match a user's preferred theme/vibe.
 // Uses module-level state (matching powerline-footer pattern).
 
-import { complete, type Context } from "@earendil-works/pi-ai";
-import { getAgentDir, getSettingsPath, type ExtensionContext } from "@selesai/code";
+import type { AssistantMessage, Context, Model, ProviderStreamOptions } from "@earendil-works/pi-ai";
+import { getSettingsPath, type ExtensionContext } from "@selesai/code";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { getAgentPath } from "./paths.ts";
 
 type VibeMode = "generate" | "file";
 
+// Extension-registered providers live in the model registry only: their custom `api` values
+// are absent from pi-ai's global api table, so streaming has to go through the provider.
+// Credential-derived base URLs are resolved per request, mirroring ModelRuntime.prepareRequest;
+// getApiKeyAndHeaders() covers the rest of the request auth but never reports a base URL.
+async function completeVibe(
+  providerId: string,
+  model: Model<string>,
+  context: Context,
+  options: ProviderStreamOptions,
+): Promise<AssistantMessage> {
+  const registry = extensionCtx?.modelRegistry;
+  const provider = registry?.getProvider(providerId);
+  if (!registry || !provider) {
+    throw new Error(`Provider not registered: ${providerId}`);
+  }
+
+  const baseUrl = (await registry.getProviderAuth(providerId))?.auth.baseUrl;
+  const requestModel = baseUrl ? { ...model, baseUrl } : model;
+  return provider.stream(requestModel, context, options).result();
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
 // ═══════════════════════════════════════════════════════════════════════════
@@ -202,7 +224,7 @@ function saveModelConfig(): boolean {
 // ═══════════════════════════════════════════════════════════════════════════
 
 function getVibesDir(): string {
-  return join(getAgentDir(), "vibes");
+  return getAgentPath("vibes");
 }
 
 function toVibeFileSlug(theme: string): string {
@@ -395,8 +417,7 @@ async function generateVibe(
   }
 
   const aiContext = buildAiContext(buildVibePrompt(ctx));
-
-  const response = await complete(model, aiContext, { apiKey: auth.apiKey, headers: auth.headers, signal });
+  const response = await completeVibe(provider, model, aiContext, { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal });
 
   const textContent = response.content.find(c => c.type === "text");
   if (!textContent?.text && response.stopReason === "error" && response.errorMessage) {
@@ -593,11 +614,23 @@ export function getVibeFileCount(theme: string): number {
   return vibes.length;
 }
 
-export interface GenerateVibesResult {
-  success: boolean;
-  count: number;
-  filePath: string;
-  error?: string;
+export type GenerateVibesResult =
+  | { success: true; count: number; filePath: string }
+  | { success: false; count: 0; filePath: string; error: string };
+
+export function parseVibeGenerateArgs(args: readonly string[]): { theme: string; count: number } | null {
+  if (args.length === 0) return null;
+
+  const last = args.at(-1);
+  const parsedCount = last && /^\d+$/.test(last) ? Number.parseInt(last, 10) : Number.NaN;
+  const hasCount = Number.isFinite(parsedCount) && args.length > 1;
+  const theme = hasCount ? args.slice(0, -1).join(" ") : args.join(" ");
+  if (!theme) return null;
+
+  return {
+    theme,
+    count: hasCount ? Math.min(Math.max(Math.floor(parsedCount), 1), 500) : 100,
+  };
 }
 
 export async function generateVibesBatch(
@@ -641,7 +674,7 @@ export async function generateVibesBatch(
   try {
     // Use longer timeout for batch generation (30 seconds)
     const signal = AbortSignal.timeout(30000);
-    const response = await complete(model, aiContext, { apiKey: auth.apiKey, headers: auth.headers, signal });
+    const response = await completeVibe(provider, model, aiContext, { apiKey: auth.apiKey, headers: auth.headers, env: auth.env, signal });
 
     const textContent = response.content.find(c => c.type === "text");
     if (!textContent?.text) {

package/dist/extensions/pi-subagents/package-lock.json

@@ -20,7 +20,7 @@
         "@earendil-works/pi-agent-core": "0.81.0",
         "@earendil-works/pi-ai": "0.81.0",
         "@earendil-works/pi-tui": "0.81.0",
-        "@selesai/code": "0.7.0",
+        "@selesai/code": "0.8.0",
         "@types/node": "24.13.3",
         "typescript": "5.9.3"
       },
@@ -47,7 +47,7 @@
     },
     "../../..": {
       "name": "@selesai/code",
-      "version": "0.7.0",
+      "version": "0.8.0",
       "dev": true,
       "dependencies": {
         "@earendil-works/pi-agent-core": "0.83.0",

package/dist/extensions/pi-subagents/package.json

@@ -97,7 +97,7 @@
   "devDependencies": {
     "@earendil-works/pi-agent-core": "0.81.0",
     "@earendil-works/pi-ai": "0.81.0",
-    "@selesai/code": "0.7.0",
+    "@selesai/code": "0.8.0",
     "@earendil-works/pi-tui": "0.81.0",
     "@types/node": "24.13.3",
     "typescript": "5.9.3"

package/dist/extensions/pi-subagents/src/slash/inline-subagents.ts

@@ -1,31 +1,62 @@
 import type { ExtensionAPI } from "@selesai/code";
 import type { AutocompleteItem, AutocompleteProvider } from "@earendil-works/pi-tui";
-import { discoverAgents, resolveAgentName } from "../agents/agents.ts";
+import { discoverAgents, resolveAgentName, type AgentConfig } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import type { SubagentState } from "../shared/types.ts";
 import { launchSlashSubagent } from "./slash-commands.ts";
 
-/** `#agent-name` at the very start of a message, followed by end-of-line or a space. */
-const INLINE_AGENT_TOKEN_RE = /^#([a-z0-9]+(?:-[a-z0-9]+)*)(?=\s|$)/i;
+/** `#agent-name` anywhere in a message (start, middle, or end), like `$skill-name`. */
+const INLINE_AGENT_TOKEN_RE = /(^|[^a-z0-9_-])#([a-z0-9]+(?:-[a-z0-9]+)*)(?![a-z0-9_-])/i;
 
 /**
  * Parse an inline subagent invocation from raw input.
- * Returns the (lowercased) agent name and the task text, or null when the
- * message does not start with a `#agent-name` token.
+ * Returns the (lowercased) agent name, the task text after the mention, and
+ * whether the mention is at the start of the input (leading whitespace counts).
+ * Returns null when the text contains no `#agent-name` token.
  */
-export function parseInlineSubagentInput(text: string): { agentName: string; task: string } | null {
-	const trimmed = text.trimStart();
-	const match = trimmed.match(INLINE_AGENT_TOKEN_RE);
+export function parseInlineSubagentInput(text: string): { agentName: string; task: string; atStart: boolean } | null {
+	const match = text.match(INLINE_AGENT_TOKEN_RE);
 	if (!match) return null;
-	return { agentName: (match[1] ?? "").toLowerCase(), task: trimmed.slice(match[0].length).trim() };
+	const index = match.index ?? 0;
+	return {
+		agentName: (match[2] ?? "").toLowerCase(),
+		task: text.slice(index + match[0].length).trim(),
+		atStart: text.slice(0, index).trim() === "",
+	};
 }
 
-/** Text before the cursor: `#` optionally followed by a partial agent name (message start only). */
+/** Text before the cursor: `#` optionally followed by a partial agent name (anywhere on the line). */
 function getInlineAgentToken(textBeforeCursor: string): string | undefined {
-	const match = textBeforeCursor.match(/^#([a-z0-9-]*)$/i);
+	const match = textBeforeCursor.match(/(?:^|[^a-z0-9_-])#([a-z0-9-]*)$/i);
 	return match ? match[1] ?? "" : undefined;
 }
 
+// Agent discovery walks builtin+user+project+package agent dirs and node_modules,
+// which is far too slow to run synchronously on every `#` keystroke (it blocks the
+// event loop and the editor drops results while typing). Cache per cwd with a short
+// TTL so the picker is responsive; a failed discovery is cached as empty so a single
+// malformed agent file cannot keep blocking the editor (nor reject its shared
+// autocomplete request chain, which would permanently kill all autocomplete).
+const AGENT_DISCOVERY_CACHE_TTL_MS = 5_000;
+const agentDiscoveryCache = new Map<string, { expiry: number; agents: AgentConfig[] }>();
+
+function discoverAgentsForPicker(cwd: string): AgentConfig[] {
+	const now = Date.now();
+	const cached = agentDiscoveryCache.get(cwd);
+	if (cached && cached.expiry > now) {
+		return cached.agents;
+	}
+	let agents: AgentConfig[] = [];
+	try {
+		agents = discoverAgents(cwd, "both").agents;
+	} catch {
+		// Never let agent discovery break autocomplete; the editor's shared request
+		// chain stays poisoned forever after a single rejected getSuggestions.
+	}
+	agentDiscoveryCache.set(cwd, { expiry: now + AGENT_DISCOVERY_CACHE_TTL_MS, agents });
+	return agents;
+}
+
 export function createInlineSubagentAutocompleteProvider(
 	state: SubagentState,
 	current: AutocompleteProvider,
@@ -33,16 +64,17 @@ export function createInlineSubagentAutocompleteProvider(
 	return {
 		triggerCharacters: ["#"],
 		async getSuggestions(lines, cursorLine, cursorCol, options) {
-			// Subagent invocations are whole-message actions: only trigger at the start of the first line.
-			if (cursorLine !== 0 || !state.baseCwd) {
+			// Like the $ skill picker, # works anywhere on the current line, not just
+			// at the start of the message.
+			if (!state.baseCwd) {
 				return current.getSuggestions(lines, cursorLine, cursorCol, options);
 			}
-			const token = getInlineAgentToken((lines[0] ?? "").slice(0, cursorCol));
+			const token = getInlineAgentToken((lines[cursorLine] ?? "").slice(0, cursorCol));
 			if (token === undefined) {
 				return current.getSuggestions(lines, cursorLine, cursorCol, options);
 			}
 
-			const items: AutocompleteItem[] = discoverAgents(state.baseCwd, "both").agents
+			const items: AutocompleteItem[] = discoverAgentsForPicker(state.baseCwd)
 				.filter((agent) => agent.name.includes(token.toLowerCase()))
 				.map((agent) => ({
 					value: `#${agent.name}`,
@@ -64,9 +96,10 @@ export function createInlineSubagentAutocompleteProvider(
 }
 
 /**
- * `#agent-name [task]` inline subagent invocation: typing `#` at the start of a
- * message suggests installed agents; sending `#agent-name task` runs that agent
- * (same path as `/run agent task`) instead of sending the text to the main agent.
+ * `#agent-name [task]` inline subagent invocation: typing `#` anywhere in a
+ * message suggests installed agents; sending a message that contains
+ * `#agent-name` runs that agent (same path as `/run agent task`) instead of
+ * sending the text to the main agent.
  */
 export function registerInlineSubagentInvocation(pi: ExtensionAPI, state: SubagentState): void {
 	pi.on("session_start", (_event, ctx) => {
@@ -82,12 +115,12 @@ export function registerInlineSubagentInvocation(pi: ExtensionAPI, state: Subage
 
 		const agents = discoverAgents(state.baseCwd, "both").agents;
 		const resolved = resolveAgentName(parsed.agentName, agents);
-		if (resolved.error) {
-			ctx.ui.notify?.(resolved.error, "warning");
-			return { action: "handled" };
-		}
-		if (!resolved.agent) {
-			ctx.ui.notify?.(`Unknown subagent: #${parsed.agentName}`, "warning");
+		if (resolved.error || !resolved.agent) {
+			// A #mention that does not resolve only consumes the input when it is an
+			// explicit invocation at the start of the message. Mid-message mentions
+			// (e.g. "issue #42") must never swallow the user's text.
+			if (!parsed.atStart) return { action: "continue" };
+			ctx.ui.notify?.(resolved.error ?? `Unknown subagent: #${parsed.agentName}`, "warning");
 			return { action: "handled" };
 		}
 

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

@@ -1,12 +1,67 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { parseInlineSubagentInput } from "../../src/slash/inline-subagents.ts";
+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,
 		});
 	});
 
@@ -14,24 +69,42 @@ describe("parseInlineSubagentInput", () => {
 		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: "" });
+		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" });
+		assert.deepEqual(parseInlineSubagentInput("#Architect plan"), { agentName: "architect", task: "plan", atStart: true });
 	});
 
 	it("allows leading whitespace", () => {
-		assert.deepEqual(parseInlineSubagentInput("  #architect plan"), { agentName: "architect", task: "plan" });
+		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 when the message does not start with #agent", () => {
+	it("returns null without a #mention", () => {
 		assert.equal(parseInlineSubagentInput("review the plan"), null);
-		assert.equal(parseInlineSubagentInput("the #architect review"), null);
+		assert.equal(parseInlineSubagentInput("pre#architect"), null);
 		assert.equal(parseInlineSubagentInput("#"), null);
 		assert.equal(parseInlineSubagentInput("#-architect"), null);
 	});
@@ -40,6 +113,7 @@ describe("parseInlineSubagentInput", () => {
 		assert.deepEqual(parseInlineSubagentInput("#architectreview"), {
 			agentName: "architectreview",
 			task: "",
+			atStart: true,
 		});
 	});
 
@@ -47,6 +121,7 @@ describe("parseInlineSubagentInput", () => {
 		assert.deepEqual(parseInlineSubagentInput("#architect   review the plan   "), {
 			agentName: "architect",
 			task: "review the plan",
+			atStart: true,
 		});
 	});
 });

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

@@ -26,7 +26,7 @@ const expectedHostPeerRanges = {
 const expectedHostDevVersions = {
 	"@earendil-works/pi-agent-core": "0.81.0",
 	"@earendil-works/pi-ai": "0.81.0",
-	"@selesai/code": "0.7.0",
+	"@selesai/code": "0.8.0",
 	"@earendil-works/pi-tui": "0.81.0",
 } satisfies Record<(typeof hostPeerPackages)[number], string>;
 

package/dist/extensions/ponytail/index.js

@@ -56,25 +56,6 @@ export { writeDefaultMode };
 export default function ponytailExtension(pi) {
   let currentMode = DEFAULT_MODE;
   let configuredDefaultMode = getDefaultMode();
-  let isActive = false;
-  let lastCtx = null;
-
-  // -- Status bar --
-  function syncStatus(ctx) {
-    if (ctx) lastCtx = ctx;
-    const c = ctx || lastCtx;
-    if (!c?.ui?.setStatus || !c.ui.theme?.fg) return;
-    const theme = c.ui.theme;
-    if (currentMode === "off") {
-      c.ui.setStatus("ponytail", "");
-      return;
-    }
-    const levelIcons = { lite: "🌿", full: "⚡", ultra: "🔥" };
-    const icon = levelIcons[currentMode] || "";
-    const label = currentMode.toUpperCase();
-    const indicator = isActive ? theme.fg("accent", "●") : theme.fg("dim", "○");
-    c.ui.setStatus("ponytail", indicator + " 🐴 " + theme.fg("muted", "ponytail: ") + theme.fg("text", icon + " " + label));
-  }
 
   const setMode = (mode, ctx) => {
     const normalized = normalizePersistedMode(mode);
@@ -82,7 +63,6 @@ export default function ponytailExtension(pi) {
 
     currentMode = normalized;
     pi.appendEntry("ponytail-mode", { mode: normalized });
-    syncStatus(ctx);
     ctx?.ui?.notify?.(`Ponytail mode set to ${normalized}.`, "info");
   };
 
@@ -168,20 +148,10 @@ export default function ponytailExtension(pi) {
     const entries = ctx?.sessionManager?.getBranch?.() || ctx?.sessionManager?.getEntries?.() || [];
     configuredDefaultMode = getDefaultMode();
     currentMode = resolveSessionMode(entries, configuredDefaultMode);
-    syncStatus(ctx);
+    ctx?.ui?.setStatus?.("ponytail", undefined);
     ctx?.ui?.notify?.(`Ponytail loaded: ${currentMode}`, "info");
   });
 
-  pi.on("agent_start", async (_event, ctx) => {
-    isActive = true;
-    syncStatus(ctx);
-  });
-
-  pi.on("agent_end", async (_event, ctx) => {
-    isActive = false;
-    syncStatus(ctx);
-  });
-
   pi.on("before_agent_start", async (event) => {
     if (!currentMode || currentMode === "off") return;
     return { systemPrompt: `${event.systemPrompt}\n\n${getPonytailInstructions(currentMode, { compact: true })}` };

package/dist/extensions/ponytail/test/extension.test.js

@@ -152,32 +152,15 @@ test("a request mentioning normal mode stays active", async () => withTempConfig
   assert.match(result.systemPrompt, /PONYTAIL ULTRA:/);
 }));
 
-test("status bar renders the mode and flips active on agent_start", async () => withTempConfig(async () => {
-  const { events } = createPiHarness();
+test("session_start clears the legacy status without rendering a replacement", async () => withTempConfig(async () => {
+  const { commands, events } = createPiHarness();
   const statusWrites = [];
   const ctx = createCommandContext({
-    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
-    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }), theme: { fg: (_color, text) => text } },
+    ui: { notify() {}, setStatus: (key, text) => statusWrites.push({ key, text }) },
   });
 
   await events.get("session_start")({ reason: "resume" }, ctx);
-  await events.get("agent_start")({}, ctx);
-
-  assert.equal(statusWrites.at(-2).key, "ponytail");
-  assert.match(statusWrites.at(-2).text, /○.*ULTRA/);
-  assert.match(statusWrites.at(-1).text, /●.*ULTRA/);
-}));
-
-test("status bar stays silent when ui lacks a theme", async () => withTempConfig(async () => {
-  const { events } = createPiHarness();
-  const calls = [];
-  const ctx = createCommandContext({
-    sessionManager: { getEntries: () => [{ type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } }] },
-    ui: { notify() {}, setStatus: (_key, text) => calls.push(text) }, // setStatus present, theme absent
-  });
-
-  await events.get("session_start")({ reason: "resume" }, ctx);
-  await events.get("agent_start")({}, ctx);
+  await commands.get("ponytail").handler("ultra", ctx);
 
-  assert.deepEqual(calls, []);
+  assert.deepEqual(statusWrites, [{ key: "ponytail", text: undefined }]);
 }));

package/dist/extensions/rtk.test.ts

@@ -1,8 +1,16 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execFile } from "node:child_process";
+
+const { ensureToolMock } = vi.hoisted(() => ({ ensureToolMock: vi.fn() }));
+
+vi.mock("@selesai/code", async (importOriginal) => ({
+	...(await importOriginal<typeof import("@selesai/code")>()),
+	ensureTool: ensureToolMock,
+}));
+
 import rtkExtension from "./rtk.ts";
 
 // The fake-binary tests need a POSIX shell shim. Windows CI cannot spawn
@@ -55,10 +63,9 @@ function makePi() {
 	return { pi: pi as any, handlers };
 }
 
-function getToolCall(handlers: Map<string, Function[]>): Function {
-	const toolCall = handlers.get("tool_call")?.[0];
-	if (!toolCall) throw new Error("no tool_call handler registered");
-	return toolCall;
+async function getToolCall(handlers: Map<string, Function[]>): Promise<Function> {
+	await vi.waitFor(() => expect(handlers.has("tool_call")).toBe(true));
+	return handlers.get("tool_call")![0]!;
 }
 
 let fakeDir: string;
@@ -70,6 +77,11 @@ beforeAll(() => {
 	process.env.PATH = `${join(fakeDir, "bin")}${oldPath ? ":" + oldPath : ""}`;
 });
 
+beforeEach(() => {
+	ensureToolMock.mockReset();
+	ensureToolMock.mockResolvedValue("rtk");
+});
+
 afterEach(() => {
 	vi.restoreAllMocks();
 });
@@ -83,28 +95,29 @@ afterAll(() => {
 posixOnly("rtk extension", () => {
 	it("registers a tool_call hook and rewrites compatible bash commands", async () => {
 		const { pi, handlers } = makePi();
-		await rtkExtension(pi);
+		rtkExtension(pi);
 
 		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
-		await getToolCall(handlers)(event, { signal: undefined });
+		await (await getToolCall(handlers))(event, { signal: undefined });
 		expect(event.input.command).toBe("rtk git status");
 	});
 
 	it("skips commands that already start with rtk", async () => {
 		const { pi, handlers } = makePi();
-		await rtkExtension(pi);
+		rtkExtension(pi);
 
 		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "rtk git status" } };
-		await getToolCall(handlers)(event, { signal: undefined });
+		await (await getToolCall(handlers))(event, { signal: undefined });
 		expect(event.input.command).toBe("rtk git status");
 	});
 
-	it("does not register a hook when rtk is disabled", async () => {
+	it("does not register a hook when rtk is disabled", () => {
 		process.env.RTK_DISABLED = "1";
 		try {
 			const { pi, handlers } = makePi();
-			await rtkExtension(pi);
+			rtkExtension(pi);
 			expect(handlers.has("tool_call")).toBe(false);
+			expect(ensureToolMock).not.toHaveBeenCalled();
 		} finally {
 			delete process.env.RTK_DISABLED;
 		}
@@ -115,8 +128,10 @@ posixOnly("rtk extension", () => {
 		const previousPath = process.env.PATH;
 		process.env.PATH = `${join(wrongDir, "bin")}${previousPath ? ":" + previousPath : ""}`;
 		try {
+			const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
 			const { pi, handlers } = makePi();
-			await rtkExtension(pi);
+			rtkExtension(pi);
+			await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("rtk gain failed")));
 			expect(handlers.has("tool_call")).toBe(false);
 		} finally {
 			if (previousPath) process.env.PATH = previousPath;