@claude-code-kit/ui 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2364 @@
+// src/index.ts
+export * from "@claude-code-kit/ink-renderer";
+
+// src/Divider.tsx
+import { useContext } from "react";
+import { Text, Ansi, TerminalSizeContext, stringWidth } from "@claude-code-kit/ink-renderer";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Divider({ width, color, char = "\u2500", padding = 0, title }) {
+  const terminalSize = useContext(TerminalSizeContext);
+  const terminalWidth = terminalSize?.columns ?? 80;
+  const effectiveWidth = Math.max(0, (width ?? terminalWidth - 2) - padding);
+  if (title) {
+    const titleWidth = stringWidth(title) + 2;
+    const sideWidth = Math.max(0, effectiveWidth - titleWidth);
+    const leftWidth = Math.floor(sideWidth / 2);
+    const rightWidth = sideWidth - leftWidth;
+    return /* @__PURE__ */ jsxs(Text, { color, dimColor: !color, children: [
+      char.repeat(leftWidth),
+      " ",
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: /* @__PURE__ */ jsx(Ansi, { children: title }) }),
+      " ",
+      char.repeat(rightWidth)
+    ] });
+  }
+  return /* @__PURE__ */ jsx(Text, { color, dimColor: !color, children: char.repeat(effectiveWidth) });
+}
+
+// src/ProgressBar.tsx
+import { Text as Text2 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var BLOCKS = [" ", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+function ProgressBar({ ratio: inputRatio, width, fillColor, emptyColor }) {
+  const ratio = Math.min(1, Math.max(0, inputRatio));
+  const whole = Math.floor(ratio * width);
+  const segments = [BLOCKS[BLOCKS.length - 1].repeat(whole)];
+  if (whole < width) {
+    const remainder = ratio * width - whole;
+    const middle = Math.floor(remainder * BLOCKS.length);
+    segments.push(BLOCKS[middle]);
+    const empty = width - whole - 1;
+    if (empty > 0) {
+      segments.push(BLOCKS[0].repeat(empty));
+    }
+  }
+  return /* @__PURE__ */ jsx2(Text2, { color: fillColor, backgroundColor: emptyColor, children: segments.join("") });
+}
+
+// src/StatusIcon.tsx
+import figures from "figures";
+import { Text as Text3 } from "@claude-code-kit/ink-renderer";
+import { jsxs as jsxs2 } from "react/jsx-runtime";
+var STATUS_CONFIG = {
+  success: { icon: figures.tick, color: "green" },
+  error: { icon: figures.cross, color: "red" },
+  warning: { icon: figures.warning, color: "yellow" },
+  info: { icon: figures.info, color: "blue" },
+  pending: { icon: figures.circle, color: void 0 },
+  loading: { icon: "\u2026", color: void 0 }
+};
+function StatusIcon({ status, withSpace = false }) {
+  const config = STATUS_CONFIG[status];
+  return /* @__PURE__ */ jsxs2(Text3, { color: config.color, dimColor: !config.color, children: [
+    config.icon,
+    withSpace && " "
+  ] });
+}
+
+// src/StatusLine.tsx
+import { useEffect, useState } from "react";
+import { Box, Text as Text4, Ansi as Ansi2 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function hasAnsi(s) {
+  return /\x1b\[/.test(s);
+}
+function StatusLine({
+  segments,
+  text,
+  paddingX = 1,
+  gap = 1,
+  borderStyle = "none",
+  borderColor
+}) {
+  const border = borderStyle === "none" ? void 0 : borderStyle;
+  return /* @__PURE__ */ jsx3(
+    Box,
+    {
+      flexDirection: "row",
+      paddingX,
+      borderStyle: border,
+      borderColor,
+      children: text !== void 0 ? hasAnsi(text) ? /* @__PURE__ */ jsx3(Ansi2, { children: text }) : /* @__PURE__ */ jsx3(Text4, { dimColor: true, children: text }) : segments?.map((seg, i) => /* @__PURE__ */ jsx3(Box, { flexGrow: seg.flex ? 1 : 0, marginRight: i < segments.length - 1 ? gap : 0, children: hasAnsi(seg.content) ? /* @__PURE__ */ jsx3(Ansi2, { children: seg.content }) : /* @__PURE__ */ jsx3(Text4, { dimColor: true, color: seg.color, children: seg.content }) }, i))
+    }
+  );
+}
+function useStatusLine(updater, deps, intervalMs) {
+  const [value, setValue] = useState(() => updater());
+  useEffect(() => {
+    setValue(updater());
+  }, deps);
+  useEffect(() => {
+    if (!intervalMs) return;
+    const id = setInterval(() => setValue(updater()), intervalMs);
+    return () => clearInterval(id);
+  }, [intervalMs]);
+  return value;
+}
+
+// src/commands/registry.ts
+var CommandRegistry = class {
+  constructor() {
+    this.commands = /* @__PURE__ */ new Map();
+  }
+  register(...commands) {
+    for (const cmd of commands) {
+      this.commands.set(cmd.name, cmd);
+      if (cmd.aliases) {
+        for (const alias of cmd.aliases) {
+          this.commands.set(alias, cmd);
+        }
+      }
+    }
+  }
+  get(name) {
+    return this.commands.get(name);
+  }
+  getAll() {
+    return [...new Set(this.commands.values())];
+  }
+  getVisible() {
+    return this.getAll().filter(
+      (cmd) => !cmd.isHidden && (cmd.isEnabled?.() ?? true)
+    );
+  }
+  parse(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) return null;
+    const spaceIdx = trimmed.indexOf(" ");
+    const name = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+    const args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1).trim();
+    const command = this.get(name);
+    if (!command) return null;
+    if (command.isEnabled && !command.isEnabled()) return null;
+    return { command, args };
+  }
+  getSuggestions(partial) {
+    if (!partial.startsWith("/")) return [];
+    const search = partial.slice(1).toLowerCase();
+    return this.getVisible().filter(
+      (cmd) => cmd.name.toLowerCase().startsWith(search) || cmd.aliases?.some((a) => a.toLowerCase().startsWith(search))
+    );
+  }
+};
+function createCommandRegistry(commands) {
+  const registry = new CommandRegistry();
+  registry.register(...commands);
+  return registry;
+}
+
+// src/commands/defineCommand.ts
+function defineCommand(cmd) {
+  return cmd;
+}
+function defineLocalCommand(cmd) {
+  return { ...cmd, type: "local" };
+}
+function defineJSXCommand(cmd) {
+  return { ...cmd, type: "jsx" };
+}
+
+// src/commands/builtins.ts
+var exitCommand = {
+  name: "exit",
+  description: "Exit the application",
+  aliases: ["quit", "q"],
+  type: "local",
+  execute: () => {
+    process.exit(0);
+  }
+};
+var helpCommand = (registry) => ({
+  name: "help",
+  description: "Show available commands",
+  aliases: ["?"],
+  type: "local",
+  execute: () => {
+    const commands = registry.getVisible();
+    const lines = commands.map((cmd) => {
+      const aliases = cmd.aliases?.length ? ` (${cmd.aliases.join(", ")})` : "";
+      return `  /${cmd.name}${aliases} \u2014 ${cmd.description}`;
+    });
+    return { type: "text", value: ["Available commands:", "", ...lines].join("\n") };
+  }
+});
+var clearCommand = {
+  name: "clear",
+  description: "Clear the screen",
+  type: "local",
+  execute: () => {
+    process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    return { type: "skip" };
+  }
+};
+
+// src/keybindings/useKeybinding.ts
+import { useCallback, useEffect as useEffect2 } from "react";
+import { useInput } from "@claude-code-kit/ink-renderer";
+
+// src/keybindings/KeybindingContext.tsx
+import {
+  createContext,
+  useContext as useContext2,
+  useLayoutEffect,
+  useMemo
+} from "react";
+
+// src/keybindings/match.ts
+function getKeyName(input, key) {
+  if (key.escape) return "escape";
+  if (key.return) return "enter";
+  if (key.tab) return "tab";
+  if (key.backspace) return "backspace";
+  if (key.delete) return "delete";
+  if (key.upArrow) return "up";
+  if (key.downArrow) return "down";
+  if (key.leftArrow) return "left";
+  if (key.rightArrow) return "right";
+  if (key.pageUp) return "pageup";
+  if (key.pageDown) return "pagedown";
+  if (key.wheelUp) return "wheelup";
+  if (key.wheelDown) return "wheeldown";
+  if (key.home) return "home";
+  if (key.end) return "end";
+  if (input.length === 1) return input.toLowerCase();
+  return null;
+}
+
+// src/keybindings/parser.ts
+function parseKeystroke(input) {
+  const parts = input.split("+");
+  const keystroke = {
+    key: "",
+    ctrl: false,
+    alt: false,
+    shift: false,
+    meta: false,
+    super: false
+  };
+  for (const part of parts) {
+    const lower = part.toLowerCase();
+    switch (lower) {
+      case "ctrl":
+      case "control":
+        keystroke.ctrl = true;
+        break;
+      case "alt":
+      case "opt":
+      case "option":
+        keystroke.alt = true;
+        break;
+      case "shift":
+        keystroke.shift = true;
+        break;
+      case "meta":
+        keystroke.meta = true;
+        break;
+      case "cmd":
+      case "command":
+      case "super":
+      case "win":
+        keystroke.super = true;
+        break;
+      case "esc":
+        keystroke.key = "escape";
+        break;
+      case "return":
+        keystroke.key = "enter";
+        break;
+      case "space":
+        keystroke.key = " ";
+        break;
+      case "\u2191":
+        keystroke.key = "up";
+        break;
+      case "\u2193":
+        keystroke.key = "down";
+        break;
+      case "\u2190":
+        keystroke.key = "left";
+        break;
+      case "\u2192":
+        keystroke.key = "right";
+        break;
+      default:
+        keystroke.key = lower;
+        break;
+    }
+  }
+  return keystroke;
+}
+function parseChord(input) {
+  if (input === " ") return [parseKeystroke("space")];
+  return input.trim().split(/\s+/).map(parseKeystroke);
+}
+function keystrokeToString(ks) {
+  const parts = [];
+  if (ks.ctrl) parts.push("ctrl");
+  if (ks.alt) parts.push("alt");
+  if (ks.shift) parts.push("shift");
+  if (ks.meta) parts.push("meta");
+  if (ks.super) parts.push("cmd");
+  const displayKey = keyToDisplayName(ks.key);
+  parts.push(displayKey);
+  return parts.join("+");
+}
+function keyToDisplayName(key) {
+  switch (key) {
+    case "escape":
+      return "Esc";
+    case " ":
+      return "Space";
+    case "tab":
+      return "tab";
+    case "enter":
+      return "Enter";
+    case "backspace":
+      return "Backspace";
+    case "delete":
+      return "Delete";
+    case "up":
+      return "\u2191";
+    case "down":
+      return "\u2193";
+    case "left":
+      return "\u2190";
+    case "right":
+      return "\u2192";
+    case "pageup":
+      return "PageUp";
+    case "pagedown":
+      return "PageDown";
+    case "home":
+      return "Home";
+    case "end":
+      return "End";
+    default:
+      return key;
+  }
+}
+function chordToString(chord) {
+  return chord.map(keystrokeToString).join(" ");
+}
+function parseBindings(blocks) {
+  const bindings = [];
+  for (const block of blocks) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      bindings.push({
+        chord: parseChord(key),
+        action,
+        context: block.context
+      });
+    }
+  }
+  return bindings;
+}
+
+// src/keybindings/resolver.ts
+function getBindingDisplayText(action, context, bindings) {
+  const binding = bindings.findLast(
+    (b) => b.action === action && b.context === context
+  );
+  return binding ? chordToString(binding.chord) : void 0;
+}
+function buildKeystroke(input, key) {
+  const keyName = getKeyName(input, key);
+  if (!keyName) return null;
+  const effectiveMeta = key.escape ? false : key.meta;
+  return {
+    key: keyName,
+    ctrl: key.ctrl,
+    alt: effectiveMeta,
+    shift: key.shift,
+    meta: effectiveMeta,
+    super: key.super
+  };
+}
+function keystrokesEqual(a, b) {
+  return a.key === b.key && a.ctrl === b.ctrl && a.shift === b.shift && (a.alt || a.meta) === (b.alt || b.meta) && a.super === b.super;
+}
+function chordPrefixMatches(prefix, binding) {
+  if (prefix.length >= binding.chord.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    const prefixKey = prefix[i];
+    const bindingKey = binding.chord[i];
+    if (!prefixKey || !bindingKey) return false;
+    if (!keystrokesEqual(prefixKey, bindingKey)) return false;
+  }
+  return true;
+}
+function chordExactlyMatches(chord, binding) {
+  if (chord.length !== binding.chord.length) return false;
+  for (let i = 0; i < chord.length; i++) {
+    const chordKey = chord[i];
+    const bindingKey = binding.chord[i];
+    if (!chordKey || !bindingKey) return false;
+    if (!keystrokesEqual(chordKey, bindingKey)) return false;
+  }
+  return true;
+}
+function resolveKeyWithChordState(input, key, activeContexts, bindings, pending) {
+  if (key.escape && pending !== null) {
+    return { type: "chord_cancelled" };
+  }
+  const currentKeystroke = buildKeystroke(input, key);
+  if (!currentKeystroke) {
+    if (pending !== null) {
+      return { type: "chord_cancelled" };
+    }
+    return { type: "none" };
+  }
+  const testChord = pending ? [...pending, currentKeystroke] : [currentKeystroke];
+  const ctxSet = new Set(activeContexts);
+  const contextBindings = bindings.filter((b) => ctxSet.has(b.context));
+  const chordWinners = /* @__PURE__ */ new Map();
+  for (const binding of contextBindings) {
+    if (binding.chord.length > testChord.length && chordPrefixMatches(testChord, binding)) {
+      chordWinners.set(chordToString(binding.chord), binding.action);
+    }
+  }
+  let hasLongerChords = false;
+  for (const action of chordWinners.values()) {
+    if (action !== null) {
+      hasLongerChords = true;
+      break;
+    }
+  }
+  if (hasLongerChords) {
+    return { type: "chord_started", pending: testChord };
+  }
+  let exactMatch;
+  for (const binding of contextBindings) {
+    if (chordExactlyMatches(testChord, binding)) {
+      exactMatch = binding;
+    }
+  }
+  if (exactMatch) {
+    if (exactMatch.action === null) {
+      return { type: "unbound" };
+    }
+    return { type: "match", action: exactMatch.action };
+  }
+  if (pending !== null) {
+    return { type: "chord_cancelled" };
+  }
+  return { type: "none" };
+}
+
+// src/keybindings/KeybindingContext.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+var KeybindingContext = createContext(null);
+function KeybindingProvider({
+  bindings,
+  pendingChordRef,
+  pendingChord,
+  setPendingChord,
+  activeContexts,
+  registerActiveContext,
+  unregisterActiveContext,
+  handlerRegistryRef,
+  children
+}) {
+  const getDisplayText = useMemo(
+    () => (action, context) => getBindingDisplayText(action, context, bindings),
+    [bindings]
+  );
+  const registerHandler = useMemo(
+    () => (registration) => {
+      const registry = handlerRegistryRef.current;
+      if (!registry) return () => {
+      };
+      if (!registry.has(registration.action)) {
+        registry.set(registration.action, /* @__PURE__ */ new Set());
+      }
+      registry.get(registration.action).add(registration);
+      return () => {
+        const handlers = registry.get(registration.action);
+        if (handlers) {
+          handlers.delete(registration);
+          if (handlers.size === 0) {
+            registry.delete(registration.action);
+          }
+        }
+      };
+    },
+    [handlerRegistryRef]
+  );
+  const invokeAction = useMemo(
+    () => (action) => {
+      const registry = handlerRegistryRef.current;
+      if (!registry) return false;
+      const handlers = registry.get(action);
+      if (!handlers || handlers.size === 0) return false;
+      for (const registration of handlers) {
+        if (activeContexts.has(registration.context)) {
+          registration.handler();
+          return true;
+        }
+      }
+      return false;
+    },
+    [activeContexts, handlerRegistryRef]
+  );
+  const resolve = useMemo(
+    () => (input, key, contexts) => resolveKeyWithChordState(
+      input,
+      key,
+      contexts,
+      bindings,
+      pendingChordRef.current
+    ),
+    [bindings, pendingChordRef]
+  );
+  const value = useMemo(
+    () => ({
+      resolve,
+      setPendingChord,
+      getDisplayText,
+      bindings,
+      pendingChord,
+      activeContexts,
+      registerActiveContext,
+      unregisterActiveContext,
+      registerHandler,
+      invokeAction
+    }),
+    [
+      resolve,
+      setPendingChord,
+      getDisplayText,
+      bindings,
+      pendingChord,
+      activeContexts,
+      registerActiveContext,
+      unregisterActiveContext,
+      registerHandler,
+      invokeAction
+    ]
+  );
+  return /* @__PURE__ */ jsx4(KeybindingContext.Provider, { value, children });
+}
+function useOptionalKeybindingContext() {
+  return useContext2(KeybindingContext);
+}
+
+// src/keybindings/useKeybinding.ts
+function useKeybinding(action, handler, options = {}) {
+  const { context = "Global", isActive = true } = options;
+  const keybindingContext = useOptionalKeybindingContext();
+  useEffect2(() => {
+    if (!keybindingContext || !isActive) return;
+    return keybindingContext.registerHandler({ action, context, handler });
+  }, [action, context, handler, keybindingContext, isActive]);
+  const handleInput = useCallback(
+    (input, key, event) => {
+      if (!keybindingContext) return;
+      const contextsToCheck = [
+        ...keybindingContext.activeContexts,
+        context,
+        "Global"
+      ];
+      const uniqueContexts = [...new Set(contextsToCheck)];
+      const result = keybindingContext.resolve(input, key, uniqueContexts);
+      switch (result.type) {
+        case "match":
+          keybindingContext.setPendingChord(null);
+          if (result.action === action) {
+            if (handler() !== false) {
+              event.stopImmediatePropagation();
+            }
+          }
+          break;
+        case "chord_started":
+          keybindingContext.setPendingChord(result.pending);
+          event.stopImmediatePropagation();
+          break;
+        case "chord_cancelled":
+          keybindingContext.setPendingChord(null);
+          break;
+        case "unbound":
+          keybindingContext.setPendingChord(null);
+          event.stopImmediatePropagation();
+          break;
+        case "none":
+          break;
+      }
+    },
+    [action, context, handler, keybindingContext]
+  );
+  useInput(handleInput, { isActive });
+}
+function useKeybindings(handlers, options = {}) {
+  const { context = "Global", isActive = true } = options;
+  const keybindingContext = useOptionalKeybindingContext();
+  useEffect2(() => {
+    if (!keybindingContext || !isActive) return;
+    const unregisterFns = [];
+    for (const [action, handler] of Object.entries(handlers)) {
+      unregisterFns.push(
+        keybindingContext.registerHandler({ action, context, handler })
+      );
+    }
+    return () => {
+      for (const unregister of unregisterFns) {
+        unregister();
+      }
+    };
+  }, [context, handlers, keybindingContext, isActive]);
+  const handleInput = useCallback(
+    (input, key, event) => {
+      if (!keybindingContext) return;
+      const contextsToCheck = [
+        ...keybindingContext.activeContexts,
+        context,
+        "Global"
+      ];
+      const uniqueContexts = [...new Set(contextsToCheck)];
+      const result = keybindingContext.resolve(input, key, uniqueContexts);
+      switch (result.type) {
+        case "match":
+          keybindingContext.setPendingChord(null);
+          if (result.action in handlers) {
+            const handler = handlers[result.action];
+            if (handler && handler() !== false) {
+              event.stopImmediatePropagation();
+            }
+          }
+          break;
+        case "chord_started":
+          keybindingContext.setPendingChord(result.pending);
+          event.stopImmediatePropagation();
+          break;
+        case "chord_cancelled":
+          keybindingContext.setPendingChord(null);
+          break;
+        case "unbound":
+          keybindingContext.setPendingChord(null);
+          event.stopImmediatePropagation();
+          break;
+        case "none":
+          break;
+      }
+    },
+    [context, handlers, keybindingContext]
+  );
+  useInput(handleInput, { isActive });
+}
+
+// src/keybindings/KeybindingProviderSetup.tsx
+import { useCallback as useCallback2, useEffect as useEffect3, useRef, useState as useState2 } from "react";
+import { useInput as useInput2 } from "@claude-code-kit/ink-renderer";
+
+// src/keybindings/loadUserBindings.ts
+import chokidar from "chokidar";
+import { readFileSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { dirname, join } from "path";
+
+// src/keybindings/defaultBindings.ts
+import { satisfies } from "@claude-code-kit/shared";
+var feature = () => false;
+var getPlatform = () => process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux";
+var isRunningWithBun = () => false;
+var IMAGE_PASTE_KEY = getPlatform() === "windows" ? "alt+v" : "ctrl+v";
+var SUPPORTS_TERMINAL_VT_MODE = getPlatform() !== "windows" || (isRunningWithBun() ? satisfies(process.versions.bun ?? "0.0.0", ">=1.2.23") : satisfies(process.versions.node, ">=22.17.0 <23.0.0 || >=24.2.0"));
+var MODE_CYCLE_KEY = SUPPORTS_TERMINAL_VT_MODE ? "shift+tab" : "meta+m";
+var DEFAULT_BINDINGS = [
+  {
+    context: "Global",
+    bindings: {
+      // ctrl+c and ctrl+d use special time-based double-press handling.
+      // They ARE defined here so the resolver can find them, but they
+      // CANNOT be rebound by users - validation in reservedShortcuts.ts
+      // will show an error if users try to override these keys.
+      "ctrl+c": "app:interrupt",
+      "ctrl+d": "app:exit",
+      "ctrl+l": "app:redraw",
+      "ctrl+t": "app:toggleTodos",
+      "ctrl+o": "app:toggleTranscript",
+      ...feature() ? { "ctrl+shift+b": "app:toggleBrief" } : {},
+      "ctrl+shift+o": "app:toggleTeammatePreview",
+      "ctrl+r": "history:search",
+      // File navigation. cmd+ bindings only fire on kitty-protocol terminals;
+      // ctrl+shift is the portable fallback.
+      ...feature() ? {
+        "ctrl+shift+f": "app:globalSearch",
+        "cmd+shift+f": "app:globalSearch",
+        "ctrl+shift+p": "app:quickOpen",
+        "cmd+shift+p": "app:quickOpen"
+      } : {},
+      ...feature() ? { "meta+j": "app:toggleTerminal" } : {}
+    }
+  },
+  {
+    context: "Chat",
+    bindings: {
+      escape: "chat:cancel",
+      // ctrl+x chord prefix avoids shadowing readline editing keys (ctrl+a/b/e/f/...).
+      "ctrl+x ctrl+k": "chat:killAgents",
+      [MODE_CYCLE_KEY]: "chat:cycleMode",
+      "meta+p": "chat:modelPicker",
+      "meta+o": "chat:fastMode",
+      "meta+t": "chat:thinkingToggle",
+      enter: "chat:submit",
+      up: "history:previous",
+      down: "history:next",
+      // Undo has two bindings to support different terminal behaviors:
+      // - ctrl+_ for legacy terminals (send \x1f control char)
+      // - ctrl+shift+- for Kitty protocol (sends physical key with modifiers)
+      "ctrl+_": "chat:undo",
+      "ctrl+shift+-": "chat:undo",
+      // ctrl+x ctrl+e is the readline-native edit-and-execute-command binding.
+      "ctrl+x ctrl+e": "chat:externalEditor",
+      "ctrl+g": "chat:externalEditor",
+      "ctrl+s": "chat:stash",
+      // Image paste shortcut (platform-specific key defined above)
+      [IMAGE_PASTE_KEY]: "chat:imagePaste",
+      ...feature() ? { "shift+up": "chat:messageActions" } : {},
+      // Voice activation (hold-to-talk). Registered so getShortcutDisplay
+      // finds it without hitting the fallback analytics log. To rebind,
+      // add a voice:pushToTalk entry (last wins); to disable, use /voice
+      // — null-unbinding space hits a pre-existing useKeybinding.ts trap
+      // where 'unbound' swallows the event (space dead for typing).
+      ...feature() ? { space: "voice:pushToTalk" } : {}
+    }
+  },
+  {
+    context: "Autocomplete",
+    bindings: {
+      tab: "autocomplete:accept",
+      escape: "autocomplete:dismiss",
+      up: "autocomplete:previous",
+      down: "autocomplete:next"
+    }
+  },
+  {
+    context: "Settings",
+    bindings: {
+      // Settings menu uses escape only (not 'n') to dismiss
+      escape: "confirm:no",
+      // Config panel list navigation (reuses Select actions)
+      up: "select:previous",
+      down: "select:next",
+      k: "select:previous",
+      j: "select:next",
+      "ctrl+p": "select:previous",
+      "ctrl+n": "select:next",
+      // Toggle/activate the selected setting (space only — enter saves & closes)
+      space: "select:accept",
+      // Save and close the config panel
+      enter: "settings:close",
+      // Enter search mode
+      "/": "settings:search",
+      // Retry loading usage data (only active on error)
+      r: "settings:retry"
+    }
+  },
+  {
+    context: "Confirmation",
+    bindings: {
+      y: "confirm:yes",
+      n: "confirm:no",
+      enter: "confirm:yes",
+      escape: "confirm:no",
+      // Navigation for dialogs with lists
+      up: "confirm:previous",
+      down: "confirm:next",
+      tab: "confirm:nextField",
+      space: "confirm:toggle",
+      // Cycle modes (used in file permission dialogs and teams dialog)
+      "shift+tab": "confirm:cycleMode",
+      // Toggle permission explanation in permission dialogs
+      "ctrl+e": "confirm:toggleExplanation",
+      // Toggle permission debug info
+      "ctrl+d": "permission:toggleDebug"
+    }
+  },
+  {
+    context: "Tabs",
+    bindings: {
+      // Tab cycling navigation
+      tab: "tabs:next",
+      "shift+tab": "tabs:previous",
+      right: "tabs:next",
+      left: "tabs:previous"
+    }
+  },
+  {
+    context: "Transcript",
+    bindings: {
+      "ctrl+e": "transcript:toggleShowAll",
+      "ctrl+c": "transcript:exit",
+      escape: "transcript:exit",
+      // q — pager convention (less, tmux copy-mode). Transcript is a modal
+      // reading view with no prompt, so q-as-literal-char has no owner.
+      q: "transcript:exit"
+    }
+  },
+  {
+    context: "HistorySearch",
+    bindings: {
+      "ctrl+r": "historySearch:next",
+      escape: "historySearch:accept",
+      tab: "historySearch:accept",
+      "ctrl+c": "historySearch:cancel",
+      enter: "historySearch:execute"
+    }
+  },
+  {
+    context: "Task",
+    bindings: {
+      // Background running foreground tasks (bash commands, agents)
+      // In tmux, users must press ctrl+b twice (tmux prefix escape)
+      "ctrl+b": "task:background"
+    }
+  },
+  {
+    context: "ThemePicker",
+    bindings: {
+      "ctrl+t": "theme:toggleSyntaxHighlighting"
+    }
+  },
+  {
+    context: "Scroll",
+    bindings: {
+      pageup: "scroll:pageUp",
+      pagedown: "scroll:pageDown",
+      wheelup: "scroll:lineUp",
+      wheeldown: "scroll:lineDown",
+      "ctrl+home": "scroll:top",
+      "ctrl+end": "scroll:bottom",
+      // Selection copy. ctrl+shift+c is standard terminal copy.
+      // cmd+c only fires on terminals using the kitty keyboard
+      // protocol (kitty/WezTerm/ghostty/iTerm2) where the super
+      // modifier actually reaches the pty — inert elsewhere.
+      // Esc-to-clear and contextual ctrl+c are handled via raw
+      // useInput so they can conditionally propagate.
+      "ctrl+shift+c": "selection:copy",
+      "cmd+c": "selection:copy"
+    }
+  },
+  {
+    context: "Help",
+    bindings: {
+      escape: "help:dismiss"
+    }
+  },
+  // Attachment navigation (select dialog image attachments)
+  {
+    context: "Attachments",
+    bindings: {
+      right: "attachments:next",
+      left: "attachments:previous",
+      backspace: "attachments:remove",
+      delete: "attachments:remove",
+      down: "attachments:exit",
+      escape: "attachments:exit"
+    }
+  },
+  // Footer indicator navigation (tasks, teams, diff, loop)
+  {
+    context: "Footer",
+    bindings: {
+      up: "footer:up",
+      "ctrl+p": "footer:up",
+      down: "footer:down",
+      "ctrl+n": "footer:down",
+      right: "footer:next",
+      left: "footer:previous",
+      enter: "footer:openSelected",
+      escape: "footer:clearSelection"
+    }
+  },
+  // Message selector (rewind dialog) navigation
+  {
+    context: "MessageSelector",
+    bindings: {
+      up: "messageSelector:up",
+      down: "messageSelector:down",
+      k: "messageSelector:up",
+      j: "messageSelector:down",
+      "ctrl+p": "messageSelector:up",
+      "ctrl+n": "messageSelector:down",
+      "ctrl+up": "messageSelector:top",
+      "shift+up": "messageSelector:top",
+      "meta+up": "messageSelector:top",
+      "shift+k": "messageSelector:top",
+      "ctrl+down": "messageSelector:bottom",
+      "shift+down": "messageSelector:bottom",
+      "meta+down": "messageSelector:bottom",
+      "shift+j": "messageSelector:bottom",
+      enter: "messageSelector:select"
+    }
+  },
+  // Diff dialog navigation
+  {
+    context: "DiffDialog",
+    bindings: {
+      escape: "diff:dismiss",
+      left: "diff:previousSource",
+      right: "diff:nextSource",
+      up: "diff:previousFile",
+      down: "diff:nextFile",
+      enter: "diff:viewDetails"
+      // Note: diff:back is handled by left arrow in detail mode
+    }
+  },
+  // Model picker effort cycling (ant-only)
+  {
+    context: "ModelPicker",
+    bindings: {
+      left: "modelPicker:decreaseEffort",
+      right: "modelPicker:increaseEffort"
+    }
+  },
+  // Select component navigation (used by /model, /resume, permission prompts, etc.)
+  {
+    context: "Select",
+    bindings: {
+      up: "select:previous",
+      down: "select:next",
+      j: "select:next",
+      k: "select:previous",
+      "ctrl+n": "select:next",
+      "ctrl+p": "select:previous",
+      enter: "select:accept",
+      escape: "select:cancel"
+    }
+  },
+  // Plugin dialog actions (manage, browse, discover plugins)
+  // Navigation (select:*) uses the Select context above
+  {
+    context: "Plugin",
+    bindings: {
+      space: "plugin:toggle",
+      i: "plugin:install"
+    }
+  }
+];
+
+// src/keybindings/reservedShortcuts.ts
+var getPlatform2 = () => process.platform === "darwin" ? "macos" : process.platform === "win32" ? "windows" : "linux";
+var NON_REBINDABLE = [
+  {
+    key: "ctrl+c",
+    reason: "Cannot be rebound - used for interrupt/exit (hardcoded)",
+    severity: "error"
+  },
+  {
+    key: "ctrl+d",
+    reason: "Cannot be rebound - used for exit (hardcoded)",
+    severity: "error"
+  },
+  {
+    key: "ctrl+m",
+    reason: "Cannot be rebound - identical to Enter in terminals (both send CR)",
+    severity: "error"
+  }
+];
+var TERMINAL_RESERVED = [
+  {
+    key: "ctrl+z",
+    reason: "Unix process suspend (SIGTSTP)",
+    severity: "warning"
+  },
+  {
+    key: "ctrl+\\",
+    reason: "Terminal quit signal (SIGQUIT)",
+    severity: "error"
+  }
+];
+var MACOS_RESERVED = [
+  { key: "cmd+c", reason: "macOS system copy", severity: "error" },
+  { key: "cmd+v", reason: "macOS system paste", severity: "error" },
+  { key: "cmd+x", reason: "macOS system cut", severity: "error" },
+  { key: "cmd+q", reason: "macOS quit application", severity: "error" },
+  { key: "cmd+w", reason: "macOS close window/tab", severity: "error" },
+  { key: "cmd+tab", reason: "macOS app switcher", severity: "error" },
+  { key: "cmd+space", reason: "macOS Spotlight", severity: "error" }
+];
+function getReservedShortcuts() {
+  const platform = getPlatform2();
+  const reserved = [...NON_REBINDABLE, ...TERMINAL_RESERVED];
+  if (platform === "macos") {
+    reserved.push(...MACOS_RESERVED);
+  }
+  return reserved;
+}
+function normalizeKeyForComparison(key) {
+  return key.trim().split(/\s+/).map(normalizeStep).join(" ");
+}
+function normalizeStep(step) {
+  const parts = step.split("+");
+  const modifiers = [];
+  let mainKey = "";
+  for (const part of parts) {
+    const lower = part.trim().toLowerCase();
+    if ([
+      "ctrl",
+      "control",
+      "alt",
+      "opt",
+      "option",
+      "meta",
+      "cmd",
+      "command",
+      "shift"
+    ].includes(lower)) {
+      if (lower === "control") modifiers.push("ctrl");
+      else if (lower === "option" || lower === "opt") modifiers.push("alt");
+      else if (lower === "command" || lower === "cmd") modifiers.push("cmd");
+      else modifiers.push(lower);
+    } else {
+      mainKey = lower;
+    }
+  }
+  modifiers.sort();
+  return [...modifiers, mainKey].join("+");
+}
+
+// src/keybindings/validate.ts
+function isKeybindingBlock(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const b = obj;
+  return typeof b.context === "string" && typeof b.bindings === "object" && b.bindings !== null;
+}
+function isKeybindingBlockArray(arr) {
+  return Array.isArray(arr) && arr.every(isKeybindingBlock);
+}
+var VALID_CONTEXTS = [
+  "Global",
+  "Chat",
+  "Autocomplete",
+  "Confirmation",
+  "Help",
+  "Transcript",
+  "HistorySearch",
+  "Task",
+  "ThemePicker",
+  "Settings",
+  "Tabs",
+  "Attachments",
+  "Footer",
+  "MessageSelector",
+  "DiffDialog",
+  "ModelPicker",
+  "Select",
+  "Plugin"
+];
+function isValidContext(value) {
+  return VALID_CONTEXTS.includes(value);
+}
+function validateKeystroke(keystroke) {
+  const parts = keystroke.toLowerCase().split("+");
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) {
+      return {
+        type: "parse_error",
+        severity: "error",
+        message: `Empty key part in "${keystroke}"`,
+        key: keystroke,
+        suggestion: 'Remove extra "+" characters'
+      };
+    }
+  }
+  const parsed = parseKeystroke(keystroke);
+  if (!parsed.key && !parsed.ctrl && !parsed.alt && !parsed.shift && !parsed.meta) {
+    return {
+      type: "parse_error",
+      severity: "error",
+      message: `Could not parse keystroke "${keystroke}"`,
+      key: keystroke
+    };
+  }
+  return null;
+}
+function validateBlock(block, blockIndex) {
+  const warnings = [];
+  if (typeof block !== "object" || block === null) {
+    warnings.push({
+      type: "parse_error",
+      severity: "error",
+      message: `Keybinding block ${blockIndex + 1} is not an object`
+    });
+    return warnings;
+  }
+  const b = block;
+  const rawContext = b.context;
+  let contextName;
+  if (typeof rawContext !== "string") {
+    warnings.push({
+      type: "parse_error",
+      severity: "error",
+      message: `Keybinding block ${blockIndex + 1} missing "context" field`
+    });
+  } else if (!isValidContext(rawContext)) {
+    warnings.push({
+      type: "invalid_context",
+      severity: "error",
+      message: `Unknown context "${rawContext}"`,
+      context: rawContext,
+      suggestion: `Valid contexts: ${VALID_CONTEXTS.join(", ")}`
+    });
+  } else {
+    contextName = rawContext;
+  }
+  if (typeof b.bindings !== "object" || b.bindings === null) {
+    warnings.push({
+      type: "parse_error",
+      severity: "error",
+      message: `Keybinding block ${blockIndex + 1} missing "bindings" field`
+    });
+    return warnings;
+  }
+  const bindings = b.bindings;
+  for (const [key, action] of Object.entries(bindings)) {
+    const keyError = validateKeystroke(key);
+    if (keyError) {
+      keyError.context = contextName;
+      warnings.push(keyError);
+    }
+    if (action !== null && typeof action !== "string") {
+      warnings.push({
+        type: "invalid_action",
+        severity: "error",
+        message: `Invalid action for "${key}": must be a string or null`,
+        key,
+        context: contextName
+      });
+    } else if (typeof action === "string" && action.startsWith("command:")) {
+      if (!/^command:[a-zA-Z0-9:\-_]+$/.test(action)) {
+        warnings.push({
+          type: "invalid_action",
+          severity: "warning",
+          message: `Invalid command binding "${action}" for "${key}": command name may only contain alphanumeric characters, colons, hyphens, and underscores`,
+          key,
+          context: contextName,
+          action
+        });
+      }
+      if (contextName && contextName !== "Chat") {
+        warnings.push({
+          type: "invalid_action",
+          severity: "warning",
+          message: `Command binding "${action}" must be in "Chat" context, not "${contextName}"`,
+          key,
+          context: contextName,
+          action,
+          suggestion: 'Move this binding to a block with "context": "Chat"'
+        });
+      }
+    } else if (action === "voice:pushToTalk") {
+      const ks = parseChord(key)[0];
+      if (ks && !ks.ctrl && !ks.alt && !ks.shift && !ks.meta && !ks.super && /^[a-z]$/.test(ks.key)) {
+        warnings.push({
+          type: "invalid_action",
+          severity: "warning",
+          message: `Binding "${key}" to voice:pushToTalk prints into the input during warmup; use space or a modifier combo like meta+k`,
+          key,
+          context: contextName,
+          action
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function checkDuplicateKeysInJson(jsonString) {
+  const warnings = [];
+  const bindingsBlockPattern = /"bindings"\s*:\s*\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}/g;
+  let blockMatch;
+  while ((blockMatch = bindingsBlockPattern.exec(jsonString)) !== null) {
+    const blockContent = blockMatch[1];
+    if (!blockContent) continue;
+    const textBeforeBlock = jsonString.slice(0, blockMatch.index);
+    const contextMatch = textBeforeBlock.match(
+      /"context"\s*:\s*"([^"]+)"[^{]*$/
+    );
+    const context = contextMatch?.[1] ?? "unknown";
+    const keyPattern = /"([^"]+)"\s*:/g;
+    const keysByName = /* @__PURE__ */ new Map();
+    let keyMatch;
+    while ((keyMatch = keyPattern.exec(blockContent)) !== null) {
+      const key = keyMatch[1];
+      if (!key) continue;
+      const count = (keysByName.get(key) ?? 0) + 1;
+      keysByName.set(key, count);
+      if (count === 2) {
+        warnings.push({
+          type: "duplicate",
+          severity: "warning",
+          message: `Duplicate key "${key}" in ${context} bindings`,
+          key,
+          context,
+          suggestion: `This key appears multiple times in the same context. JSON uses the last value, earlier values are ignored.`
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function validateUserConfig(userBlocks) {
+  const warnings = [];
+  if (!Array.isArray(userBlocks)) {
+    warnings.push({
+      type: "parse_error",
+      severity: "error",
+      message: "keybindings.json must contain an array",
+      suggestion: "Wrap your bindings in [ ]"
+    });
+    return warnings;
+  }
+  for (let i = 0; i < userBlocks.length; i++) {
+    warnings.push(...validateBlock(userBlocks[i], i));
+  }
+  return warnings;
+}
+function checkDuplicates(blocks) {
+  const warnings = [];
+  const seenByContext = /* @__PURE__ */ new Map();
+  for (const block of blocks) {
+    const contextMap = seenByContext.get(block.context) ?? /* @__PURE__ */ new Map();
+    seenByContext.set(block.context, contextMap);
+    for (const [key, action] of Object.entries(block.bindings)) {
+      const normalizedKey = normalizeKeyForComparison(key);
+      const existingAction = contextMap.get(normalizedKey);
+      if (existingAction && existingAction !== action) {
+        warnings.push({
+          type: "duplicate",
+          severity: "warning",
+          message: `Duplicate binding "${key}" in ${block.context} context`,
+          key,
+          context: block.context,
+          action: action ?? "null (unbind)",
+          suggestion: `Previously bound to "${existingAction}". Only the last binding will be used.`
+        });
+      }
+      contextMap.set(normalizedKey, action ?? "null");
+    }
+  }
+  return warnings;
+}
+function checkReservedShortcuts(bindings) {
+  const warnings = [];
+  const reserved = getReservedShortcuts();
+  for (const binding of bindings) {
+    const keyDisplay = chordToString(binding.chord);
+    const normalizedKey = normalizeKeyForComparison(keyDisplay);
+    for (const res of reserved) {
+      if (normalizeKeyForComparison(res.key) === normalizedKey) {
+        warnings.push({
+          type: "reserved",
+          severity: res.severity,
+          message: `"${keyDisplay}" may not work: ${res.reason}`,
+          key: keyDisplay,
+          context: binding.context,
+          action: binding.action ?? void 0
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function getUserBindingsForValidation(userBlocks) {
+  const bindings = [];
+  for (const block of userBlocks) {
+    for (const [key, action] of Object.entries(block.bindings)) {
+      const chord = key.split(" ").map((k) => parseKeystroke(k));
+      bindings.push({
+        chord,
+        action,
+        context: block.context
+      });
+    }
+  }
+  return bindings;
+}
+function validateBindings(userBlocks, _parsedBindings) {
+  const warnings = [];
+  warnings.push(...validateUserConfig(userBlocks));
+  if (isKeybindingBlockArray(userBlocks)) {
+    warnings.push(...checkDuplicates(userBlocks));
+    const userBindings = getUserBindingsForValidation(userBlocks);
+    warnings.push(...checkReservedShortcuts(userBindings));
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return warnings.filter((w) => {
+    const key = `${w.type}:${w.key}:${w.context}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/keybindings/loadUserBindings.ts
+function logForDebugging(msg) {
+  if (process.env.DEBUG_KEYBINDINGS) console.error(msg);
+}
+function getClaudeConfigHomeDir() {
+  return join(process.env.HOME ?? "~", ".claude");
+}
+function isENOENT(error) {
+  return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function jsonParse(text) {
+  return JSON.parse(text);
+}
+function createSignal() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    emit: (...args) => {
+      for (const listener of listeners) listener(...args);
+    },
+    clear: () => listeners.clear()
+  };
+}
+function isKeybindingCustomizationEnabled() {
+  return true;
+}
+var FILE_STABILITY_THRESHOLD_MS = 500;
+var FILE_STABILITY_POLL_INTERVAL_MS = 200;
+var watcher = null;
+var initialized = false;
+var disposed = false;
+var cachedBindings = null;
+var cachedWarnings = [];
+var keybindingsChanged = createSignal();
+function isKeybindingBlock2(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const b = obj;
+  return typeof b.context === "string" && typeof b.bindings === "object" && b.bindings !== null;
+}
+function isKeybindingBlockArray2(arr) {
+  return Array.isArray(arr) && arr.every(isKeybindingBlock2);
+}
+function getKeybindingsPath() {
+  return join(getClaudeConfigHomeDir(), "keybindings.json");
+}
+function getDefaultParsedBindings() {
+  return parseBindings(DEFAULT_BINDINGS);
+}
+async function loadKeybindings() {
+  const defaultBindings = getDefaultParsedBindings();
+  if (!isKeybindingCustomizationEnabled()) {
+    return { bindings: defaultBindings, warnings: [] };
+  }
+  const userPath = getKeybindingsPath();
+  try {
+    const content = await readFile(userPath, "utf-8");
+    const parsed = jsonParse(content);
+    let userBlocks;
+    if (typeof parsed === "object" && parsed !== null && "bindings" in parsed) {
+      userBlocks = parsed.bindings;
+    } else {
+      const msg = 'keybindings.json must have a "bindings" array';
+      const suggestion = 'Use format: { "bindings": [ ... ] }';
+      logForDebugging(`[keybindings] Invalid keybindings.json: ${msg}`);
+      return {
+        bindings: defaultBindings,
+        warnings: [{ type: "parse_error", severity: "error", message: msg, suggestion }]
+      };
+    }
+    if (!isKeybindingBlockArray2(userBlocks)) {
+      const msg = !Array.isArray(userBlocks) ? '"bindings" must be an array' : "keybindings.json contains invalid block structure";
+      const suggestion = !Array.isArray(userBlocks) ? 'Set "bindings" to an array of keybinding blocks' : 'Each block must have "context" (string) and "bindings" (object)';
+      logForDebugging(`[keybindings] Invalid keybindings.json: ${msg}`);
+      return {
+        bindings: defaultBindings,
+        warnings: [{ type: "parse_error", severity: "error", message: msg, suggestion }]
+      };
+    }
+    const userParsed = parseBindings(userBlocks);
+    logForDebugging(`[keybindings] Loaded ${userParsed.length} user bindings from ${userPath}`);
+    const mergedBindings = [...defaultBindings, ...userParsed];
+    const duplicateKeyWarnings = checkDuplicateKeysInJson(content);
+    const warnings = [
+      ...duplicateKeyWarnings,
+      ...validateBindings(userBlocks, mergedBindings)
+    ];
+    if (warnings.length > 0) {
+      logForDebugging(`[keybindings] Found ${warnings.length} validation issue(s)`);
+    }
+    return { bindings: mergedBindings, warnings };
+  } catch (error) {
+    if (isENOENT(error)) {
+      return { bindings: defaultBindings, warnings: [] };
+    }
+    logForDebugging(`[keybindings] Error loading ${userPath}: ${errorMessage(error)}`);
+    return {
+      bindings: defaultBindings,
+      warnings: [
+        {
+          type: "parse_error",
+          severity: "error",
+          message: `Failed to parse keybindings.json: ${errorMessage(error)}`
+        }
+      ]
+    };
+  }
+}
+function loadKeybindingsSyncWithWarnings() {
+  if (cachedBindings) {
+    return { bindings: cachedBindings, warnings: cachedWarnings };
+  }
+  const defaultBindings = getDefaultParsedBindings();
+  if (!isKeybindingCustomizationEnabled()) {
+    cachedBindings = defaultBindings;
+    cachedWarnings = [];
+    return { bindings: cachedBindings, warnings: cachedWarnings };
+  }
+  const userPath = getKeybindingsPath();
+  try {
+    const content = readFileSync(userPath, "utf-8");
+    const parsed = jsonParse(content);
+    let userBlocks;
+    if (typeof parsed === "object" && parsed !== null && "bindings" in parsed) {
+      userBlocks = parsed.bindings;
+    } else {
+      cachedBindings = defaultBindings;
+      cachedWarnings = [
+        {
+          type: "parse_error",
+          severity: "error",
+          message: 'keybindings.json must have a "bindings" array',
+          suggestion: 'Use format: { "bindings": [ ... ] }'
+        }
+      ];
+      return { bindings: cachedBindings, warnings: cachedWarnings };
+    }
+    if (!isKeybindingBlockArray2(userBlocks)) {
+      const msg = !Array.isArray(userBlocks) ? '"bindings" must be an array' : "keybindings.json contains invalid block structure";
+      const suggestion = !Array.isArray(userBlocks) ? 'Set "bindings" to an array of keybinding blocks' : 'Each block must have "context" (string) and "bindings" (object)';
+      cachedBindings = defaultBindings;
+      cachedWarnings = [{ type: "parse_error", severity: "error", message: msg, suggestion }];
+      return { bindings: cachedBindings, warnings: cachedWarnings };
+    }
+    const userParsed = parseBindings(userBlocks);
+    logForDebugging(`[keybindings] Loaded ${userParsed.length} user bindings from ${userPath}`);
+    cachedBindings = [...defaultBindings, ...userParsed];
+    const duplicateKeyWarnings = checkDuplicateKeysInJson(content);
+    cachedWarnings = [
+      ...duplicateKeyWarnings,
+      ...validateBindings(userBlocks, cachedBindings)
+    ];
+    if (cachedWarnings.length > 0) {
+      logForDebugging(`[keybindings] Found ${cachedWarnings.length} validation issue(s)`);
+    }
+    return { bindings: cachedBindings, warnings: cachedWarnings };
+  } catch {
+    cachedBindings = defaultBindings;
+    cachedWarnings = [];
+    return { bindings: cachedBindings, warnings: cachedWarnings };
+  }
+}
+async function initializeKeybindingWatcher() {
+  if (initialized || disposed) return;
+  if (!isKeybindingCustomizationEnabled()) {
+    logForDebugging("[keybindings] Skipping file watcher - user customization disabled");
+    return;
+  }
+  const userPath = getKeybindingsPath();
+  const watchDir = dirname(userPath);
+  try {
+    const stats = await stat(watchDir);
+    if (!stats.isDirectory()) {
+      logForDebugging(`[keybindings] Not watching: ${watchDir} is not a directory`);
+      return;
+    }
+  } catch {
+    logForDebugging(`[keybindings] Not watching: ${watchDir} does not exist`);
+    return;
+  }
+  initialized = true;
+  logForDebugging(`[keybindings] Watching for changes to ${userPath}`);
+  watcher = chokidar.watch(userPath, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: FILE_STABILITY_THRESHOLD_MS,
+      pollInterval: FILE_STABILITY_POLL_INTERVAL_MS
+    },
+    ignorePermissionErrors: true,
+    usePolling: false,
+    atomic: true
+  });
+  watcher.on("add", handleChange);
+  watcher.on("change", handleChange);
+  watcher.on("unlink", handleDelete);
+}
+var subscribeToKeybindingChanges = keybindingsChanged.subscribe;
+async function handleChange(path) {
+  logForDebugging(`[keybindings] Detected change to ${path}`);
+  try {
+    const result = await loadKeybindings();
+    cachedBindings = result.bindings;
+    cachedWarnings = result.warnings;
+    keybindingsChanged.emit(result);
+  } catch (error) {
+    logForDebugging(`[keybindings] Error reloading: ${errorMessage(error)}`);
+  }
+}
+function handleDelete(path) {
+  logForDebugging(`[keybindings] Detected deletion of ${path}`);
+  const defaultBindings = getDefaultParsedBindings();
+  cachedBindings = defaultBindings;
+  cachedWarnings = [];
+  keybindingsChanged.emit({ bindings: defaultBindings, warnings: [] });
+}
+
+// src/keybindings/KeybindingProviderSetup.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var plural = (n, s) => n === 1 ? s : s + "s";
+function logForDebugging2(msg) {
+  if (process.env.DEBUG_KEYBINDINGS) console.error(msg);
+}
+var CHORD_TIMEOUT_MS = 1e3;
+function KeybindingSetup({ children, onWarnings }) {
+  const [{ bindings, warnings }, setLoadResult] = useState2(() => {
+    const result = loadKeybindingsSyncWithWarnings();
+    logForDebugging2(
+      `[keybindings] KeybindingSetup initialized with ${result.bindings.length} bindings, ${result.warnings.length} warnings`
+    );
+    return result;
+  });
+  const [isReload, setIsReload] = useState2(false);
+  useEffect3(() => {
+    if (!onWarnings || warnings.length === 0) return;
+    const errorCount = warnings.filter((w) => w.severity === "error").length;
+    const warnCount = warnings.filter((w) => w.severity === "warning").length;
+    let message;
+    if (errorCount > 0 && warnCount > 0) {
+      message = `Found ${errorCount} keybinding ${plural(errorCount, "error")} and ${warnCount} ${plural(warnCount, "warning")}`;
+    } else if (errorCount > 0) {
+      message = `Found ${errorCount} keybinding ${plural(errorCount, "error")}`;
+    } else {
+      message = `Found ${warnCount} keybinding ${plural(warnCount, "warning")}`;
+    }
+    onWarnings(message + " \xB7 /doctor for details", errorCount > 0);
+  }, [warnings, isReload, onWarnings]);
+  const pendingChordRef = useRef(null);
+  const [pendingChord, setPendingChordState] = useState2(null);
+  const chordTimeoutRef = useRef(null);
+  const handlerRegistryRef = useRef(
+    /* @__PURE__ */ new Map()
+  );
+  const activeContextsRef = useRef(/* @__PURE__ */ new Set());
+  const registerActiveContext = useCallback2((context) => {
+    activeContextsRef.current.add(context);
+  }, []);
+  const unregisterActiveContext = useCallback2(
+    (context) => {
+      activeContextsRef.current.delete(context);
+    },
+    []
+  );
+  const clearChordTimeout = useCallback2(() => {
+    if (chordTimeoutRef.current) {
+      clearTimeout(chordTimeoutRef.current);
+      chordTimeoutRef.current = null;
+    }
+  }, []);
+  const setPendingChord = useCallback2(
+    (pending) => {
+      clearChordTimeout();
+      if (pending !== null) {
+        chordTimeoutRef.current = setTimeout(() => {
+          logForDebugging2("[keybindings] Chord timeout - cancelling");
+          pendingChordRef.current = null;
+          setPendingChordState(null);
+        }, CHORD_TIMEOUT_MS);
+      }
+      pendingChordRef.current = pending;
+      setPendingChordState(pending);
+    },
+    [clearChordTimeout]
+  );
+  useEffect3(() => {
+    void initializeKeybindingWatcher();
+    const unsubscribe = subscribeToKeybindingChanges((result) => {
+      setIsReload(true);
+      setLoadResult(result);
+      logForDebugging2(
+        `[keybindings] Reloaded: ${result.bindings.length} bindings, ${result.warnings.length} warnings`
+      );
+    });
+    return () => {
+      unsubscribe();
+      clearChordTimeout();
+    };
+  }, [clearChordTimeout]);
+  return /* @__PURE__ */ jsxs3(
+    KeybindingProvider,
+    {
+      bindings,
+      pendingChordRef,
+      pendingChord,
+      setPendingChord,
+      activeContexts: activeContextsRef.current,
+      registerActiveContext,
+      unregisterActiveContext,
+      handlerRegistryRef,
+      children: [
+        /* @__PURE__ */ jsx5(
+          ChordInterceptor,
+          {
+            bindings,
+            pendingChordRef,
+            setPendingChord,
+            activeContexts: activeContextsRef.current,
+            handlerRegistryRef
+          }
+        ),
+        children
+      ]
+    }
+  );
+}
+function ChordInterceptor({
+  bindings,
+  pendingChordRef,
+  setPendingChord,
+  activeContexts,
+  handlerRegistryRef
+}) {
+  const handleInput = useCallback2(
+    (input, key, event) => {
+      if ((key.wheelUp || key.wheelDown) && pendingChordRef.current === null) {
+        return;
+      }
+      const registry = handlerRegistryRef.current;
+      const handlerContexts = /* @__PURE__ */ new Set();
+      if (registry) {
+        for (const handlers of registry.values()) {
+          for (const registration of handlers) {
+            handlerContexts.add(registration.context);
+          }
+        }
+      }
+      const contexts = [
+        ...handlerContexts,
+        ...activeContexts,
+        "Global"
+      ];
+      const wasInChord = pendingChordRef.current !== null;
+      const result = resolveKeyWithChordState(
+        input,
+        key,
+        contexts,
+        bindings,
+        pendingChordRef.current
+      );
+      switch (result.type) {
+        case "chord_started":
+          setPendingChord(result.pending);
+          event.stopImmediatePropagation();
+          break;
+        case "match":
+          setPendingChord(null);
+          if (wasInChord) {
+            const contextsSet = new Set(contexts);
+            if (registry) {
+              const handlers = registry.get(result.action);
+              if (handlers && handlers.size > 0) {
+                for (const registration of handlers) {
+                  if (contextsSet.has(registration.context)) {
+                    registration.handler();
+                    event.stopImmediatePropagation();
+                    break;
+                  }
+                }
+              }
+            }
+          }
+          break;
+        case "chord_cancelled":
+          setPendingChord(null);
+          event.stopImmediatePropagation();
+          break;
+        case "unbound":
+          setPendingChord(null);
+          event.stopImmediatePropagation();
+          break;
+        case "none":
+          break;
+      }
+    },
+    [bindings, pendingChordRef, setPendingChord, activeContexts, handlerRegistryRef]
+  );
+  useInput2(handleInput);
+  return null;
+}
+
+// src/PromptInput.tsx
+import { useState as useState3, useCallback as useCallback3 } from "react";
+import { Text as Text5, Box as Box2, useInput as useInput3 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function PromptInput({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  prefix = "\u276F",
+  prefixColor = "cyan",
+  disabled = false,
+  commands = [],
+  onCommandSelect,
+  history = []
+}) {
+  const [cursor, setCursor] = useState3(0);
+  const [historyIndex, setHistoryIndex] = useState3(-1);
+  const [suggestionIndex, setSuggestionIndex] = useState3(0);
+  const [showSuggestions, setShowSuggestions] = useState3(false);
+  const suggestions = value.startsWith("/") && commands.length > 0 ? commands.filter((cmd) => `/${cmd.name}`.startsWith(value)) : [];
+  const hasSuggestions = showSuggestions && suggestions.length > 0;
+  const updateValue = useCallback3(
+    (newValue, newCursor) => {
+      onChange(newValue);
+      setCursor(newCursor ?? newValue.length);
+      setHistoryIndex(-1);
+      setShowSuggestions(newValue.startsWith("/"));
+      setSuggestionIndex(0);
+    },
+    [onChange]
+  );
+  useInput3(
+    (input, key) => {
+      if (disabled) return;
+      if (key.return) {
+        if (hasSuggestions) {
+          const cmd = suggestions[suggestionIndex];
+          const cmdValue = `/${cmd.name}`;
+          onCommandSelect?.(cmd.name);
+          onChange(cmdValue);
+          setCursor(cmdValue.length);
+          setShowSuggestions(false);
+          return;
+        }
+        if (value.length > 0) {
+          onSubmit(value);
+        }
+        return;
+      }
+      if (key.escape) {
+        if (hasSuggestions) {
+          setShowSuggestions(false);
+        }
+        return;
+      }
+      if (key.tab) {
+        if (hasSuggestions) {
+          const cmd = suggestions[suggestionIndex];
+          const cmdValue = `/${cmd.name} `;
+          updateValue(cmdValue);
+        }
+        return;
+      }
+      if (key.upArrow) {
+        if (hasSuggestions) {
+          setSuggestionIndex((i) => i > 0 ? i - 1 : suggestions.length - 1);
+          return;
+        }
+        if (history.length > 0) {
+          const nextIndex = historyIndex + 1;
+          if (nextIndex < history.length) {
+            setHistoryIndex(nextIndex);
+            const histValue = history[nextIndex];
+            onChange(histValue);
+            setCursor(histValue.length);
+          }
+        }
+        return;
+      }
+      if (key.downArrow) {
+        if (hasSuggestions) {
+          setSuggestionIndex((i) => i < suggestions.length - 1 ? i + 1 : 0);
+          return;
+        }
+        if (historyIndex > 0) {
+          const nextIndex = historyIndex - 1;
+          setHistoryIndex(nextIndex);
+          const histValue = history[nextIndex];
+          onChange(histValue);
+          setCursor(histValue.length);
+        } else if (historyIndex === 0) {
+          setHistoryIndex(-1);
+          onChange("");
+          setCursor(0);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursor((c) => Math.min(value.length, c + 1));
+        return;
+      }
+      if (key.home || key.ctrl && input === "a") {
+        setCursor(0);
+        return;
+      }
+      if (key.end || key.ctrl && input === "e") {
+        setCursor(value.length);
+        return;
+      }
+      if (key.ctrl && input === "w") {
+        if (cursor > 0) {
+          let i = cursor - 1;
+          while (i > 0 && value[i - 1] === " ") i--;
+          while (i > 0 && value[i - 1] !== " ") i--;
+          const newValue = value.slice(0, i) + value.slice(cursor);
+          updateValue(newValue, i);
+        }
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        const newValue = value.slice(cursor);
+        updateValue(newValue, 0);
+        return;
+      }
+      if (key.backspace) {
+        if (cursor > 0) {
+          const newValue = value.slice(0, cursor - 1) + value.slice(cursor);
+          updateValue(newValue, cursor - 1);
+        }
+        return;
+      }
+      if (key.delete) {
+        if (cursor < value.length) {
+          const newValue = value.slice(0, cursor) + value.slice(cursor + 1);
+          updateValue(newValue, cursor);
+        }
+        return;
+      }
+      if (key.ctrl || key.meta) return;
+      if (input.length > 0) {
+        const newValue = value.slice(0, cursor) + input + value.slice(cursor);
+        updateValue(newValue, cursor + input.length);
+      }
+    },
+    { isActive: !disabled }
+  );
+  const renderTextWithCursor = () => {
+    if (value.length === 0 && placeholder) {
+      return /* @__PURE__ */ jsxs4(Text5, { children: [
+        /* @__PURE__ */ jsx6(Text5, { inverse: true, children: " " }),
+        /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: placeholder })
+      ] });
+    }
+    const before = value.slice(0, cursor);
+    const atCursor = cursor < value.length ? value[cursor] : " ";
+    const after = cursor < value.length ? value.slice(cursor + 1) : "";
+    return /* @__PURE__ */ jsxs4(Text5, { children: [
+      before,
+      /* @__PURE__ */ jsx6(Text5, { inverse: true, children: atCursor }),
+      after
+    ] });
+  };
+  return /* @__PURE__ */ jsxs4(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsxs4(Text5, { color: prefixColor, children: [
+        prefix,
+        " "
+      ] }),
+      renderTextWithCursor()
+    ] }),
+    hasSuggestions && /* @__PURE__ */ jsx6(Box2, { flexDirection: "column", marginLeft: 2, children: suggestions.map((cmd, i) => /* @__PURE__ */ jsxs4(Box2, { children: [
+      /* @__PURE__ */ jsx6(
+        Text5,
+        {
+          inverse: i === suggestionIndex,
+          color: i === suggestionIndex ? "cyan" : void 0,
+          children: `  /${cmd.name}`
+        }
+      ),
+      /* @__PURE__ */ jsx6(Text5, { dimColor: true, children: `  ${cmd.description}` })
+    ] }, cmd.name)) })
+  ] });
+}
+
+// src/Spinner.tsx
+import { useState as useState4, useEffect as useEffect4, useRef as useRef2 } from "react";
+import { Text as Text6, Box as Box3 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL = 80;
+var VERB_ROTATE_INTERVAL = 4e3;
+var ELAPSED_SHOW_AFTER = 1e3;
+var DEFAULT_COLOR = "#DA7756";
+function Spinner({
+  label,
+  verb,
+  verbs,
+  color = DEFAULT_COLOR,
+  showElapsed = true
+}) {
+  const [frameIndex, setFrameIndex] = useState4(0);
+  const [verbIndex, setVerbIndex] = useState4(0);
+  const [elapsed, setElapsed] = useState4(0);
+  const startRef = useRef2(Date.now());
+  const allVerbs = verbs ?? (verb ? [verb] : ["Thinking"]);
+  useEffect4(() => {
+    const id = setInterval(() => {
+      setFrameIndex((i) => (i + 1) % FRAMES.length);
+      setElapsed(Date.now() - startRef.current);
+    }, SPINNER_INTERVAL);
+    return () => clearInterval(id);
+  }, []);
+  useEffect4(() => {
+    if (allVerbs.length <= 1) return;
+    const id = setInterval(() => {
+      setVerbIndex((i) => (i + 1) % allVerbs.length);
+    }, VERB_ROTATE_INTERVAL);
+    return () => clearInterval(id);
+  }, [allVerbs.length]);
+  const frame = FRAMES[frameIndex];
+  const currentVerb = allVerbs[verbIndex % allVerbs.length];
+  const elapsedSec = Math.floor(elapsed / 1e3);
+  const showTime = showElapsed && elapsed >= ELAPSED_SHOW_AFTER;
+  return /* @__PURE__ */ jsxs5(Box3, { children: [
+    /* @__PURE__ */ jsx7(Text6, { color, children: frame }),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      " ",
+      currentVerb,
+      "..."
+    ] }),
+    label && /* @__PURE__ */ jsxs5(Text6, { children: [
+      " ",
+      label
+    ] }),
+    showTime && /* @__PURE__ */ jsxs5(Text6, { dimColor: true, children: [
+      " (",
+      elapsedSec,
+      "s)"
+    ] })
+  ] });
+}
+
+// src/Select.tsx
+import { useState as useState5, useRef as useRef3, useMemo as useMemo2, useCallback as useCallback4 } from "react";
+import { Box as Box4, Text as Text7, useInput as useInput4 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function useListNavigation(opts) {
+  const { options, maxVisible, onCancel, onSelect, extraHandler } = opts;
+  const [focusIndex, setFocusIndex] = useState5(0);
+  const focusRef = useRef3(focusIndex);
+  focusRef.current = focusIndex;
+  const total = options.length;
+  const max = maxVisible ?? total;
+  const scrollOffset = useMemo2(() => {
+    if (total <= max) return 0;
+    const half = Math.floor(max / 2);
+    if (focusIndex <= half) return 0;
+    if (focusIndex >= total - max + half) return total - max;
+    return focusIndex - half;
+  }, [focusIndex, total, max]);
+  const visibleOptions = useMemo2(
+    () => options.slice(scrollOffset, scrollOffset + max),
+    [options, scrollOffset, max]
+  );
+  const moveFocus = useCallback4(
+    (dir) => {
+      setFocusIndex((prev) => {
+        let next = prev;
+        for (let i = 0; i < total; i++) {
+          next = (next + dir + total) % total;
+          if (!options[next].disabled) return next;
+        }
+        return prev;
+      });
+    },
+    [options, total]
+  );
+  useInput4((input, key) => {
+    if (extraHandler?.(input, key, focusRef.current)) return;
+    if (key.upArrow || input === "k") {
+      moveFocus(-1);
+    } else if (key.downArrow || input === "j") {
+      moveFocus(1);
+    } else if (key.return) {
+      if (!options[focusRef.current]?.disabled) {
+        onSelect(focusRef.current);
+      }
+    } else if (key.escape) {
+      onCancel?.();
+    } else if (input >= "1" && input <= "9") {
+      const idx = parseInt(input, 10) - 1;
+      if (idx < total && !options[idx].disabled) {
+        setFocusIndex(idx);
+        onSelect(idx);
+      }
+    }
+  });
+  return { focusIndex, scrollOffset, visibleOptions, max, total };
+}
+function ScrollHint({ count, direction }) {
+  return /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+    "  ",
+    direction === "up" ? "\u2191" : "\u2193",
+    " ",
+    count,
+    " more"
+  ] });
+}
+function Select({
+  options,
+  defaultValue,
+  onChange,
+  onCancel,
+  title,
+  maxVisible
+}) {
+  const handleSelect = useCallback4(
+    (index) => onChange(options[index].value),
+    [onChange, options]
+  );
+  const { focusIndex, scrollOffset, visibleOptions, max, total } = useListNavigation({ options, maxVisible, onCancel, onSelect: handleSelect });
+  return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
+    title && /* @__PURE__ */ jsx8(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx8(Text7, { bold: true, children: title }) }),
+    scrollOffset > 0 && /* @__PURE__ */ jsx8(ScrollHint, { count: scrollOffset, direction: "up" }),
+    visibleOptions.map((opt, i) => {
+      const realIndex = scrollOffset + i;
+      const isFocused = realIndex === focusIndex;
+      const isSelected = opt.value === defaultValue;
+      const isDisabled = opt.disabled === true;
+      return /* @__PURE__ */ jsxs6(Box4, { children: [
+        /* @__PURE__ */ jsxs6(Text7, { color: isFocused ? "cyan" : void 0, children: [
+          isFocused ? "\u276F" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs6(
+          Text7,
+          {
+            color: isDisabled ? "gray" : isFocused ? "cyan" : void 0,
+            bold: isFocused,
+            dimColor: isDisabled,
+            children: [
+              realIndex + 1,
+              ". ",
+              opt.label
+            ]
+          }
+        ),
+        isSelected && /* @__PURE__ */ jsx8(Text7, { color: "green", children: " \u2713" }),
+        opt.description && /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+          "   ",
+          opt.description
+        ] })
+      ] }, realIndex);
+    }),
+    scrollOffset + max < total && /* @__PURE__ */ jsx8(ScrollHint, { count: total - scrollOffset - max, direction: "down" }),
+    /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Enter to confirm \xB7 Esc to exit" }) })
+  ] });
+}
+function MultiSelect({
+  options,
+  selectedValues = [],
+  onToggle,
+  onConfirm,
+  onCancel,
+  title,
+  maxVisible
+}) {
+  const [selected, setSelected] = useState5(() => new Set(selectedValues));
+  const handleConfirm = useCallback4(
+    () => onConfirm(Array.from(selected)),
+    [onConfirm, selected]
+  );
+  const handleSpace = useCallback4(
+    (input, _key, focusIndex2) => {
+      if (input !== " ") return false;
+      const opt = options[focusIndex2];
+      if (!opt || opt.disabled) return true;
+      setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(opt.value)) next.delete(opt.value);
+        else next.add(opt.value);
+        return next;
+      });
+      onToggle(opt.value);
+      return true;
+    },
+    [options, onToggle]
+  );
+  const { focusIndex, scrollOffset, visibleOptions, max, total } = useListNavigation({
+    options,
+    maxVisible,
+    onCancel,
+    onSelect: handleConfirm,
+    extraHandler: handleSpace
+  });
+  return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
+    title && /* @__PURE__ */ jsx8(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx8(Text7, { bold: true, children: title }) }),
+    scrollOffset > 0 && /* @__PURE__ */ jsx8(ScrollHint, { count: scrollOffset, direction: "up" }),
+    visibleOptions.map((opt, i) => {
+      const realIndex = scrollOffset + i;
+      const isFocused = realIndex === focusIndex;
+      const isChecked = selected.has(opt.value);
+      const isDisabled = opt.disabled === true;
+      return /* @__PURE__ */ jsxs6(Box4, { children: [
+        /* @__PURE__ */ jsxs6(Text7, { color: isFocused ? "cyan" : void 0, children: [
+          isFocused ? "\u276F" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs6(
+          Text7,
+          {
+            color: isDisabled ? "gray" : isFocused ? "cyan" : void 0,
+            bold: isFocused,
+            dimColor: isDisabled,
+            children: [
+              isChecked ? "[x]" : "[ ]",
+              " ",
+              realIndex + 1,
+              ". ",
+              opt.label
+            ]
+          }
+        ),
+        opt.description && /* @__PURE__ */ jsxs6(Text7, { dimColor: true, children: [
+          "   ",
+          opt.description
+        ] })
+      ] }, realIndex);
+    }),
+    scrollOffset + max < total && /* @__PURE__ */ jsx8(ScrollHint, { count: total - scrollOffset - max, direction: "down" }),
+    /* @__PURE__ */ jsx8(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text7, { dimColor: true, children: "Space to toggle \xB7 Enter to confirm \xB7 Esc to exit" }) })
+  ] });
+}
+
+// src/MessageList.tsx
+import { Box as Box5, Text as Text8 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var ROLE_CONFIG = {
+  user: { icon: "\u276F", label: "You", color: "cyan" },
+  assistant: { icon: "\u25CF", label: "Claude", color: "#DA7756" },
+  system: { icon: "\u273B", label: "System", color: void 0 }
+};
+function MessageItem({
+  message,
+  renderMessage
+}) {
+  if (renderMessage) {
+    return renderMessage(message);
+  }
+  const config = ROLE_CONFIG[message.role];
+  const isSystem = message.role === "system";
+  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs7(Box5, { children: [
+      /* @__PURE__ */ jsx9(Text8, { color: config.color, dimColor: isSystem, children: config.icon }),
+      /* @__PURE__ */ jsxs7(Text8, { color: config.color, dimColor: isSystem, bold: !isSystem, children: [
+        " ",
+        config.label
+      ] })
+    ] }),
+    message.content.split("\n").map((line, i) => /* @__PURE__ */ jsx9(Box5, { marginLeft: 2, children: /* @__PURE__ */ jsx9(Text8, { dimColor: isSystem, children: line }) }, i))
+  ] });
+}
+function MessageList({
+  messages,
+  streamingContent,
+  renderMessage
+}) {
+  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+    messages.map((message, i) => /* @__PURE__ */ jsx9(Box5, { flexDirection: "column", marginTop: i > 0 ? 1 : 0, children: /* @__PURE__ */ jsx9(MessageItem, { message, renderMessage }) }, message.id)),
+    streamingContent != null && streamingContent.length > 0 && /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", marginTop: messages.length > 0 ? 1 : 0, children: [
+      /* @__PURE__ */ jsxs7(Box5, { children: [
+        /* @__PURE__ */ jsx9(Text8, { color: "#DA7756", children: "\u25CF" }),
+        /* @__PURE__ */ jsxs7(Text8, { color: "#DA7756", bold: true, children: [
+          " ",
+          "Claude"
+        ] })
+      ] }),
+      streamingContent.split("\n").map((line, i) => /* @__PURE__ */ jsx9(Box5, { marginLeft: 2, children: /* @__PURE__ */ jsxs7(Text8, { children: [
+        line,
+        i === streamingContent.split("\n").length - 1 && /* @__PURE__ */ jsx9(Text8, { color: "#DA7756", children: "\u2588" })
+      ] }) }, i))
+    ] })
+  ] });
+}
+
+// src/StreamingText.tsx
+import { useState as useState6, useEffect as useEffect5, useRef as useRef4 } from "react";
+import { Text as Text9 } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx10 } from "react/jsx-runtime";
+function StreamingText({
+  text,
+  speed = 3,
+  interval = 20,
+  onComplete,
+  color
+}) {
+  const [revealed, setRevealed] = useState6(0);
+  const onCompleteRef = useRef4(onComplete);
+  onCompleteRef.current = onComplete;
+  useEffect5(() => {
+    if (revealed >= text.length) return;
+    const id = setInterval(() => {
+      setRevealed((prev) => {
+        const next = Math.min(prev + speed, text.length);
+        if (next >= text.length) {
+          onCompleteRef.current?.();
+        }
+        return next;
+      });
+    }, interval);
+    return () => clearInterval(id);
+  }, [text.length, speed, interval, revealed >= text.length]);
+  return /* @__PURE__ */ jsx10(Text9, { color, children: text.slice(0, revealed) });
+}
+
+// src/REPL.tsx
+import { useState as useState7, useCallback as useCallback5, useRef as useRef5 } from "react";
+import { Box as Box6, useInput as useInput5, useApp } from "@claude-code-kit/ink-renderer";
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function REPL({
+  onSubmit,
+  onExit,
+  messages,
+  isLoading = false,
+  streamingContent,
+  commands = [],
+  model,
+  statusSegments,
+  prefix = "\u276F",
+  placeholder,
+  history: externalHistory,
+  renderMessage,
+  spinner
+}) {
+  const { exit } = useApp();
+  const [inputValue, setInputValue] = useState7("");
+  const [internalHistory, setInternalHistory] = useState7([]);
+  const submittingRef = useRef5(false);
+  const history = externalHistory ?? internalHistory;
+  const promptCommands = commands.map((c) => ({
+    name: c.name,
+    description: c.description
+  }));
+  const handleSubmit = useCallback5(
+    (value) => {
+      if (submittingRef.current) return;
+      const trimmed = value.trim();
+      if (!trimmed) return;
+      if (trimmed.startsWith("/")) {
+        const spaceIndex = trimmed.indexOf(" ");
+        const cmdName = spaceIndex >= 0 ? trimmed.slice(1, spaceIndex) : trimmed.slice(1);
+        const cmdArgs = spaceIndex >= 0 ? trimmed.slice(spaceIndex + 1).trim() : "";
+        const cmd = commands.find((c) => c.name === cmdName);
+        if (cmd) {
+          setInputValue("");
+          cmd.onExecute(cmdArgs);
+          return;
+        }
+      }
+      submittingRef.current = true;
+      setInputValue("");
+      if (!externalHistory) {
+        setInternalHistory((prev) => [trimmed, ...prev]);
+      }
+      const result = onSubmit(trimmed);
+      if (result && typeof result.then === "function") {
+        result.finally(() => {
+          submittingRef.current = false;
+        });
+      } else {
+        submittingRef.current = false;
+      }
+    },
+    [commands, onSubmit, externalHistory]
+  );
+  useInput5(
+    (_input, key) => {
+      if (key.ctrl && _input === "c" && isLoading) {
+        return;
+      }
+      if (key.ctrl && _input === "d") {
+        if (onExit) {
+          onExit();
+        } else {
+          exit();
+        }
+      }
+    },
+    { isActive: true }
+  );
+  const resolvedSegments = statusSegments ?? buildDefaultSegments(model);
+  return /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsxs8(Box6, { flexDirection: "column", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx11(
+        MessageList,
+        {
+          messages,
+          streamingContent,
+          renderMessage
+        }
+      ),
+      isLoading && !streamingContent && /* @__PURE__ */ jsx11(Box6, { marginTop: messages.length > 0 ? 1 : 0, children: spinner ?? /* @__PURE__ */ jsx11(Spinner, {}) })
+    ] }),
+    /* @__PURE__ */ jsx11(Divider, {}),
+    /* @__PURE__ */ jsx11(
+      PromptInput,
+      {
+        value: inputValue,
+        onChange: setInputValue,
+        onSubmit: handleSubmit,
+        prefix,
+        placeholder,
+        disabled: isLoading,
+        commands: promptCommands,
+        history
+      }
+    ),
+    /* @__PURE__ */ jsx11(Divider, {}),
+    resolvedSegments.length > 0 && /* @__PURE__ */ jsx11(StatusLine, { segments: resolvedSegments })
+  ] });
+}
+function buildDefaultSegments(model) {
+  if (!model) return [];
+  return [{ content: model, color: "green" }];
+}
+export {
+  CommandRegistry,
+  DEFAULT_BINDINGS,
+  Divider,
+  KeybindingSetup,
+  MessageList,
+  MultiSelect,
+  ProgressBar,
+  PromptInput,
+  REPL,
+  Select,
+  Spinner,
+  StatusIcon,
+  StatusLine,
+  StreamingText,
+  clearCommand,
+  createCommandRegistry,
+  defineCommand,
+  defineJSXCommand,
+  defineLocalCommand,
+  exitCommand,
+  helpCommand,
+  useKeybinding,
+  useKeybindings,
+  useStatusLine
+};