@narumitw/pi-btw 0.57.1 → 0.58.0

package/dist/index.ts

@@ -481,15 +481,23 @@ import {
   copyToClipboard as copyToHostClipboard
 } from "@earendil-works/pi-coding-agent";
 import {
-  isKeyRelease,
-  isKittyProtocolActive,
+  isKeyRelease as isKeyRelease2,
+  isKittyProtocolActive as isKittyProtocolActive2,
   Key as Key2,
-  matchesKey as matchesKey2,
   parseKey,
   TuiAltScreen,
   truncateToWidth as truncateToWidth2
 } from "@earendil-works/pi-tui";
 
+// src/keybindings.ts
+import {
+  isKeyRelease,
+  isKittyProtocolActive,
+  KeybindingsManager,
+  matchesKey as matchesKey2,
+  TUI_KEYBINDINGS
+} from "@earendil-works/pi-tui";
+
 // src/text.ts
 function sanitizeSingleLine(text) {
   return [...text.replace(/[\r\n\t]/gu, " ")].filter((character) => {
@@ -510,6 +518,234 @@ function formatKeyLabel2(key) {
   }).join("+");
 }
 
+// src/keybindings.ts
+var BTW_SHORTCUT_ACTIONS = ["exit", "cycleThinkingLevel", "bringToMain"];
+var MODIFIERS = ["shift", "alt", "ctrl", "super"];
+var SYMBOLS = "`-=[]\\;',./!@#$%^&*()_|~{}:<>?";
+var SPECIAL = {
+  escape: 27,
+  tab: 9,
+  enter: 13,
+  space: 32,
+  backspace: 127,
+  insert: 57425,
+  delete: 57426,
+  home: 57423,
+  end: 57424,
+  pageup: 57421,
+  pagedown: 57422,
+  left: 57417,
+  right: 57418,
+  up: 57419,
+  down: 57420
+};
+var FUNCTION_INPUTS = [
+  "OP",
+  "OQ",
+  "OR",
+  "OS",
+  "[15~",
+  "[17~",
+  "[18~",
+  "[19~",
+  "[20~",
+  "[21~",
+  "[23~",
+  "[24~"
+];
+var LEGACY_INPUTS = [
+  ...Array.from({ length: 128 }, (_, code) => String.fromCharCode(code)),
+  ...Array.from({ length: 128 }, (_, code) => `\x1B${String.fromCharCode(code)}`),
+  "\x1B[Z",
+  "\x1BOM",
+  "\x1B[E",
+  "\x1B[e",
+  "\x1BOe",
+  ...FUNCTION_INPUTS.map((suffix) => `\x1B${suffix}`)
+];
+function normalizeBtwKey(value) {
+  if (typeof value !== "string" || value.length > 80 || /[\s\p{Cc}]/u.test(value)) return void 0;
+  const parts = value.toLowerCase().split("+");
+  let base = parts.pop();
+  if (!base) return void 0;
+  if (base === "esc") base = "escape";
+  if (base === "return") base = "enter";
+  if (new Set(parts).size !== parts.length || parts.some((part) => !MODIFIERS.includes(part)))
+    return void 0;
+  if (!Object.hasOwn(SPECIAL, base) && base !== "clear" && !/^f(?:[1-9]|1[0-2])$/u.test(base) && !(base.length === 1 && (/^[a-z0-9]$/u.test(base) || SYMBOLS.includes(base))))
+    return void 0;
+  if ((base === "escape" || base.startsWith("f") && base.length > 1) && parts.length)
+    return void 0;
+  if (base === "clear" && (parts.length > 1 || parts.length === 1 && !["ctrl", "shift"].includes(parts[0] ?? "")))
+    return void 0;
+  return [...MODIFIERS.filter((part) => parts.includes(part)), base].join("+");
+}
+function inputsFor(key) {
+  const parts = key.split("+");
+  const base = parts.pop() ?? "";
+  const modifier = MODIFIERS.reduce(
+    (mask, part, bit) => mask | (parts.includes(part) ? 1 << bit : 0),
+    0
+  );
+  const code = SPECIAL[base] ?? (base.length === 1 ? base.charCodeAt(0) : void 0);
+  const inputs = code === void 0 ? LEGACY_INPUTS : [...LEGACY_INPUTS, `\x1B[${code};${modifier + 1}u`];
+  return inputs.filter((input) => matchesKey2(input, key));
+}
+function btwKeysOverlap(first, second) {
+  const normalized = normalizeBtwKey(first);
+  return normalized !== void 0 && inputsFor(normalized).some((input) => matchesKey2(input, second));
+}
+function reservedKeys(keybindings, copyOnSelect) {
+  return [
+    "ctrl+c",
+    "shift+backspace",
+    "shift+delete",
+    "shift+space",
+    // Exact-range review uses these fixed selection actions even if Editor is remapped.
+    "shift+left",
+    "shift+right",
+    "shift+up",
+    "shift+down",
+    "left",
+    "right",
+    "enter",
+    "alt+enter",
+    "ctrl+j",
+    "pageUp",
+    "pageDown",
+    ...Object.keys(TUI_KEYBINDINGS).flatMap(
+      (id) => keybindings.getKeys(id)
+    ),
+    ...!copyOnSelect ? keybindings.getKeys("app.message.copy") : []
+  ];
+}
+function isTextKey(key) {
+  const parts = key.split("+");
+  const base = parts.at(-1) ?? "";
+  return (base.length === 1 || base === "space") && !parts.some((part) => ["ctrl", "alt", "super"].includes(part));
+}
+function resolveBtwShortcuts(overrides = {}, keybindings, copyOnSelect = true) {
+  let mode = isKittyProtocolActive();
+  let snapshot = resolveShortcutSnapshot(overrides, keybindings, copyOnSelect);
+  const current = () => {
+    if (mode !== isKittyProtocolActive()) {
+      mode = isKittyProtocolActive();
+      snapshot = resolveShortcutSnapshot(overrides, keybindings, copyOnSelect);
+    }
+    return snapshot;
+  };
+  return {
+    get keys() {
+      return current().keys;
+    },
+    get warnings() {
+      return current().warnings;
+    },
+    matches: (data, action) => current().matches(data, action),
+    label: (action) => current().label(action)
+  };
+}
+function resolveShortcutSnapshot(overrides = {}, keybindings, copyOnSelect = true) {
+  const reserved = reservedKeys(keybindings, copyOnSelect);
+  const keys = { exit: ["ctrl+c"], cycleThinkingLevel: [], bringToMain: [] };
+  const warnings = [];
+  const defaults = {
+    exit: ["ctrl+c"],
+    cycleThinkingLevel: keybindings.getKeys("app.thinking.cycle"),
+    bringToMain: ["ctrl+r"]
+  };
+  const usable = (action, candidate, inherited = false) => {
+    const key = normalizeBtwKey(candidate);
+    if (!key || !inherited && isTextKey(key)) return void 0;
+    const inputs = inputsFor(key);
+    if (!inputs.length) return void 0;
+    if (action === "exit" && key === "ctrl+c") return key;
+    if (reserved.some(
+      (other) => typeof other === "string" && inputs.some((input) => matchesKey2(input, other))
+    ))
+      return void 0;
+    return key;
+  };
+  const candidates = {};
+  const availableDefaults = { ...defaults };
+  for (const action of BTW_SHORTCUT_ACTIONS) {
+    availableDefaults[action] = defaults[action].map((key) => usable(action, key, action === "cycleThinkingLevel")).filter((key) => key !== void 0);
+    const override = overrides[action];
+    if (override !== void 0) candidates[action] = usable(action, override);
+  }
+  for (; ; ) {
+    const rejected = BTW_SHORTCUT_ACTIONS.filter((action) => {
+      const candidate = candidates[action];
+      return candidate !== void 0 && BTW_SHORTCUT_ACTIONS.some(
+        (other) => other !== action && (candidates[other] ? [candidates[other]] : availableDefaults[other]).some(
+          (key) => btwKeysOverlap(candidate, key)
+        )
+      );
+    });
+    if (!rejected.length) break;
+    for (const action of rejected) delete candidates[action];
+  }
+  for (const action of BTW_SHORTCUT_ACTIONS) {
+    const override = overrides[action];
+    const selected = candidates[action];
+    if (override !== void 0 && !selected)
+      warnings.push(
+        `${action}: configured shortcut is invalid or conflicts with a reserved action; using an available default.`
+      );
+    const effective = selected ? [selected] : availableDefaults[action].filter(
+      (key) => !BTW_SHORTCUT_ACTIONS.some(
+        (other) => other !== action && keys[other].some((used) => btwKeysOverlap(key, used))
+      )
+    );
+    keys[action] = action === "exit" ? [.../* @__PURE__ */ new Set([...effective, "ctrl+c"])] : effective;
+    if (!keys[action].length && (override !== void 0 || defaults[action].length > 0))
+      warnings.push(`${action}: no usable shortcut; change Pi BTW Settings or Pi keybindings.`);
+  }
+  return {
+    keys,
+    warnings,
+    matches: (data, action) => !isKeyRelease(data) && keys[action].some((key) => matchesKey2(data, key)),
+    label: (action) => keys[action].length ? formatKeyLabel2(keys[action][0] ?? "") : "Unavailable"
+  };
+}
+function validateBtwShortcutEdit(action, value, overrides, keybindings, copyOnSelect) {
+  if (value === void 0) return void 0;
+  if (!normalizeBtwKey(value))
+    return "Invalid key combination. Use a Pi key name such as ctrl+q or f6.";
+  const next = { ...overrides, [action]: value };
+  const resolved = resolveBtwShortcuts(next, keybindings, copyOnSelect);
+  const previous = resolveBtwShortcuts(overrides, keybindings, copyOnSelect);
+  for (const item of BTW_SHORTCUT_ACTIONS) {
+    if (item === action && !resolved.keys[item].includes(normalizeBtwKey(value) ?? "") || item !== action && previous.keys[item].some((key) => !resolved.keys[item].includes(key))) {
+      return `${item} conflicts with another BTW shortcut, editing, selection, search, scrolling, or copying. Choose a different key.`;
+    }
+  }
+  return void 0;
+}
+var bindingsByTui = /* @__PURE__ */ new WeakMap();
+function setBtwShortcuts(tui, shortcuts) {
+  bindingsByTui.set(tui, shortcuts);
+}
+function getBtwShortcuts(tui, keybindings) {
+  return bindingsByTui.get(tui) ?? resolveBtwShortcuts(
+    {},
+    keybindings ?? new KeybindingsManager({
+      ...TUI_KEYBINDINGS,
+      "app.thinking.cycle": { defaultKeys: "shift+tab" }
+    })
+  );
+}
+var BtwPasteGuard = class {
+  active = false;
+  consume(data) {
+    const wasActive = this.active;
+    const starts = data.includes("\x1B[200~");
+    if (starts) this.active = true;
+    if (this.active && data.includes("\x1B[201~")) this.active = false;
+    return wasActive || starts;
+  }
+};
+
 // src/fullscreen-ui.ts
 var FullscreenUiDisposedError = class extends Error {
   constructor() {
@@ -690,7 +926,7 @@ function legacyRawInput(key) {
   const parts = key.split("+");
   const base = parts.at(-1) ?? "";
   if (parts.length === 2 && parts[0] === "ctrl") return rawCtrlInput(base);
-  if (isKittyProtocolActive()) return void 0;
+  if (isKittyProtocolActive2()) return void 0;
   if (parts.length === 2 && parts[0] === "alt" && base.length === 1) return `\x1B${base}`;
   if (parts.length === 3 && parts[0] === "ctrl" && parts[1] === "alt") {
     const input = rawCtrlInput(base);
@@ -761,7 +997,7 @@ function createBtwFullscreenTui(parent, theme, keybindings, copyOnSelect, manual
       if (isInBracketedPaste && data.includes(BRACKETED_PASTE_END)) {
         isInBracketedPaste = false;
       }
-      if (wasInBracketedPaste || startsBracketedPaste || fullscreen.hasFocusedOverlay() || isKeyRelease(data) || !keybindings.matches(data, "app.message.copy")) {
+      if (wasInBracketedPaste || startsBracketedPaste || fullscreen.hasFocusedOverlay() || isKeyRelease2(data) || !keybindings.matches(data, "app.message.copy")) {
         return void 0;
       }
       if (!fullscreen.hasActiveSelection()) {
@@ -839,9 +1075,30 @@ var BtwFullscreenHost = class {
       this.fullscreen = this.createTui(this.parent, this.theme, this.keybindings, this.options);
       this.fullscreenCreated = true;
       this.fullscreen.start();
+      const shortcuts = resolveBtwShortcuts(
+        this.options.keybindings,
+        this.keybindings,
+        this.options.copyOnSelect ?? true
+      );
+      setBtwShortcuts(this.fullscreen, shortcuts);
+      let previousWarnings = [];
+      const reportWarnings = () => {
+        const warnings = shortcuts.warnings;
+        for (const warning of warnings) {
+          if (previousWarnings.includes(warning)) continue;
+          try {
+            this.ctx.ui.notify(`Pi BTW: ${warning}`, "warning");
+          } catch {
+          }
+        }
+        previousWarnings = warnings;
+      };
+      const pasteGuard = new BtwPasteGuard();
       const addHardCancelListener = this.fullscreen.addInputListenerBeforeAll?.bind(this.fullscreen) ?? this.fullscreen.addInputListenerBeforeViewport?.bind(this.fullscreen) ?? this.fullscreen.addInputListener.bind(this.fullscreen);
       this.removeHardCancelListener = addHardCancelListener((data) => {
-        if (isKeyRelease(data) || !matchesKey2(data, Key2.ctrl("c"))) return void 0;
+        reportWarnings();
+        if (pasteGuard.consume(data) || !shortcuts.matches(data, "exit")) return void 0;
+        this.disposed = true;
         try {
           this.hardCancelActiveCustom?.();
         } finally {
@@ -1242,6 +1499,17 @@ function btwSettingsPath() {
 function normalizeBtwSettings(value) {
   if (!isSettingsDocument(value)) return void 0;
   const settings = {};
+  if (Object.hasOwn(value, "keybindings")) {
+    const keys = value.keybindings;
+    if (!isSettingsDocument(keys)) return void 0;
+    settings.keybindings = {};
+    for (const action of BTW_SHORTCUT_ACTIONS) {
+      if (!Object.hasOwn(keys, action)) continue;
+      const key = normalizeBtwKey(keys[action]);
+      if (!key) return void 0;
+      settings.keybindings[action] = key;
+    }
+  }
   if (Object.hasOwn(value, "model")) {
     const model = Reflect.get(value, "model");
     if (typeof model !== "string" || !parseBtwModelReference(model)) return void 0;
@@ -1285,6 +1553,8 @@ function updateBtwSettings(patch, options = {}) {
   return enqueueMutation(settingsPath, async () => {
     options.signal?.throwIfAborted();
     const current = await readSettingsDocumentForUpdate(settingsPath);
+    options.signal?.throwIfAborted();
+    options.validateCurrent?.(normalizeBtwSettings(current) ?? {});
     const updated = applyBtwSettingsPatch(current, patch);
     const settings = normalizeBtwSettings(updated);
     if (!settings) throw invalidSettingsError(settingsPath, "invalid settings shape");
@@ -1403,6 +1673,16 @@ async function publishSettings(settingsPath, document, signal, beforeRename) {
 }
 function applyBtwSettingsPatch(current, patch) {
   const updated = { ...current };
+  if (patch.keybindings) {
+    const keys = isSettingsDocument(current.keybindings) ? { ...current.keybindings } : {};
+    for (const action of BTW_SHORTCUT_ACTIONS) {
+      if (!Object.hasOwn(patch.keybindings, action)) continue;
+      if (patch.keybindings[action] === void 0) delete keys[action];
+      else keys[action] = patch.keybindings[action];
+    }
+    if (Object.keys(keys).length) updated.keybindings = keys;
+    else delete updated.keybindings;
+  }
   if (Object.hasOwn(patch, "thinkingLevel")) {
     if (patch.thinkingLevel === void 0) delete updated.thinkingLevel;
     else updated.thinkingLevel = patch.thinkingLevel;
@@ -1447,6 +1727,64 @@ async function showBtwCommandMenu(ctx, options) {
   let startSelected = false;
   let treeSelected = false;
   let resumedThreadId;
+  let keybindings;
+  let shortcut = "exit";
+  const shortcutLabels = {
+    exit: "Exit shortcut",
+    cycleThinkingLevel: "Cycle thinking level shortcut",
+    bringToMain: "Bring to main shortcut"
+  };
+  const shortcutValue = (settings, action) => {
+    if (!keybindings) return "Default";
+    const effective = resolveBtwShortcuts(
+      settings.keybindings,
+      keybindings,
+      effectiveFullscreenCopyOnSelect(settings)
+    );
+    const configured = settings.keybindings?.[action];
+    if (configured !== void 0 && !effective.keys[action].includes(configured)) {
+      return `Fallback (${effective.label(action)}; saved ${formatKeyLabel2(configured)})`;
+    }
+    const source = configured === void 0 ? action === "cycleThinkingLevel" ? "Inherit Pi" : "Default" : "Custom";
+    return `${source} (${effective.label(action)})`;
+  };
+  const saveShortcut = async (state, value, signal) => {
+    if (!keybindings || state.kind !== "valid" || signal.aborted)
+      return { kind: "rejected" };
+    const action = shortcut;
+    const manager = keybindings;
+    const validate = (settings) => validateBtwShortcutEdit(
+      action,
+      value,
+      settings.keybindings ?? {},
+      manager,
+      effectiveFullscreenCopyOnSelect(settings)
+    );
+    const error = validate(state.settings);
+    if (error) {
+      notifySafely(ctx, error, "error");
+      return { kind: "rejected" };
+    }
+    try {
+      await updateSettings(
+        { keybindings: { [action]: value === void 0 ? void 0 : normalizeBtwKey(value) } },
+        {
+          settingsPath,
+          signal,
+          validateCurrent: (settings) => {
+            const conflict = validate(settings);
+            if (conflict) throw new Error(conflict);
+          }
+        }
+      );
+      if (signal.aborted) return { kind: "rejected" };
+      notifySafely(ctx, "Pi BTW shortcut saved; applies when opening or resuming BTW.", "info");
+      return { kind: "back" };
+    } catch (error2) {
+      if (!signal.aborted) notifySaveFailure(ctx, error2);
+      return { kind: "rejected" };
+    }
+  };
   const loadState = async () => {
     const loaded = await readSettings(settingsPath);
     if (loaded.kind === "invalid") {
@@ -1498,7 +1836,7 @@ async function showBtwCommandMenu(ctx, options) {
           {
             id: "settings",
             label: "Settings",
-            description: "Choose thinking, shortcut memory, and selection copying",
+            description: "Choose thinking, keybindings, and selection copying",
             to: state.kind === "invalid" ? "invalid" : "settings"
           }
         ],
@@ -1545,9 +1883,34 @@ async function showBtwCommandMenu(ctx, options) {
             currentValue: effectiveFullscreenCopyOnSelect(state.settings) ? "On" : "Off",
             values: ["On", "Off"],
             action: "set-fullscreen-copy"
-          }
+          },
+          ...BTW_SHORTCUT_ACTIONS.map((action) => ({
+            id: action,
+            label: shortcutLabels[action],
+            description: "Edit a BTW-only key combination or restore its default. Ctrl+C always hard-cancels.",
+            currentValue: shortcutValue(state.settings, action),
+            action: "edit-shortcut"
+          }))
         ]
       }),
+      shortcut: ({ state }) => ({
+        kind: "actions",
+        title: shortcutLabels[shortcut],
+        lines: [shortcutValue(state.settings, shortcut), "Ctrl+C always hard-cancels BTW."],
+        items: [
+          { id: "edit", label: "Edit key combination\u2026", to: "shortcut-input" },
+          { id: "reset", label: "Restore default", action: "reset-shortcut" }
+        ],
+        hint: "back"
+      }),
+      "shortcut-input": () => ({
+        kind: "input",
+        title: shortcutLabels[shortcut],
+        lines: ["Type a key name, not the shortcut itself. For example: ctrl+q or f6."],
+        placeholder: "Key combination",
+        action: "save-shortcut",
+        hint: "back"
+      }),
       invalid: ({ state }) => ({
         kind: "detail",
         title: "Pi BTW Settings \xB7 Read only",
@@ -1559,6 +1922,14 @@ async function showBtwCommandMenu(ctx, options) {
       })
     },
     actions: {
+      "edit-shortcut": ({ itemId }) => {
+        if (!BTW_SHORTCUT_ACTIONS.includes(itemId))
+          return { kind: "rejected" };
+        shortcut = itemId;
+        return { kind: "to", screen: "shortcut" };
+      },
+      "save-shortcut": ({ state, value, signal }) => saveShortcut(state, value?.trim() ?? "", signal),
+      "reset-shortcut": ({ state, signal }) => saveShortcut(state, void 0, signal),
       start: async () => {
         startSelected = true;
         return { kind: "close" };
@@ -1622,7 +1993,10 @@ async function showBtwCommandMenu(ctx, options) {
   });
   const result = await runBtwMenuPreservingEditor(
     ctx,
-    (menuContext) => runMenu(menuContext, menu, { getState: loadState })
+    (menuContext) => runMenu(menuContext, menu, { getState: loadState }),
+    (manager) => {
+      keybindings = manager;
+    }
   );
   if (result.kind !== "closed" || result.reason !== "close") return "closed";
   if (resumedThreadId) return { kind: "resume", threadId: resumedThreadId };
@@ -1650,23 +2024,23 @@ async function showBtwCustomPreservingEditor(ctx, factory) {
   }
   return result;
 }
-async function runBtwMenuPreservingEditor(ctx, run) {
+async function runBtwMenuPreservingEditor(ctx, run, onKeybindings) {
   let liveEditorText = ctx.ui.getEditorText();
   let completed = false;
   const ui = new Proxy(ctx.ui, {
     get(target, property) {
       if (property === "custom") {
-        return (factory, customOptions) => target.custom(
-          (tui, theme, keybindings, done) => factory(tui, theme, keybindings, (value2) => {
+        return (factory, customOptions) => target.custom((tui, theme, keybindings, done) => {
+          onKeybindings?.(keybindings);
+          return factory(tui, theme, keybindings, (value2) => {
             try {
               liveEditorText = target.getEditorText();
             } catch {
             }
             completed = true;
             done(value2);
-          }),
-          customOptions
-        );
+          });
+        }, customOptions);
       }
       const value = Reflect.get(target, property, target);
       return typeof value === "function" ? value.bind(target) : value;
@@ -2052,6 +2426,7 @@ var BtwTranscriptPager = class {
     this.theme = theme;
     this.onAction = onAction;
     this.options = options;
+    this.shortcuts = getBtwShortcuts(tui, options.thinking?.keybindings);
     this.transcriptComponents = buildTranscriptComponents(turns, this.theme);
     this.canBringToMain = turns.some((turn) => turn.kind === "answered");
     this.thinkingLevel = options.thinking?.level;
@@ -2095,6 +2470,8 @@ var BtwTranscriptPager = class {
   theme;
   onAction;
   options;
+  shortcuts;
+  pasteGuard = new BtwPasteGuard();
   transcriptComponents;
   editor;
   canBringToMain;
@@ -2116,6 +2493,7 @@ var BtwTranscriptPager = class {
     return this.layoutRoot;
   }
   render(width) {
+    if (width <= 0) return [];
     const safeWidth = Math.max(1, width);
     const editorLines = this.editor.render(safeWidth);
     const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
@@ -2136,22 +2514,27 @@ var BtwTranscriptPager = class {
       this.renderFooter(safeWidth),
       editorLines,
       availableRows
-    );
+    ).map((line) => truncateToWidth3(line, safeWidth));
   }
   handleInput(data) {
     if (this.finished) return;
-    if (matchesKey4(data, Key4.ctrl("c"))) {
+    if (this.pasteGuard.consume(data)) {
+      this.editor.handleInput(data);
+      this.tui.requestRender();
+      return;
+    }
+    if (this.shortcuts.matches(data, "exit")) {
       this.finished = true;
       this.onAction({ kind: "close" });
       return;
     }
-    if (this.canBringToMain && matchesKey4(data, Key4.ctrl("r"))) {
+    if (this.canBringToMain && this.shortcuts.matches(data, "bringToMain")) {
       this.finished = true;
       this.onAction({ kind: "bringToMain", questionDraft: this.editor.getExpandedText() });
       return;
     }
     const thinking = this.options.thinking;
-    if (thinking && thinking.levels.length > 1 && thinking.keybindings.matches(data, "app.thinking.cycle")) {
+    if (thinking && thinking.levels.length > 1 && this.shortcuts.matches(data, "cycleThinkingLevel")) {
       const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
       const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
       if (nextLevel) {
@@ -2184,23 +2567,26 @@ var BtwTranscriptPager = class {
     this.onAction({ kind: "close" });
   }
   renderFooter(width) {
+    const exit = this.shortcuts.label("exit");
+    const bring = this.canBringToMain && this.shortcuts.keys.bringToMain.length > 0;
+    const bringKey = this.shortcuts.label("bringToMain");
     if (this.warning) {
-      const warning = width < 32 ? "Empty \u2022 Ctrl+C" : `${this.warning} \u2022 Ctrl+C exit`;
+      const warning = width < 32 ? `Empty \u2022 ${exit}` : `${this.warning} \u2022 ${exit} exit`;
       return truncateToWidth3(this.theme.fg("warning", warning), width);
     }
     const scrollable = this.getMaxScrollOffset() > 0;
     const thinking = this.options.thinking;
-    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${thinkingKeyLabel(thinking.keybindings)} cycle` : "";
-    const base = this.canBringToMain ? "btw \u2022 Enter send \u2022 Ctrl+R bring to main \u2022 Ctrl+C exit" : "btw \u2022 Enter send \u2022 Ctrl+C exit";
+    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel && this.shortcuts.keys.cycleThinkingLevel.length ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${this.shortcuts.label("cycleThinkingLevel")} cycle` : "";
+    const base = bring ? `btw \u2022 Enter send \u2022 ${bringKey} bring to main \u2022 ${exit} exit` : `btw \u2022 Enter send \u2022 ${exit} exit`;
     const fullBase = `${base}${cycleHint}`;
-    const fallbackBase = "btw \u2022 Enter \u2022 Ctrl+C";
-    const compactBase = this.canBringToMain ? "btw \u2022 Enter \u2022 Ctrl+R \u2022 Ctrl+C" : fallbackBase;
+    const fallbackBase = `btw \u2022 Enter \u2022 ${exit}`;
+    const compactBase = bring ? `btw \u2022 Enter \u2022 ${bringKey} \u2022 ${exit}` : fallbackBase;
     const compactWithThinking = `${compactBase}${cycleHint}`;
     let hints = visibleWidth2(fullBase) <= width ? fullBase : visibleWidth2(compactWithThinking) <= width ? compactWithThinking : visibleWidth2(compactBase) <= width ? compactBase : fallbackBase;
     if (scrollable) {
       const history = ` \u2022 ${this.scrollView.scrollTop > 0 ? "\u2191 older" : "\u2193 newer"} \u2022 PgUp/PgDn history`;
       const compactHistory = " \u2022 PgUp/PgDn";
-      const compactScrollable = this.canBringToMain ? "Enter \u2022 Ctrl+R \u2022 Ctrl+C \u2022 PgUp/PgDn" : `${fallbackBase}${compactHistory}`;
+      const compactScrollable = bring ? `Enter \u2022 ${bringKey} \u2022 ${exit} \u2022 PgUp/PgDn` : `${fallbackBase}${compactHistory}`;
       if (visibleWidth2(`${hints}${history}`) <= width) {
         hints += history;
       } else if (visibleWidth2(`${compactBase}${history}`) <= width) {
@@ -2251,6 +2637,7 @@ var BtwAnsweringView = class {
     this.theme = theme;
     this.onCancel = onCancel;
     this.options = options;
+    this.shortcuts = getBtwShortcuts(tui, options.steering?.thinking?.keybindings);
     this.transcriptComponents = buildTranscriptComponents(turns, this.theme, pendingQuestion);
     this.thinkingLevel = options.steering?.thinking?.level ?? thinkingLevel;
     this.loader = new Loader(
@@ -2304,6 +2691,8 @@ var BtwAnsweringView = class {
   theme;
   onCancel;
   options;
+  shortcuts;
+  pasteGuard = new BtwPasteGuard();
   transcriptComponents;
   loader;
   editor;
@@ -2329,6 +2718,7 @@ var BtwAnsweringView = class {
     return this.layoutRoot;
   }
   render(width) {
+    if (width <= 0) return [];
     const safeWidth = Math.max(1, width);
     const availableRows = Math.max(1, this.tui.terminal.rows - RESERVED_APP_LINES);
     const editorLines = this.editor?.render(safeWidth) ?? [];
@@ -2360,11 +2750,16 @@ var BtwAnsweringView = class {
       editorLines,
       availableRows,
       steeringLines
-    );
+    ).map((line) => truncateToWidth3(line, safeWidth));
   }
   handleInput(data) {
     if (this.finished) return;
-    if (matchesKey4(data, Key4.ctrl("c"))) {
+    if (this.pasteGuard.consume(data)) {
+      this.editor?.handleInput(data);
+      this.tui.requestRender();
+      return;
+    }
+    if (this.shortcuts.matches(data, "exit")) {
       this.finished = true;
       this.loader.stop();
       this.controller.abort();
@@ -2372,7 +2767,7 @@ var BtwAnsweringView = class {
       return;
     }
     const thinking = this.options.steering?.thinking;
-    if (thinking && thinking.levels.length > 1 && thinking.keybindings.matches(data, "app.thinking.cycle")) {
+    if (thinking && thinking.levels.length > 1 && this.shortcuts.matches(data, "cycleThinkingLevel")) {
       const currentIndex = thinking.levels.indexOf(this.thinkingLevel ?? thinking.level);
       const nextLevel = thinking.levels[(currentIndex + 1) % thinking.levels.length];
       if (nextLevel) {
@@ -2415,16 +2810,17 @@ var BtwAnsweringView = class {
     this.onCancel();
   }
   renderFooter(width) {
+    const exit = this.shortcuts.label("exit");
     if (this.warning) {
-      const warning = width < 32 ? "Empty \u2022 Ctrl+C" : `${this.warning} \u2022 Ctrl+C cancel`;
+      const warning = width < 32 ? `Empty \u2022 ${exit}` : `${this.warning} \u2022 ${exit} cancel`;
       return truncateToWidth3(this.theme.fg("warning", warning), width);
     }
-    const baseHint = this.editor ? "Enter steer \u2022 Ctrl+C cancel" : "Ctrl+C cancel";
+    const baseHint = this.editor ? `Enter steer \u2022 ${exit} cancel` : `${exit} cancel`;
     const thinking = this.options.steering?.thinking;
-    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${thinkingKeyLabel(thinking.keybindings)} cycle` : "";
+    const cycleHint = thinking && thinking.levels.length > 1 && this.thinkingLevel && this.shortcuts.keys.cycleThinkingLevel.length ? ` \u2022 thinking ${this.thinkingLevel} \u2022 ${this.shortcuts.label("cycleThinkingLevel")} cycle` : "";
     const scrollHint = this.getMaxScrollOffset() > 0 ? " \u2022 PgUp/PgDn history" : "";
     const hints = `${baseHint}${cycleHint}${scrollHint}`;
-    const compactHints = this.editor ? "Enter \u2022 Ctrl+C" : "Ctrl+C";
+    const compactHints = this.editor ? `Enter \u2022 ${exit}` : exit;
     const selectedHints = visibleWidth2(hints) <= width ? hints : compactHints;
     const loaderWidth = Math.max(1, width - visibleWidth2(selectedHints) - 3);
     const loaderLine = this.loader.render(loaderWidth).at(-1) ?? "Answering\u2026";
@@ -2512,9 +2908,6 @@ function renderSideThreadHeader(width, theme, thinkingLevel) {
   const ruleWidth = Math.max(0, width - visibleWidth2(title));
   return theme.fg("muted", `${title}${"\u2500".repeat(ruleWidth)}`);
 }
-function thinkingKeyLabel(keybindings) {
-  return formatKeyLabel2(String(keybindings.getKeys("app.thinking.cycle")[0] ?? "shift+tab")) || "Shift+Tab";
-}
 function fitComposerLayout(header, contentLines, footer, editorLines, availableRows, statusLines = []) {
   const lines = [header, ...contentLines, ...statusLines, footer, ...editorLines];
   if (lines.length <= availableRows) return lines;
@@ -2748,7 +3141,10 @@ function btw(pi, dependencies = {}) {
               ctx: fullscreenCtx
             });
           },
-          { copyOnSelect: effectiveFullscreenCopyOnSelect(settings) }
+          {
+            copyOnSelect: effectiveFullscreenCopyOnSelect(settings),
+            ...settings.keybindings ? { keybindings: settings.keybindings } : {}
+          }
         );
       } finally {
         if (state?.title && state.thread.turns.length > 0) {