@selesai/code 0.13.12 → 0.13.13

package/dist/extensions/question/tests/zz-ig3.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { QuestionList } from "../question-list.ts";
-import { SingleSelect } from "../selection-mode.ts";
-import type { KeybindingsManager, Theme } from "@selesai/code";
-import type { ResolvedShortcut } from "../types.ts";
-
-const fakeTheme = { fg: (_n: string, s: string) => s, bold: (s: string) => s } as unknown as Theme;
-const fakeKeybindings = (actions: string[] = []): KeybindingsManager =>
-	({ matches: (_d: string, a: string) => actions.includes(a), getKeys: () => [] }) as unknown as KeybindingsManager;
-const disabledShortcut: ResolvedShortcut = { disabled: true, spec: null, matches: ((_d: string) => false) as (d: string) => false };
-
-describe("ig3", () => {
-	it("confirm option", () => {
-		const list = new QuestionList([{ value: "a", label: "A" }], SingleSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
-		let submitted = false;
-		list.onSubmit = () => (submitted = true);
-		list.handleInput("\r");
-		expect(submitted).toBe(true);
-	});
-});

package/dist/extensions/question/tests/zz-probe.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import questionExtension from "../index.ts";
-
-const theme = { fg: (_n: string, s: string) => s, bg: (_n: string, s: string) => s, bold: (s: string) => s };
-const tui = { requestRender() {}, terminal: { rows: 24 } };
-const keybindings = { matches: () => false, getKeys: () => ["Enter"] };
-
-async function runWizard(params: unknown) {
-	let tool: any;
-	let component: any;
-	let done!: (value: unknown) => void;
-	questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
-	const execution = tool.execute("call", params, undefined, undefined, {
-		mode: "tui",
-		ui: { custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => { done = resolve; component = factory(tui, theme, keybindings, done); }) },
-	} as any);
-	return { component: () => component, execution };
-}
-
-describe("probe", () => {
-	it("text question focused false", async () => {
-		const { component, execution } = await runWizard({ questions: [{ type: "text", question: "Type" }] });
-		component().focused = false;
-		component().handleInput("a");
-		component().handleInput("\r");
-		await execution;
-		expect(true).toBe(true);
-	});
-});

package/dist/extensions/question/types.ts

@@ -1,132 +0,0 @@
-// Shared type definitions for the question extension.
-
-import type { KeybindingsManager } from "@selesai/code";
-
-export interface RawQuestionOption {
-	value: string;
-	label: string;
-	description?: string;
-}
-
-export interface QuestionOption {
-	value: string;
-	label: string;
-	description?: string;
-}
-
-interface RawQuestionBase {
-	id?: string;
-	label?: string;
-	question: string;
-	context?: string;
-}
-
-export interface RawSelectQuestion extends RawQuestionBase {
-	type: "select";
-	options: RawQuestionOption[];
-	allowOther?: boolean;
-}
-
-export interface RawMultiSelectQuestion extends RawQuestionBase {
-	type: "multiselect";
-	options: RawQuestionOption[];
-	allowOther?: boolean;
-}
-
-export interface RawTextQuestion extends RawQuestionBase {
-	type: "text";
-}
-
-export type RawQuestion = RawSelectQuestion | RawMultiSelectQuestion | RawTextQuestion;
-
-export interface PreparedQuestionBase {
-	id: string;
-	label: string;
-	question: string;
-	context?: string;
-}
-
-export interface PreparedSelectQuestion extends PreparedQuestionBase {
-	type: "select";
-	options: QuestionOption[];
-	allowOther: boolean;
-}
-
-export interface PreparedMultiSelectQuestion extends PreparedQuestionBase {
-	type: "multiselect";
-	options: QuestionOption[];
-	allowOther: boolean;
-}
-
-export interface PreparedTextQuestion extends PreparedQuestionBase {
-	type: "text";
-	options: [];
-	allowOther: false;
-}
-
-export type PreparedQuestion = PreparedSelectQuestion | PreparedMultiSelectQuestion | PreparedTextQuestion;
-
-export type QuestionResponse =
-	| { kind: "selection"; values: string[]; otherText?: string }
-	| { kind: "text"; text: string };
-
-export type QuestionAnswer =
-	| { id: string; status: "answered"; response: QuestionResponse }
-	| { id: string; status: "skipped" | "unanswered" };
-
-export type QuestionToolResult =
-	| { status: "submitted"; answers: QuestionAnswer[] }
-	| { status: "cancelled"; reason: "user" };
-
-export interface DraftQuestionState {
-	status: "answered" | "skipped";
-	response?: QuestionResponse;
-}
-
-// ---------------------------------------------------------------------------
-// Legacy list internals.
-// ---------------------------------------------------------------------------
-
-export type ResolvedShortcut =
-	| { disabled: false; spec: string; matches: (data: string) => boolean }
-	| { disabled: true; spec: null; matches: (data: string) => false };
-
-export interface ResolvedShortcuts {
-	commentToggle: ResolvedShortcut;
-}
-
-export interface AnnotatedRow {
-	line: string;
-	selected: boolean;
-}
-
-export interface ItemBlock {
-	itemIndex: number;
-	lines: string[];
-}
-
-export type ListItem =
-	| { type: "option"; option: QuestionOption }
-	| { type: "comment-toggle"; option: QuestionOption }
-	| { type: "freeform"; option: QuestionOption };
-
-export interface RenderRowsParams {
-	options: QuestionOption[];
-	selectedIndex: number;
-	width: number;
-	allowFreeform: boolean;
-	allowComment?: boolean;
-	commentEnabled?: boolean;
-	maxRows?: number;
-	hideDescriptions?: boolean;
-}
-
-export type QuestionMode = "select" | "other" | "text";
-
-export interface CustomFactoryResult {
-	handleInput(data: string): void;
-	render(width: number): string[];
-	focused: boolean;
-}
-
-export type QuestionKeybindings = KeybindingsManager;

package/dist/extensions/rtk.test.ts

@@ -1,320 +0,0 @@
-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, { parseSemver } 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 });
-		}
-	});
-
-	it("parseSemver returns null for non-version strings", () => {
-		expect(parseSemver("no version here")).toBeNull();
-		expect(parseSemver("")).toBeNull();
-	});
-
-	it("parseSemver parses X.Y.Z from arbitrary text", () => {
-		expect(parseSemver("rtk 0.42.0")).toEqual([0, 42, 0]);
-		expect(parseSemver("  v1.2.3 ")).toEqual([1, 2, 3]);
-	});
-
-	it("disables the extension when --version fails", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		// Override exec so --version fails.
-		pi.exec = vi.fn(async () => ({ code: 1, stdout: "", stderr: "not found", killed: false }));
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("failed --version")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("disables the extension when the version is unparseable", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		pi.exec = vi.fn(async () => ({ code: 0, stdout: "garbage output", stderr: "", killed: false }));
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("could not parse version")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("disables the extension when the version output is empty", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		pi.exec = vi.fn(async () => ({ code: 0, stdout: "   ", stderr: "", killed: false }));
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("<empty output>")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("disables the extension when the version is too old", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		pi.exec = vi.fn(async () => ({ code: 0, stdout: "rtk 0.22.0", stderr: "", killed: false }));
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("too old")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("warns and skips when ensureTool fails", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		ensureToolMock.mockRejectedValue(new Error("download failed"));
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("managed installation failed")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("warns with the stringified error when ensureTool rejects a non-Error", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		ensureToolMock.mockRejectedValue("plain string failure");
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("plain string failure")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("warns and skips when ensureTool returns nothing", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		ensureToolMock.mockResolvedValue(undefined);
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("unavailable")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("warns and skips when probeRtk throws", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		pi.exec = vi.fn(async () => {
-			throw new Error("spawn ENOENT");
-		});
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("verification failed")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("warns with the stringified error when probeRtk throws a non-Error", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		ensureToolMock.mockResolvedValue("rtk");
-		pi.exec = vi.fn(async () => {
-			throw "string failure";
-		});
-		rtkExtension(pi);
-		await vi.waitFor(() => expect(warn).toHaveBeenCalledWith(expect.stringContaining("string failure")));
-		expect(handlers.has("tool_call")).toBe(false);
-	});
-
-	it("ignores non-bash tool calls and empty commands", async () => {
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		const handler = await getToolCall(handlers);
-
-		const nonBash: any = { type: "tool_call", toolName: "edit", toolCallId: "c1", input: { path: "a.ts" } };
-		await handler(nonBash, { signal: undefined });
-		expect(nonBash.input.path).toBe("a.ts");
-
-		const nonString: any = { type: "tool_call", toolName: "bash", toolCallId: "c2", input: { command: 42 } };
-		await handler(nonString, { signal: undefined });
-		expect(nonString.input.command).toBe(42);
-
-		const empty: any = { type: "tool_call", toolName: "bash", toolCallId: "c3", input: { command: "   " } };
-		await handler(empty, { signal: undefined });
-		expect(empty.input.command).toBe("   ");
-	});
-
-	it("passes through when RTK_DISABLED is set mid-run", async () => {
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		const handler = await getToolCall(handlers);
-
-		process.env.RTK_DISABLED = "1";
-		try {
-			const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
-			await handler(event, { signal: undefined });
-			expect(event.input.command).toBe("git status");
-		} finally {
-			delete process.env.RTK_DISABLED;
-		}
-	});
-
-	it("passes through when rewrite is killed or returns an unexpected code", async () => {
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		const handler = await getToolCall(handlers);
-
-		// The probe (--version + gain) already ran against the real fake binary,
-		// so the mock's responses are consumed by the rewrite call only.
-		// Killed rewrite.
-		pi.exec = vi.fn().mockResolvedValueOnce({ code: 0, stdout: "", stderr: "", killed: true });
-		const event1: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
-		await handler(event1, { signal: undefined });
-		expect(event1.input.command).toBe("git status");
-
-		// Unexpected exit code (2).
-		pi.exec = vi.fn().mockResolvedValueOnce({ code: 2, stdout: "", stderr: "err", killed: false });
-		const event2: any = { type: "tool_call", toolName: "bash", toolCallId: "c2", input: { command: "git status" } };
-		await handler(event2, { signal: undefined });
-		expect(event2.input.command).toBe("git status");
-	});
-
-	it("passes through when rewrite returns empty stdout", async () => {
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		const handler = await getToolCall(handlers);
-
-		pi.exec = vi.fn().mockResolvedValueOnce({ code: 0, stdout: "   ", stderr: "", killed: false });
-		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
-		await handler(event, { signal: undefined });
-		expect(event.input.command).toBe("git status");
-	});
-
-	it("fails open when the tool_call handler throws", async () => {
-		const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-		const { pi, handlers } = makePi();
-		rtkExtension(pi);
-		const handler = await getToolCall(handlers);
-
-		pi.exec = vi.fn().mockRejectedValueOnce(new Error("boom"));
-		const event: any = { type: "tool_call", toolName: "bash", toolCallId: "c1", input: { command: "git status" } };
-		await handler(event, { signal: undefined });
-		expect(event.input.command).toBe("git status");
-		expect(warn).toHaveBeenCalledWith(expect.stringContaining("unexpected error"), expect.any(Error));
-	});
-});

package/dist/extensions/rtk.ts

@@ -1,123 +0,0 @@
-// RTK Pi extension — rewrites bash commands to use rtk for token savings.
-// 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).
-// To add or change rewrite rules, edit the Rust registry — not this file.
-//
-// Exit code contract for `rtk rewrite`:
-//   0 + stdout  Rewrite found → mutate command
-//   1           No RTK equivalent → pass through unchanged
-//   3 + stdout  Rewrite (advisory) → mutate command
-
-import type { ExtensionAPI } 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" 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(rtkPath, ["rewrite", cmd], {
-    timeout: REWRITE_TIMEOUT_MS,
-    signal,
-  })
-  if (result.killed) return null
-  if (result.code !== 0 && result.code !== 3) return null
-  return result.stdout.trim() || null
-}
-
-export default function (pi: ExtensionAPI) {
-  // Explicit opt-out must also prevent an automatic managed-binary download.
-  if (process.env.RTK_DISABLED === "1") return
-
-  // 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
-    }
-
-    try {
-      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
-
-        if (cmd.trimStart().startsWith("rtk ")) return
-        if (process.env.RTK_DISABLED === "1") return
-
-        // 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
-      }
-    })
-  })()
-}

package/dist/extensions/test-resolve-hook-impl.mjs

@@ -1,7 +0,0 @@
-export async function resolve(specifier, context, next) {
-	if (specifier === "@selesai/code" || specifier.startsWith("@selesai/code/")) {
-		const url = new URL("../../src/index.ts", import.meta.url);
-		return next(url.href, context);
-	}
-	return next(specifier, context);
-}

package/dist/extensions/test-resolve-hook.mjs

@@ -1,7 +0,0 @@
-// Register ESM resolve hook to rewrite "@selesai/code" -> this repo's src.
-// Node 24 loads .ts natively (no jiti), so we need a real resolve hook.
-// Usage: node --import ./src/extensions/test-resolve-hook.mjs --test <file>
-import { register } from "node:module";
-import { pathToFileURL } from "node:url";
-
-register(pathToFileURL("./src/extensions/test-resolve-hook-impl.mjs").href);