@selesai/code 0.6.3 → 0.8.0

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

@@ -159,13 +159,27 @@ describe("worktree", () => {
 		}
 	});
 
+	it("createWorktrees ignores pi-subagents runtime artifacts in the source checkout", () => {
+		const repoDir = createRepo("pi-worktree-runtime-artifacts-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			fs.mkdirSync(path.join(repoDir, ".pi-subagents", "missions"), { recursive: true });
+			fs.writeFileSync(path.join(repoDir, ".pi-subagents", "missions", "mission.json"), "{}\n", "utf-8");
+			setup = createWorktrees(repoDir, "runtime-artifacts", 1);
+			assert.equal(setup.worktrees.length, 1);
+		} finally {
+			if (setup) cleanupWorktrees(setup);
+			cleanupRepo(repoDir);
+		}
+	});
+
 	it("findWorktreeTaskCwdConflict allows omitted or matching task cwd values", () => {
 		const sharedCwd = path.join("/tmp", "repo");
 		assert.equal(
 			findWorktreeTaskCwdConflict(
 				[
-					{ agent: "worker-a" },
-					{ agent: "worker-b", cwd: sharedCwd },
+					{ agent: "builder-a" },
+					{ agent: "builder-b", cwd: sharedCwd },
 				],
 				sharedCwd,
 			),
@@ -177,7 +191,7 @@ describe("worktree", () => {
 		const sharedCwd = path.join("/tmp", "repo");
 		assert.equal(
 			findWorktreeTaskCwdConflict(
-				[{ agent: "worker-a", cwd: "." }],
+				[{ agent: "builder-a", cwd: "." }],
 				sharedCwd,
 			),
 			undefined,
@@ -188,14 +202,14 @@ describe("worktree", () => {
 		const sharedCwd = path.join("/tmp", "repo");
 		const conflict = findWorktreeTaskCwdConflict(
 			[
-				{ agent: "worker-a", cwd: sharedCwd },
-				{ agent: "worker-b", cwd: path.join(sharedCwd, "packages", "app") },
+				{ agent: "builder-a", cwd: sharedCwd },
+				{ agent: "builder-b", cwd: path.join(sharedCwd, "packages", "app") },
 			],
 			sharedCwd,
 		);
 		assert.deepEqual(conflict, {
 			index: 1,
-			agent: "worker-b",
+			agent: "builder-b",
 			cwd: path.join(sharedCwd, "packages", "app"),
 		});
 	});
@@ -208,7 +222,7 @@ describe("worktree", () => {
 
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repoDir, "diff", 1);
+			setup = createWorktrees(repoDir, `diff-${process.pid}`, 1);
 			const worktree = setup.worktrees[0]!;
 			fs.writeFileSync(path.join(worktree.path, "committed.ts"), "export const committed = true;\n", "utf-8");
 			git(worktree.path, ["add", "committed.ts"]);
@@ -234,7 +248,7 @@ describe("worktree", () => {
 			assert.match(summary, /=== Worktree Changes ===/);
 			assert.match(summary, /Full patches:/);
 		} finally {
-			if (setup) cleanupWorktrees(setup);
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
 			cleanupRepo(repoDir);
 		}
 	});
@@ -266,6 +280,87 @@ describe("worktree", () => {
 		}
 	});
 
+	it("preserves dirty worktrees when no patch was captured", () => {
+		const repoDir = createRepo("pi-worktree-uncaptured-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repoDir, "uncaptured", 1);
+			const worktree = setup.worktrees[0]!;
+			fs.writeFileSync(path.join(worktree.path, "tracked.txt"), "uncaptured\n", "utf-8");
+
+			const cleanup = cleanupWorktrees(setup);
+			assert.equal(cleanup.state, "partial");
+			assert.equal(cleanup.tasks[0]?.preserved, true);
+			assert.match(cleanup.tasks[0]?.reason ?? "", /not represented by a captured handoff patch/);
+			assert.equal(fs.existsSync(worktree.path), true);
+			assert.notEqual(git(repoDir, ["branch", "--list", worktree.branch]), "");
+
+			const unconfirmed = cleanupWorktrees(setup, { kind: "discard", authorization: { kind: "policy" } });
+			assert.equal(unconfirmed.state, "partial");
+			assert.match(unconfirmed.tasks[0]?.reason ?? "", /confirmation/);
+			const discarded = cleanupWorktrees(setup, { kind: "discard", authorization: { kind: "confirmed" } });
+			assert.equal(discarded.state, "complete");
+			setup = undefined;
+		} finally {
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
+			cleanupRepo(repoDir);
+		}
+	});
+
+	it("preserves committed branch work when no patch was captured", () => {
+		const repoDir = createRepo("pi-worktree-committed-uncaptured-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repoDir, "committed-uncaptured", 1);
+			const worktree = setup.worktrees[0]!;
+			fs.writeFileSync(path.join(worktree.path, "committed.txt"), "unlanded commit\n", "utf-8");
+			git(worktree.path, ["add", "committed.txt"]);
+			git(worktree.path, ["commit", "-m", "unlanded work"]);
+			assert.equal(git(worktree.path, ["status", "--porcelain"]), "");
+
+			const cleanup = cleanupWorktrees(setup);
+			assert.equal(cleanup.state, "partial");
+			assert.equal(cleanup.tasks[0]?.preserved, true);
+			assert.equal(fs.existsSync(worktree.path), true);
+
+			cleanupWorktrees(setup, { kind: "discard", authorization: { kind: "confirmed" } });
+			setup = undefined;
+		} finally {
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
+			cleanupRepo(repoDir);
+		}
+	});
+
+	it("removes dirty worktrees only after their captured patch is recorded in the handoff manifest", () => {
+		const repoDir = createRepo("pi-worktree-captured-");
+		let setup: WorktreeSetup | undefined;
+		try {
+			setup = createWorktrees(repoDir, "captured", 1);
+			const worktreePath = setup.worktrees[0]!.path;
+			fs.writeFileSync(path.join(worktreePath, "tracked.txt"), "captured\n", "utf-8");
+			const diffs = diffWorktrees(setup, ["builder"], path.join(repoDir, "artifacts", "captured"));
+			assert.equal(diffs[0]?.error, undefined);
+			assert.ok(fs.statSync(diffs[0]!.patchPath).size > 0);
+
+			const withoutManifest = cleanupWorktrees(setup, { kind: "preserve", capturedDiffs: diffs });
+			assert.equal(withoutManifest.state, "partial");
+			assert.equal(fs.existsSync(worktreePath), true);
+
+			const handoffManifestPath = path.join(repoDir, "artifacts", "handoff.json");
+			fs.writeFileSync(handoffManifestPath, JSON.stringify({
+				version: 1,
+				groups: [{ children: [{ patch: { path: diffs[0]!.patchPath } }] }],
+			}), "utf-8");
+			const cleanup = cleanupWorktrees(setup, { kind: "preserve", capturedDiffs: diffs, handoffManifestPath });
+			assert.equal(cleanup.state, "complete");
+			assert.equal(fs.existsSync(worktreePath), false);
+			setup = undefined;
+		} finally {
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
+			cleanupRepo(repoDir);
+		}
+	});
+
 	it("createWorktrees creates node_modules symlink when node_modules exists", {
 		skip: process.platform === "win32" ? "Symlink behavior differs on Windows CI environments." : undefined,
 	}, () => {
@@ -302,7 +397,7 @@ describe("worktree", () => {
 
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repoDir, "tracked-node-modules", 1);
+			setup = createWorktrees(repoDir, `tracked-node-modules-${process.pid}`, 1);
 			assert.equal(setup.worktrees[0]!.nodeModulesLinked, false);
 			assert.deepEqual(setup.worktrees[0]!.syntheticPaths, []);
 			fs.writeFileSync(path.join(setup.worktrees[0]!.path, "tracked.txt"), "modified\n", "utf-8");
@@ -313,7 +408,7 @@ describe("worktree", () => {
 			assert.doesNotMatch(patch, /diff --git a\/node_modules b\/node_modules/);
 			assert.equal(fs.lstatSync(path.join(setup.worktrees[0]!.path, "node_modules")).isSymbolicLink(), true);
 		} finally {
-			if (setup) cleanupWorktrees(setup);
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
 			cleanupRepo(repoDir);
 		}
 	});
@@ -421,7 +516,7 @@ process.stdout.write(JSON.stringify({ syntheticPaths: [".env.local"] }));
 
 		let setup: WorktreeSetup | undefined;
 		try {
-			setup = createWorktrees(repoDir, "hook-diff", 1, {
+			setup = createWorktrees(repoDir, `hook-diff-${process.pid}`, 1, {
 				setupHook: { hookPath: path.relative(repoDir, hookPath) },
 			});
 			fs.writeFileSync(path.join(setup.worktrees[0]!.path, "tracked.txt"), "modified-by-agent\n", "utf-8");
@@ -430,7 +525,7 @@ process.stdout.write(JSON.stringify({ syntheticPaths: [".env.local"] }));
 			assert.match(patch, /tracked\.txt/);
 			assert.doesNotMatch(patch, /\.env\.local/);
 		} finally {
-			if (setup) cleanupWorktrees(setup);
+			if (setup) cleanupWorktrees(setup, { kind: "setup-rollback" });
 			cleanupRepo(repoDir);
 		}
 	});
@@ -481,3 +576,38 @@ setTimeout(() => {
 		}
 	});
 });
+
+describe("manifest-backed worktree discard", () => {
+	it("keeps incomplete cleanup actionable with exact manual Git commands", async () => {
+		const root = fs.mkdtempSync(path.join(os.tmpdir(), "pi-worktree-discard-manifest-"));
+		try {
+			const manifestPath = path.join(root, "handoff.json");
+			const worktreePath = path.join(root, "preserved-worktree");
+			fs.mkdirSync(worktreePath);
+			fs.writeFileSync(manifestPath, JSON.stringify({
+				version: 1,
+				runId: "discard-run",
+				mode: "parallel",
+				source: "foreground",
+				cwd: root,
+				createdAt: 1,
+				updatedAt: 1,
+				groups: [{
+					stepIndex: 0,
+					baseCommit: "deadbeef",
+					repoRoot: root,
+					children: [],
+					cleanup: { state: "partial", pruned: false, tasks: [{ index: 0, path: worktreePath, branch: "pi-parallel-discard", worktreeRemoved: false, branchRemoved: false, preserved: true }] },
+				}],
+			}), "utf-8");
+			const { discardPreservedWorktrees } = await import("../../src/runs/shared/parallel-handoff.ts");
+			const discarded = discardPreservedWorktrees(manifestPath, { kind: "confirmed" });
+			assert.match(discarded.text, /git -C .* worktree remove --force/);
+			assert.match(discarded.text, /branch -D/);
+			assert.equal(discarded.manifest.groups[0]?.cleanup.state, "partial");
+			assert.equal(discarded.manifest.groups[0]?.cleanup.tasks[0]?.preserved, true);
+		} finally {
+			fs.rmSync(root, { recursive: true, force: true });
+		}
+	});
+});

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

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2023"],
+    "types": ["node"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["index.ts", "src/**/*.ts", "src/**/*.d.ts"]
+}

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

@@ -0,0 +1,141 @@
+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
+// .cmd shims without a shell, and the real flow uses the managed rtk.exe
+// there, so the shim tests are POSIX-only.
+const posixOnly = describe.skipIf(process.platform === "win32");
+
+function fakeRtkDir(version: string, gainExit: number): string {
+	const dir = mkdtempSync(join(tmpdir(), "rtk-test-"));
+	const binDir = join(dir, "bin");
+	mkdirSync(binDir, { recursive: true });
+	const bin = join(binDir, "rtk");
+	writeFileSync(
+		bin,
+		`#!/usr/bin/env bash
+case "$1" in
+  --version) echo "rtk ${version}"; exit 0;;
+  gain) echo "RTK Token Savings (Global Scope)"; exit ${gainExit};;
+  rewrite) echo "rtk $2"; exit 3;;
+  *) exit 0;;
+esac
+`,
+		{ mode: 0o755 },
+	);
+	return dir;
+}
+
+function makePi() {
+	const handlers = new Map<string, Function[]>();
+	const pi = {
+		exec: async (cmd: string, args: string[], opts?: { timeout?: number }) =>
+			new Promise((resolve) => {
+				execFile(cmd, args, { timeout: opts?.timeout }, (error, stdout, stderr) => {
+					if (error) {
+						// execFile reports non-zero exits as errors; keep the real exit code.
+						const code =
+							typeof (error as NodeJS.ErrnoException & { code?: unknown }).code === "number"
+								? ((error as any).code as number)
+								: 1;
+						resolve({ code, stdout: stdout ?? "", stderr: stderr ?? "", killed: false });
+					} else {
+						resolve({ code: 0, stdout: stdout ?? "", stderr: stderr ?? "", killed: false });
+					}
+				});
+			}),
+		on: (evt: string, h: Function) => {
+			handlers.set(evt, [...(handlers.get(evt) ?? []), h]);
+		},
+	};
+	return { pi: pi as any, handlers };
+}
+
+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;
+let oldPath: string | undefined;
+
+beforeAll(() => {
+	fakeDir = fakeRtkDir("0.42.0", 0);
+	oldPath = process.env.PATH;
+	process.env.PATH = `${join(fakeDir, "bin")}${oldPath ? ":" + oldPath : ""}`;
+});
+
+beforeEach(() => {
+	ensureToolMock.mockReset();
+	ensureToolMock.mockResolvedValue("rtk");
+});
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+afterAll(() => {
+	if (oldPath) process.env.PATH = oldPath;
+	else delete process.env.PATH;
+	rmSync(fakeDir, { recursive: true, force: true });
+});
+
+posixOnly("rtk extension", () => {
+	it("registers a tool_call hook and rewrites compatible bash commands", async () => {
+		const { pi, handlers } = makePi();
+		rtkExtension(pi);
+
+		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
+		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();
+		rtkExtension(pi);
+
+		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "rtk git status" } };
+		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", () => {
+		process.env.RTK_DISABLED = "1";
+		try {
+			const { pi, handlers } = makePi();
+			rtkExtension(pi);
+			expect(handlers.has("tool_call")).toBe(false);
+			expect(ensureToolMock).not.toHaveBeenCalled();
+		} finally {
+			delete process.env.RTK_DISABLED;
+		}
+	});
+
+	it("does not register a hook for a wrong rtk binary (gain fails)", async () => {
+		const wrongDir = fakeRtkDir("0.40.0", 1);
+		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();
+			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;
+			rmSync(wrongDir, { recursive: true, force: true });
+		}
+	});
+});

package/dist/extensions/rtk.ts

@@ -1,5 +1,5 @@
 // RTK Pi extension — rewrites bash commands to use rtk for token savings.
-// Requires: rtk >= 0.23.0 in PATH.
+// RTK is provisioned into Selesai's managed binary directory when it is missing.
 //
 // This is a thin delegating extension: all rewrite logic lives in `rtk rewrite`,
 // which is the single source of truth (src/discover/registry.rs).
@@ -11,25 +11,57 @@
 //   3 + stdout  Rewrite (advisory) → mutate command
 
 import type { ExtensionAPI } from "@selesai/code"
-import { isToolCallEventType } from "@selesai/code"
+import { ensureTool, isToolCallEventType } from "@selesai/code"
 
 const REWRITE_TIMEOUT_MS = 2_000
 const MIN_SUPPORTED_RTK_MINOR = 23
 
-// Parse "X.Y.Z" semver, return [major, minor, patch] or null.
-function parseSemver(raw: string): [number, number, number] | null {
+// Parse "X.Y.Z" from either `rtk --version` output or a diagnostic string.
+export function parseSemver(raw: string): [number, number, number] | null {
   const m = raw.trim().match(/(\d+)\.(\d+)\.(\d+)/)
   if (!m) return null
   return [parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)]
 }
 
+async function probeRtk(pi: ExtensionAPI, rtkPath: string): Promise<boolean> {
+  const ver = await pi.exec(rtkPath, ["--version"], { timeout: REWRITE_TIMEOUT_MS })
+  if (ver.code !== 0) {
+    console.warn("[rtk] managed binary failed --version — extension disabled")
+    return false
+  }
+
+  const parsed = parseSemver(ver.stdout)
+  if (!parsed) {
+    console.warn(`[rtk] could not parse version from ${ver.stdout.trim() || "<empty output>"} — extension disabled`)
+    return false
+  }
+
+  const [major, minor] = parsed
+  if (major === 0 && minor < MIN_SUPPORTED_RTK_MINOR) {
+    console.warn(`[rtk] ${ver.stdout.trim()} is too old (need >= 0.23.0) — extension disabled`)
+    return false
+  }
+
+  // `rtk` is also the name of an unrelated Rust Type Kit project. `gain` is
+  // the upstream RTK Token Killer identity check and prevents that collision.
+  const identity = await pi.exec(rtkPath, ["gain"], { timeout: REWRITE_TIMEOUT_MS })
+  if (identity.code !== 0) {
+    console.warn("[rtk] binary is not rtk-ai/rtk (rtk gain failed) — extension disabled")
+    console.warn("[rtk] install Rust Token Killer from https://github.com/rtk-ai/rtk")
+    return false
+  }
+
+  return true
+}
+
 // Calls `rtk rewrite`; returns the rewritten command or null (pass through).
 async function rewriteCommand(
   pi: ExtensionAPI,
+  rtkPath: string,
   cmd: string,
   signal?: AbortSignal
 ): Promise<string | null> {
-  const result = await pi.exec("rtk", ["rewrite", cmd], {
+  const result = await pi.exec(rtkPath, ["rewrite", cmd], {
     timeout: REWRITE_TIMEOUT_MS,
     signal,
   })
@@ -38,44 +70,54 @@ async function rewriteCommand(
   return result.stdout.trim() || null
 }
 
-export default async function (pi: ExtensionAPI) {
-  // Probe rtk version at load time; disables extension if missing or too old.
-  const ver = await pi.exec("rtk", ["--version"], { timeout: REWRITE_TIMEOUT_MS })
-  if (ver.code !== 0) {
-    console.warn("[rtk] rtk binary not found in PATH — extension disabled")
-    console.warn("[rtk] you can install rtk-ai to reduce token usage by a lot!")
-    return
-  }
+export default function (pi: ExtensionAPI) {
+  // Explicit opt-out must also prevent an automatic managed-binary download.
+  if (process.env.RTK_DISABLED === "1") return
 
-  // Warn and bail if rtk predates 0.23.0 (when `rtk rewrite` was introduced).
-  const parsed = parseSemver(ver.stdout.replace(/^rtk\s+/, ""))
-  if (parsed) {
-    const [major, minor] = parsed
-    if (major === 0 && minor < MIN_SUPPORTED_RTK_MINOR) {
-      console.warn(`[rtk] rtk ${ver.stdout.trim()} is too old (need >= 0.23.0) — extension disabled`)
+  // Provisioning may download the managed binary from GitHub (with 120s timeouts)
+  // and probe system binaries. Running it in the extension factory would block the
+  // whole startup on a slow/unreachable network, so defer it off the critical path.
+  // Bash commands issued before the hook registers simply pass through un-rewritten.
+  void (async () => {
+    let rtkPath: string | undefined
+    try {
+      rtkPath = await ensureTool("rtk")
+    } catch (err) {
+      console.warn(`[rtk] managed installation failed: ${err instanceof Error ? err.message : String(err)}`)
+    }
+
+    if (!rtkPath) {
+      console.warn("[rtk] unavailable; install from https://github.com/rtk-ai/rtk")
       return
     }
-  }
 
-  pi.on("tool_call", async (event, ctx) => {
     try {
-      if (!isToolCallEventType("bash", event)) return
+      if (!(await probeRtk(pi, rtkPath))) return
+    } catch (err) {
+      console.warn(`[rtk] verification failed: ${err instanceof Error ? err.message : String(err)} — extension disabled`)
+      return
+    }
+
+    pi.on("tool_call", async (event, ctx) => {
+      try {
+        if (!isToolCallEventType("bash", event)) return
 
-      const cmd = event.input.command
-      if (typeof cmd !== "string" || cmd.trim() === "") return
+        const cmd = event.input.command
+        if (typeof cmd !== "string" || cmd.trim() === "") return
 
-      if (cmd.startsWith("rtk ")) return
-      if (process.env.RTK_DISABLED === "1") return
+        if (cmd.trimStart().startsWith("rtk ")) return
+        if (process.env.RTK_DISABLED === "1") return
 
-      // Delegate to RTK.
-      const rewritten = await rewriteCommand(pi, cmd, ctx.signal)
-      if (rewritten && rewritten !== cmd) {
-        event.input.command = rewritten
+        // Delegate to RTK.
+        const rewritten = await rewriteCommand(pi, rtkPath, cmd, ctx.signal)
+        if (rewritten && rewritten !== cmd) {
+          event.input.command = rewritten
+        }
+      } catch (err) {
+        // Fail open: never block execution on an unexpected error.
+        console.warn("[rtk] unexpected error in tool_call handler; passing through command", err)
+        return
       }
-    } catch (err) {
-      // Fail open: never block execution on an unexpected error.
-      console.warn("[rtk] unexpected error in tool_call handler; passing through command", err)
-      return
-    }
-  })
+    })
+  })()
 }

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { type Args, parseArgs } from "./cli/args.ts";
 export { CONFIG_DIR_NAME, getAgentDir, getDocsPath, getModelsPath, getSettingsPath, getExamplesPath, getPackageDir, getReadmePath, VERSION, } from "./config.ts";
 export { AgentSession, type AgentSessionConfig, type AgentSessionEvent, type AgentSessionEventListener, type ModelCycleResult, type ParsedSkillBlock, type ParsedSkillBlocks, type PromptOptions, parseSkillBlock, parseSkillBlocks, type SessionStats, } from "./core/agent-session.ts";
 export { readStoredCredential } from "./core/auth-storage.ts";
+export { ensureTool, getToolPath, type ManagedTool } from "./utils/tools-manager.ts";
 export { type BranchPreparation, type BranchSummaryResult, type CollectEntriesResult, type CompactionResult, type CutPointResult, calculateContextTokens, collectEntriesForBranchSummary, compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, type FileOperations, findCutPoint, findTurnStartIndex, type GenerateBranchSummaryOptions, generateBranchSummary, generateSummary, generateSummaryWithUsage, getLastAssistantUsage, prepareBranchEntries, serializeConversation, shouldCompact, } from "./core/compaction/index.ts";
 export { createEventBus, type EventBus, type EventBusController } from "./core/event-bus.ts";
 export type { AgentEndEvent, AgentSettledEvent, AgentStartEvent, AgentToolResult, AgentToolUpdateCallback, AppKeybinding, AutocompleteProviderFactory, BashToolCallEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BeforeProviderRequestEventResult, BuildSystemPromptOptions, CompactOptions, ContextEvent, ContextUsage, CustomToolCallEvent, EditToolCallEvent, EntryRenderer, EntryRenderOptions, ExecOptions, ExecResult, Extension, ExtensionActions, ExtensionAPI, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFactory, ExtensionFlag, ExtensionHandler, ExtensionRuntime, ExtensionShortcut, ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetOptions, FindToolCallEvent, GrepToolCallEvent, InlineExtension, InputEvent, InputEventResult, InputSource, KeybindingsManager, LoadExtensionsResult, LsToolCallEvent, MessageEndEvent, MessageRenderer, MessageRenderOptions, MessageStartEvent, MessageUpdateEvent, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventDecision, ProjectTrustEventResult, ProjectTrustHandler, ProviderConfig, ProviderModelConfig, ReadToolCallEvent, RegisteredCommand, RegisteredTool, ResolvedCommand, SessionBeforeCompactEvent, SessionBeforeForkEvent, SessionBeforeSwitchEvent, SessionBeforeTreeEvent, SessionCompactEvent, SessionInfoChangedEvent, SessionShutdownEvent, SessionStartEvent, SessionTreeEvent, SlashCommandInfo, SlashCommandSource, SourceInfo, TerminalInputHandler, ToolCallEvent, ToolCallEventResult, ToolDefinition, ToolExecutionEndEvent, ToolExecutionMode, ToolExecutionStartEvent, ToolExecutionUpdateEvent, ToolInfo, ToolRenderResultOptions, ToolResultEvent, TurnEndEvent, TurnStartEvent, UserBashEvent, UserBashEventResult, WidgetPlacement, WorkingIndicatorOptions, WriteToolCallEvent, } from "./core/extensions/index.ts";
@@ -32,4 +33,3 @@ export { parseFrontmatter, stripFrontmatter } from "./utils/frontmatter.ts";
 export { convertToPng } from "./utils/image-convert.ts";
 export { formatDimensionNote, type ResizedImage, resizeImage } from "./utils/image-resize.ts";
 export { getShellConfig } from "./utils/shell.ts";
-//# sourceMappingURL=index.d.ts.map