@iowarp/clio-coder 0.4.5 → 0.4.7

package/dist/{chunk-7TKWWPD7.js → chunk-U3TPUXOQ.js}

@@ -1,43 +1,33 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  combineBashOutput
-} from "./chunk-5A6XR3RJ.js";
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/engine/tui.ts
-init_esm_shims();
 import {
   Box,
-  CombinedAutocompleteProvider,
-  Container,
   Editor,
-  fuzzyFilter,
-  getKeybindings,
   Input,
-  isKeyRelease,
   KeybindingsManager,
-  Markdown,
-  Marked,
-  matchesKey,
   ProcessTerminal,
-  ScrollView,
+  SelectList,
+  TUI_KEYBINDINGS,
+  TuiAltScreen,
+  TuiMainScreen,
+  decodePrintableKey,
+  getKeybindings,
   setKeybindings,
   stripTerminalSequences,
-  Text,
-  TUI_KEYBINDINGS,
-  TuiAltScreen as TuiAltScreen2,
-  TuiMainScreen as TuiMainScreen2,
   truncateToWidth,
-  VStack,
-  visibleWidth,
-  wrapTextWithAnsi
-} from "@earendil-works/pi-tui";
+  visibleWidth
+} from "./chunk-V4ZKOKRB.js";
+import {
+  combineBashOutput
+} from "./chunk-5A6XR3RJ.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/engine/tui.ts
+init_esm_shims();
 
 // src/engine/instrumented-tui.ts
 init_esm_shims();
-import { TuiAltScreen, TuiMainScreen } from "@earendil-works/pi-tui";
 var DeferredRenderAdmission = class {
   constructor(admission, render) {
     this.admission = admission;
@@ -178,13 +168,10 @@ var InstrumentedTuiAltScreen = class extends TuiAltScreen {
 
 // src/engine/select-list.ts
 init_esm_shims();
-import {
-  SelectList as EngineSelectList
-} from "@earendil-works/pi-tui";
 var PI_SELECT_CURSOR = "\u2192";
 var ESC = String.fromCharCode(27);
 var LEADING_CURSOR_PATTERN = new RegExp(`^((?:${ESC}\\[[0-9;]*m)*)${PI_SELECT_CURSOR} `);
-var SelectList = class extends EngineSelectList {
+var SelectList2 = class extends SelectList {
   designCursor;
   constructor(items, maxVisible, theme, layout) {
     super(items, maxVisible, theme, layout);
@@ -289,6 +276,40 @@ function spinnerFrame(tick) {
   return SPINNER_FRAMES[index] ?? SPINNER_FRAMES[0];
 }
 
+// src/interactive/theme/segments.ts
+init_esm_shims();
+function present(parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0);
+}
+function brandMark(theme) {
+  const prompt = GLYPH.brand.slice(0, 1);
+  const initial = GLYPH.brand.slice(1, 2);
+  const cursor = GLYPH.brand.slice(2, 3);
+  return `${theme.fg("dim", prompt)}${theme.style("accent", initial, { bold: true })}${theme.fg("dim", cursor)}`;
+}
+function dotSep(theme) {
+  return theme.fg("dim", " \xB7 ");
+}
+function barSep(theme) {
+  return theme.fg("frame", " \u2502 ");
+}
+function sectionTag(theme, token, label, pad = 0) {
+  const text = pad > 0 ? label.padEnd(pad) : label;
+  return theme.style(token, text, { bold: true });
+}
+function screenTitle(theme, label) {
+  return theme.style("title", label, { bold: true });
+}
+function listGroupHeader(theme, label) {
+  return theme.fg("dim", `\u2500\u2500 ${label}`);
+}
+function joinChips(theme, parts) {
+  return present(parts).join(dotSep(theme));
+}
+function joinSections(theme, parts) {
+  return present(parts).join(barSep(theme));
+}
+
 // src/interactive/theme/index.ts
 init_esm_shims();
 
@@ -379,42 +400,6 @@ function paintHex(text, hex, options = {}) {
 
 // src/interactive/theme/components.ts
 init_esm_shims();
-
-// src/interactive/theme/segments.ts
-init_esm_shims();
-function present(parts) {
-  return parts.filter((part) => typeof part === "string" && part.length > 0);
-}
-function brandMark(theme) {
-  const prompt = GLYPH.brand.slice(0, 1);
-  const initial = GLYPH.brand.slice(1, 2);
-  const cursor = GLYPH.brand.slice(2, 3);
-  return `${theme.fg("dim", prompt)}${theme.style("accent", initial, { bold: true })}${theme.fg("dim", cursor)}`;
-}
-function dotSep(theme) {
-  return theme.fg("dim", " \xB7 ");
-}
-function barSep(theme) {
-  return theme.fg("frame", " \u2502 ");
-}
-function sectionTag(theme, token, label, pad = 0) {
-  const text = pad > 0 ? label.padEnd(pad) : label;
-  return theme.style(token, text, { bold: true });
-}
-function screenTitle(theme, label) {
-  return theme.style("title", label, { bold: true });
-}
-function listGroupHeader(theme, label) {
-  return theme.fg("dim", `\u2500\u2500 ${label}`);
-}
-function joinChips(theme, parts) {
-  return present(parts).join(dotSep(theme));
-}
-function joinSections(theme, parts) {
-  return present(parts).join(barSep(theme));
-}
-
-// src/interactive/theme/components.ts
 var identity = (text) => text;
 function markdownTheme(theme, highlightCode) {
   return {
@@ -621,6 +606,27 @@ function bashExecutionEntryInput(args) {
 // src/interactive/overlay-frame.ts
 init_esm_shims();
 
+// src/interactive/keyboard-owner.ts
+init_esm_shims();
+function keyboardOwner(component) {
+  if (component instanceof Editor || component instanceof Input) {
+    return {
+      keyboardScope: "edit",
+      undoInput: () => {
+        component.applyEdit("undo");
+        return true;
+      }
+    };
+  }
+  return component ?? {};
+}
+function focusedComponent(tui) {
+  return tui instanceof TuiAltScreen || tui instanceof TuiMainScreen ? tui.getFocusedComponent() : null;
+}
+function localKey(data) {
+  return data.includes("\x1B[200~") ? data : decodePrintableKey(data) ?? data;
+}
+
 // src/interactive/modal-marker.ts
 init_esm_shims();
 var MODAL_MARKER_BASE_TITLE = "clio";
@@ -696,6 +702,12 @@ var FocusBox = class extends Box {
     this.inputTarget = options?.inputTarget === void 0 ? childList[0] ?? null : options.inputTarget;
     this.onInput = options?.onInput;
   }
+  get keyboardScope() {
+    return keyboardOwner(this.inputTarget).keyboardScope;
+  }
+  undoInput() {
+    return keyboardOwner(this.inputTarget).undoInput?.() ?? false;
+  }
   handleInput(data) {
     if (this.onInput) {
       this.onInput(data);
@@ -901,6 +913,12 @@ var ClioOverlayFrame = class {
     this.cachedRender = { width, rowBudget: this.rowBudget, childLines, title: titleText, hint, tone, lines };
     return lines;
   }
+  get keyboardScope() {
+    return keyboardOwner(this.child).keyboardScope;
+  }
+  undoInput() {
+    return keyboardOwner(this.child).undoInput?.() ?? false;
+  }
   handleInput(data) {
     this.child.handleInput?.(data);
   }
@@ -965,9 +983,14 @@ function resolveRowSize(value, termHeight) {
 // src/interactive/permission-hint.ts
 init_esm_shims();
 var MUTATION_PREVIEW_KEY = "v";
-function permissionHintEntries(composerHasDraft = false, inspection = "none") {
+var PERMISSION_TERMS_KEY = "?";
+function permissionHintEntries(composerHasDraft = false, inspection = "none", terms) {
   return [
     composerHasDraft ? { key: "Backspace", verb: "clear the draft to allow", short: "clear draft", critical: true } : { key: "Enter", verb: "allow once", short: "allow", critical: true },
+    // The terms key is the card's own and the most droppable entry: the folded
+    // card already states what the keys do in one row. It sits before the
+    // inspect key so the narrowing drops it first.
+    ...terms === void 0 ? [] : [{ key: PERMISSION_TERMS_KEY, verb: terms === "open" ? "hide terms" : "terms", short: "terms", critical: false }],
     ...inspection === "none" ? [] : inspection === "open" ? [
       { key: "\u2191\u2193", verb: "scroll", critical: false },
       { key: MUTATION_PREVIEW_KEY, verb: "hide mutation", short: "hide", critical: false }
@@ -1026,7 +1049,7 @@ function composerMode(chrome, text) {
 function lowerRailHint(theme, chrome) {
   return theme.fg(
     "dim",
-    `${chrome.getSubmitKeyLabel?.() ?? "Enter"} send \xB7 ${chrome.getNewlineKeyLabel?.() ?? "Shift+Enter"} newline`
+    `${chrome.getSubmitKeyLabel?.() ?? "Enter"} send \xB7 ${chrome.getNewlineKeyLabel?.() ?? "Ctrl+J"} newline`
   );
 }
 function confirmRailHint(theme, width, hasDraft, inspection) {
@@ -1098,6 +1121,22 @@ var ClioEditor = class extends Editor {
   chrome;
   pastedBangOffsets = /* @__PURE__ */ new Set();
   bracketedPasteActive = false;
+  revision = 0;
+  pastedOperatorTokens = /* @__PURE__ */ new Set();
+  get draftRevision() {
+    return this.revision;
+  }
+  /** Restored queues and external buffers are literal editor content. */
+  setLiteralText(text) {
+    this.setText(text);
+    this.pastedBangOffsets = new Set([...text.matchAll(/!/gu)].map((match) => match.index));
+  }
+  applyEdit(operation) {
+    const before = this.getText();
+    super.applyEdit(operation);
+    this.revision += 1;
+    this.pastedBangOffsets = remapPastedBangOffsets(before, this.getText(), this.pastedBangOffsets, operation === "undo");
+  }
   render(width) {
     const lines = super.render(width);
     if (lines.length === 0) return lines;
@@ -1145,23 +1184,21 @@ var ClioEditor = class extends Editor {
    */
   getTextForSubmit() {
     const text = this.getExpandedText();
-    return startsWithPastedOperator(this.getText(), this.pastedBangOffsets) ? guardPastedEditorOperator(text) : text;
+    return this.startsWithLiteralOperator() ? guardPastedEditorOperator(text) : text;
   }
-  /**
-   * pi-tui's bracketed-paste handling inserts pasted text (including a
-   * trailing newline the paste carried) without submitting: a pasted
-   * `/model\n` lands as two lines in the buffer and just sits there. Once
-   * the base handler has applied a chunk that closed a paste, check whether
-   * the buffer now reads as a completed slash command and, if so, submit it
-   * through the same handler the typed-Enter path uses.
-   */
+  startsWithLiteralOperator() {
+    const visible = this.getText();
+    return startsWithPastedOperator(visible, this.pastedBangOffsets) || [...this.pastedOperatorTokens].some((token) => visible.trimStart().startsWith(token));
+  }
+  /** Paste is always literal; a later deliberate key submits it. */
   handleInput(data) {
+    this.revision += 1;
     const openedPaste = data.includes("\x1B[200~");
     const closedPaste = data.includes("\x1B[201~");
     const pasteMutation = this.bracketedPasteActive || openedPaste;
     const textBeforeInput = this.getText();
     const keybindings = getKeybindings();
-    if (startsWithPastedOperator(textBeforeInput, this.pastedBangOffsets) && keybindings.matches(data, "tui.input.submit")) {
+    if (this.startsWithLiteralOperator() && keybindings.matches(data, "tui.input.submit")) {
       const pastedText = this.getTextForSubmit();
       this.pastedBangOffsets.clear();
       this.bracketedPasteActive = false;
@@ -1184,15 +1221,22 @@ var ClioEditor = class extends Editor {
     );
     if (openedPaste) this.bracketedPasteActive = true;
     if (closedPaste) this.bracketedPasteActive = false;
-    if (!closedPaste) return;
-    const text = this.getText();
-    if (!text.endsWith("\n")) return;
-    const command = text.trimEnd();
-    if (!command.startsWith("/")) return;
-    this.setText("");
-    this.onSubmit?.(command);
+    if (pasteMutation && textAfterInput !== this.getExpandedText()) {
+      let start = 0;
+      while (start < textBeforeInput.length && start < textAfterInput.length && textBeforeInput[start] === textAfterInput[start])
+        start++;
+      let oldEnd = textBeforeInput.length, end = textAfterInput.length;
+      while (oldEnd > start && end > start && textBeforeInput[oldEnd - 1] === textAfterInput[end - 1]) {
+        oldEnd--;
+        end--;
+      }
+      const token = textAfterInput.slice(start, end).trimStart();
+      if (token && !token.startsWith("!")) this.pastedOperatorTokens.add(token);
+    }
   }
   setText(text) {
+    this.revision += 1;
+    this.pastedOperatorTokens.clear();
     this.pastedBangOffsets.clear();
     this.bracketedPasteActive = false;
     super.setText(text);
@@ -1969,125 +2013,177 @@ init_esm_shims();
 // src/domains/config/keybindings.ts
 init_esm_shims();
 var CLIO_APP_KEYBINDINGS = {
-  "clio-coder.thinking.cycle": {
-    defaultKeys: "shift+tab",
-    description: "Cycle orchestrator thinking level"
+  "clio-coder.library.toggle": {
+    defaultKeys: "alt+l",
+    description: "Library",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "l"
   },
-  "clio-coder.exit": {
-    defaultKeys: "ctrl+d",
-    description: "Exit when the editor is empty"
+  "clio-coder.model.select": {
+    defaultKeys: "alt+m",
+    description: "Model picker",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "m"
+  },
+  "clio-coder.output.cycle": {
+    defaultKeys: "alt+o",
+    description: "Output style",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false,
+    leader: "o"
   },
   "clio-coder.status.toggle": {
     defaultKeys: "alt+u",
-    description: "Toggle the footer dashboard (compact / expanded)"
-  },
-  "clio-coder.session.tree": {
-    defaultKeys: "alt+t",
-    description: "Open the /tree navigator"
+    description: "Dashboard",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "u"
   },
   "clio-coder.dispatchBoard.toggle": {
     defaultKeys: "alt+w",
-    description: "Toggle the dispatch (workers) board overlay"
+    description: "Workers",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "w"
   },
   "clio-coder.files.toggle": {
-    // Alt+F is a pi-tui editor reserve (word-forward), so the files pane
-    // takes the next letter that reads as "explorer" and stays inside the
-    // Alt+<letter> scheme, which also earns it the Ctrl+G leader fallback.
     defaultKeys: "alt+e",
-    description: "Toggle the files pane beside the session (a --with-panes session inside herdr)"
-  },
-  "clio-coder.tasks.open": {
-    // Approved application-boundary override of pi-tui editor word-back.
-    defaultKeys: "alt+b",
-    description: "Open the composite session and operator task board"
-  },
-  "clio-coder.decisions.open": {
-    // Approved application-boundary override of pi-tui editor word-delete.
-    defaultKeys: "alt+d",
-    description: "Open the settled interview decision board"
+    description: "Files (from Clio focus)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "e"
   },
-  "clio-coder.dispatch.background": {
-    // Ctrl+B alone is pi-tui's editor cursor-left, so the Claude Code chord
-    // cannot be the primary here. Alt+S ("send to background") keeps the app
-    // scheme and earns the Ctrl+G leader fallback, which only alt+<letter>
-    // bindings get; Ctrl+Alt+B stays for the b-for-background muscle memory.
-    defaultKeys: ["alt+s", "ctrl+alt+b"],
-    description: "Send the running attached dispatch to the background as a detached batch"
+  "clio-coder.thinking.cycle": {
+    defaultKeys: "shift+tab",
+    description: "Thinking effort",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false,
+    leader: "t"
   },
-  "clio-coder.model.select": {
-    defaultKeys: "alt+l",
-    description: "Open the model + targets selector"
+  "clio-coder.message.followUp": {
+    defaultKeys: "ctrl+q",
+    description: "Send after the active run",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "f"
   },
-  "clio-coder.model.cycleForward": {
-    defaultKeys: "alt+j",
-    description: "Cycle to next scoped model"
+  "clio-coder.message.dequeue": {
+    defaultKeys: "alt+q",
+    description: "Restore queued messages",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "q"
   },
-  "clio-coder.model.cycleBackward": {
-    defaultKeys: "alt+k",
-    description: "Cycle to previous scoped model"
+  "clio-coder.exit": {
+    defaultKeys: "ctrl+d",
+    description: "Exit empty idle composer with no queued messages",
+    scope: "composer",
+    kind: "exit",
+    repeat: false
   },
-  "clio-coder.tool.expand": {
-    defaultKeys: "alt+o",
-    description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block"
+  "clio-coder.leader": {
+    defaultKeys: "ctrl+g",
+    description: "Open contextual action menu",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
   },
-  "clio-coder.tool.expandAll": {
-    // Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
-    // Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
-    defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
-    description: "Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides"
+  "clio-coder.tasks.open": {
+    defaultKeys: [],
+    description: "Tasks (/tasks)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
   },
-  "clio-coder.tool.liveOutput": {
-    defaultKeys: "alt+p",
-    description: "Toggle streaming partial tool output in expanded tool bodies"
+  "clio-coder.decisions.open": {
+    defaultKeys: [],
+    description: "Decisions (/decisions)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
   },
-  "clio-coder.thinking.expand": {
-    defaultKeys: "alt+r",
-    description: "Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)"
+  "clio-coder.session.tree": {
+    defaultKeys: [],
+    description: "Session tree (/tree)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
   },
-  "clio-coder.thinking.expandAll": {
-    // Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
-    // Alt+Shift+R as a distinct key event.
-    defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
-    description: "Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides"
+  "clio-coder.model.cycleForward": {
+    defaultKeys: [],
+    description: "Next scoped model",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false
   },
-  "clio-coder.editor.external": {
-    defaultKeys: "alt+g",
-    description: "Open the current input in an external editor"
+  "clio-coder.model.cycleBackward": {
+    defaultKeys: [],
+    description: "Previous scoped model",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false
   },
-  "clio-coder.message.followUp": {
-    defaultKeys: "alt+enter",
-    description: "End of turn: queue the current input for delivery when the active run settles (Enter delivers it at the next slot, between tool batches)"
+  "clio-coder.dispatch.background": {
+    defaultKeys: [],
+    description: "Background attached dispatch",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "s"
   },
   "clio-coder.message.interrupt": {
-    // Alt+I keeps the app scheme and earns the Ctrl+G leader fallback. A
-    // Ctrl+Enter chord was rejected because legacy terminals send it as a
-    // plain Enter, which would turn every send into a cancel.
-    defaultKeys: "alt+i",
-    description: "Interrupt: cancel the active run and deliver the current input now (refused while an attached dispatch runs or a permission ask is parked; the input then queues for the next slot)"
+    defaultKeys: [],
+    description: "Interrupt with draft",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "i"
   },
-  "clio-coder.message.dequeue": {
-    defaultKeys: "alt+up",
-    description: "Restore queued steering and follow-up messages to the editor"
+  "clio-coder.editor.external": {
+    defaultKeys: [],
+    description: "Edit expanded draft externally",
+    scope: "composer",
+    kind: "edit",
+    repeat: false,
+    leader: "g"
   },
   "clio-coder.notifications.dismiss": {
-    defaultKeys: "alt+x",
-    description: "Dismiss footer notifications"
-  },
-  "clio-coder.leader": {
-    defaultKeys: "ctrl+g",
-    description: "Start portable leader-key fallback for Alt shortcuts"
+    defaultKeys: [],
+    description: "Dismiss oldest notification",
+    scope: "composer",
+    kind: "dismiss",
+    repeat: false,
+    leader: "x"
   }
 };
 var CLIO_KEYBINDINGS = {
   ...TUI_KEYBINDINGS,
-  "tui.editor.historyPrevious": {
-    ...TUI_KEYBINDINGS["tui.editor.historyPrevious"],
-    defaultKeys: "ctrl+p"
-  },
-  "tui.editor.historyNext": {
-    ...TUI_KEYBINDINGS["tui.editor.historyNext"],
-    defaultKeys: "ctrl+n"
+  "tui.editor.historyPrevious": { ...TUI_KEYBINDINGS["tui.editor.historyPrevious"], defaultKeys: "ctrl+p" },
+  "tui.editor.historyNext": { ...TUI_KEYBINDINGS["tui.editor.historyNext"], defaultKeys: "ctrl+n" },
+  "tui.editor.deleteWordBackward": {
+    ...TUI_KEYBINDINGS["tui.editor.deleteWordBackward"],
+    defaultKeys: ["ctrl+w", "alt+backspace", "ctrl+backspace"]
   },
+  "tui.editor.undo": { ...TUI_KEYBINDINGS["tui.editor.undo"], defaultKeys: "ctrl+_" },
+  "tui.input.newLine": { ...TUI_KEYBINDINGS["tui.input.newLine"], defaultKeys: ["ctrl+j", "shift+enter"] },
+  "tui.altScreen.top": { ...TUI_KEYBINDINGS["tui.altScreen.top"], defaultKeys: [] },
+  "tui.altScreen.bottom": { ...TUI_KEYBINDINGS["tui.altScreen.bottom"], defaultKeys: [] },
+  "tui.altScreen.previousPrompt": { ...TUI_KEYBINDINGS["tui.altScreen.previousPrompt"], defaultKeys: "ctrl+up" },
+  "tui.altScreen.nextPrompt": { ...TUI_KEYBINDINGS["tui.altScreen.nextPrompt"], defaultKeys: "ctrl+down" },
+  "tui.altScreen.search": { ...TUI_KEYBINDINGS["tui.altScreen.search"], defaultKeys: "ctrl+r" },
+  "tui.altScreen.searchNext": { ...TUI_KEYBINDINGS["tui.altScreen.searchNext"], defaultKeys: "enter" },
+  "tui.altScreen.searchPrevious": { ...TUI_KEYBINDINGS["tui.altScreen.searchPrevious"], defaultKeys: "up" },
   ...CLIO_APP_KEYBINDINGS
 };
 var CLIO_APP_KEYBINDING_IDS = Object.keys(CLIO_APP_KEYBINDINGS);
@@ -2159,6 +2255,14 @@ var BASE_SYMBOL_KEYS = /* @__PURE__ */ new Set([
   "?"
 ]);
 var MODIFIERS = /* @__PURE__ */ new Set(["ctrl", "shift", "alt", "super"]);
+function canonicalKey(key) {
+  const parts = key.toLowerCase().split("+");
+  let base = parts.pop() ?? "";
+  if (base === "esc") base = "escape";
+  if (base === "return") base = "enter";
+  const modifiers = ["ctrl", "alt", "shift", "super"].filter((mod) => parts.includes(mod));
+  return [...modifiers, base].join("+");
+}
 function isValidKeyId(keyId) {
   if (typeof keyId !== "string" || keyId.length === 0) return false;
   const parts = keyId.toLowerCase().split("+");
@@ -2184,10 +2288,13 @@ function validateKeybindings(raw) {
   const valid = {};
   const invalid = [];
   for (const [id, value] of Object.entries(raw)) {
+    if (!Object.hasOwn(CLIO_KEYBINDINGS, id)) {
+      invalid.push({ id, keys: ["unknown action ID; use /help"] });
+      continue;
+    }
     if (typeof value === "string") {
-      if (value.length === 0) continue;
       if (isValidKeyId(value)) {
-        valid[id] = value;
+        valid[id] = canonicalKey(value);
       } else {
         invalid.push({ id, keys: [value] });
       }
@@ -2197,14 +2304,17 @@ function validateKeybindings(raw) {
       const accepted = [];
       const rejected = [];
       for (const entry of value) {
-        if (typeof entry !== "string" || entry.length === 0) continue;
+        if (typeof entry !== "string") {
+          rejected.push(String(entry));
+          continue;
+        }
         if (isValidKeyId(entry)) {
-          accepted.push(entry);
+          accepted.push(canonicalKey(entry));
         } else {
           rejected.push(entry);
         }
       }
-      if (accepted.length > 0) valid[id] = accepted;
+      if (accepted.length > 0 || value.length === 0) valid[id] = accepted;
       if (rejected.length > 0) invalid.push({ id, keys: rejected });
     }
   }
@@ -2304,8 +2414,10 @@ function keyUsesAltLetter(keyId) {
 }
 function terminalReservedReason(keyId) {
   const key = normalizeKeyForRisk(keyId);
-  if (key === "ctrl+s" || key === "ctrl+q") return "terminal flow control may intercept this chord";
-  if (key === "ctrl+z") return "shell job control may suspend the process";
+  if (key === "ctrl+s")
+    return "an intermediary may intercept this chord; Node raw mode normally disables terminal flow control";
+  if (key === "ctrl+z")
+    return "an intermediary may intercept this chord; Node raw mode normally disables signal generation";
   return null;
 }
 function keyRiskReason(keyId, support) {
@@ -2315,7 +2427,7 @@ function keyRiskReason(keyId, support) {
   if (support.ideReservedKeys?.map(normalizeKeyForRisk).includes(key)) return `${support.name} may reserve this chord`;
   return terminalReservedReason(key);
 }
-var MACOS_OPTION_DEFAULT_WARNING_ID = "clio.macos.option-letter.defaults";
+var MACOS_OPTION_DEFAULT_WARNING_ID = "clio-coder.macos.option-letter.defaults";
 function detectPlatformKeybindingWarnings(userBindings, support = detectTerminalKeySupport()) {
   const warnings = [];
   const macosDefaultAltKeys = [];
@@ -2366,94 +2478,124 @@ function joinKeys(keys) {
   if (keys.length === 1) return String(keys[0]);
   return keys.join(" / ");
 }
-function deriveLeaderTargets(inner) {
-  const targets = [];
-  for (const id of CLIO_APP_KEYBINDING_IDS) {
+var VIEWPORT_LEADER_TARGETS = [
+  { key: "z", id: "tui.editor.undo" },
+  { key: "r", id: "tui.altScreen.search" },
+  { key: "p", id: "tui.altScreen.pageUp" },
+  { key: "n", id: "tui.altScreen.pageDown" },
+  { key: "home", id: "tui.altScreen.top" },
+  { key: "end", id: "tui.altScreen.bottom" },
+  { key: "", id: "tui.altScreen.previousPrompt" },
+  { key: "", id: "tui.altScreen.nextPrompt" }
+];
+function keybindingScope(id) {
+  if (id.startsWith("clio-coder.")) return "composer";
+  if (id.startsWith("tui.select.")) return "selection";
+  if (/tui.altScreen.search(Next|Previous|Close)/u.test(id)) return "search";
+  if (id.startsWith("tui.altScreen.")) return "fullscreen composer";
+  return "editable field";
+}
+function legacyKey(key) {
+  const canonical = canonicalKey(key);
+  return { "ctrl+i": "tab", "ctrl+m": "enter", "ctrl+[": "escape", "ctrl+_": "ctrl+-" }[canonical] ?? canonical;
+}
+function scopesOverlap(a, b) {
+  const left = keybindingScope(a), right = keybindingScope(b);
+  if (left === "selection" || right === "selection") return left === right;
+  if (left === "search" || right === "search") return left === right;
+  if (a === "clio-coder.exit" && b === "tui.editor.deleteCharForward" || b === "clio-coder.exit" && a === "tui.editor.deleteCharForward")
+    return false;
+  return true;
+}
+function effectiveConflicts(inner) {
+  const keys = /* @__PURE__ */ new Map();
+  for (const id of Object.keys(CLIO_KEYBINDINGS)) {
     for (const key of inner.getKeys(id)) {
-      const base = altLetterBase(String(key));
-      if (base) targets.push({ key: base, id });
+      const canonical = legacyKey(key);
+      const ids = keys.get(canonical) ?? [];
+      if (!ids.includes(id)) ids.push(id);
+      keys.set(canonical, ids);
     }
   }
-  return targets;
-}
-function buildManager(inner, invalid, platformWarnings) {
-  const frozen = invalid.map((entry) => ({ id: entry.id, keys: [...entry.keys] }));
-  const frozenPlatformWarnings = platformWarnings.map((entry) => ({
-    id: entry.id,
-    keys: [...entry.keys],
-    terminal: entry.terminal,
-    reason: entry.reason,
-    source: entry.source
+  return [...keys].filter(
+    ([, ids]) => ids.length > 1 && ids.some((id, index) => ids.slice(index + 1).some((other) => scopesOverlap(id, other)))
+  ).map(([key, keybindings]) => ({
+    key,
+    keybindings: keybindings.filter((id) => keybindings.some((other) => other !== id && scopesOverlap(id, other)))
   }));
-  const frozenLeaderTargets = deriveLeaderTargets(inner).map((entry) => ({ ...entry }));
+}
+function buildManager(overrides, env, install) {
+  let validated = validateKeybindings(overrides);
+  const inner = new KeybindingsManager(CLIO_KEYBINDINGS, validated.valid);
+  if (install) setKeybindings(inner);
+  let generation = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const isDisabled = (id) => {
+    const value = inner.getUserBindings()[id];
+    return Array.isArray(value) && value.length === 0;
+  };
+  const leaderTargets = () => {
+    if (inner.getKeys("clio-coder.leader").length === 0) return [];
+    const app = CLIO_APP_KEYBINDING_IDS.flatMap((id) => {
+      const descriptor = CLIO_APP_KEYBINDINGS[id];
+      return "leader" in descriptor ? [{ key: descriptor.leader, id }] : [];
+    });
+    return [...app, ...VIEWPORT_LEADER_TARGETS].filter(({ id }) => !isDisabled(id));
+  };
+  const actionLabel = (id) => {
+    const keys = inner.getKeys(id);
+    const suffix = leaderTargets().find((entry) => entry.id === id)?.key;
+    return [keys.join(" / "), suffix ? `${inner.getKeys("clio-coder.leader")[0]} ${suffix}` : ""].filter(Boolean).join(" \xB7 ") || "unbound; see /help";
+  };
   return {
-    matches(data, id) {
-      return inner.matches(data, id);
-    },
-    getKeys(id) {
-      return inner.getKeys(id);
-    },
-    getDescription(id) {
-      return inner.getDefinition(id).description ?? "";
-    },
-    getConflicts() {
-      return inner.getConflicts();
-    },
-    overrideCount() {
-      return Object.keys(inner.getUserBindings()).length;
-    },
-    invalidCount() {
-      return frozen.reduce((sum, entry) => sum + entry.keys.length, 0);
+    matches: (data, id) => inner.matches(data, id),
+    getKeys: (id) => inner.getKeys(id),
+    getDescription: (id) => inner.getDefinition(id).description ?? "",
+    getConflicts: () => effectiveConflicts(inner),
+    get generation() {
+      return generation;
     },
-    invalidBindings() {
-      return frozen;
-    },
-    platformWarnings() {
-      return frozenPlatformWarnings;
+    reload(next) {
+      validated = validateKeybindings(next);
+      inner.setUserBindings(validated.valid);
+      if (install) setKeybindings(inner);
+      generation += 1;
+      for (const listener of listeners) listener();
     },
-    leaderTargets() {
-      return frozenLeaderTargets;
+    onReload(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     },
-    hotkeyEntries() {
-      const userBindings = inner.getUserBindings();
-      return CLIO_APP_KEYBINDING_IDS.map((id) => ({
-        id,
-        keys: joinKeys(inner.getKeys(id)),
-        description: inner.getDefinition(id).description ?? "",
-        source: userBindings[id] === void 0 ? "default" : "user"
-      }));
-    }
+    isDisabled,
+    actionLabel,
+    overrideCount: () => Object.keys(validated.valid).length,
+    invalidCount: () => validated.invalid.reduce((sum, entry) => sum + entry.keys.length, 0),
+    invalidBindings: () => validated.invalid,
+    platformWarnings: () => detectPlatformKeybindingWarnings(validated.valid, detectTerminalKeySupport(env)),
+    leaderTargets,
+    hotkeyEntries: () => Object.keys(CLIO_KEYBINDINGS).map((id) => ({
+      id,
+      keys: joinKeys(inner.getKeys(id)),
+      description: `${inner.getDefinition(id).description ?? ""} (${keybindingScope(id)}${isDisabled(id) ? "; disabled by user" : ""})${id === "tui.input.copy" ? "; composer Ctrl+C cancels; use native terminal clipboard" : ""}`,
+      source: validated.valid[id] === void 0 ? "default" : "user"
+    }))
   };
 }
 function createKeybindingManager(settings, env = process.env) {
-  const { valid, invalid } = validateKeybindings(settings.interface.keybindings ?? {});
-  const inner = new KeybindingsManager(CLIO_KEYBINDINGS, valid);
-  setKeybindings(inner);
-  return buildManager(inner, invalid, detectPlatformKeybindingWarnings(valid, detectTerminalKeySupport(env)));
+  return buildManager(settings.interface.keybindings ?? {}, env, true);
 }
 
 export {
-  SelectList,
+  SelectList2 as SelectList,
   createAgentProgress,
-  CombinedAutocompleteProvider,
-  Container,
-  fuzzyFilter,
-  getKeybindings,
-  Input,
-  isKeyRelease,
-  Markdown,
-  Marked,
-  matchesKey,
-  ScrollView,
-  stripTerminalSequences,
-  Text,
-  truncateToWidth,
-  VStack,
-  visibleWidth,
-  wrapTextWithAnsi,
   unguardPastedEditorOperator,
   parseEditorBashCommand,
   bashExecutionEntryInput,
+  keyboardOwner,
+  focusedComponent,
+  localKey,
   SGR_RESET,
   SGR_DIM,
   fgSequence,
@@ -2471,6 +2613,7 @@ export {
   joinSections,
   markdownTheme,
   selectListTheme,
+  editorTheme,
   abbreviateModelId,
   formatTargetLabel,
   formatCompactMs,
@@ -2493,11 +2636,13 @@ export {
   diagnosticSeverityToken,
   showClioOverlayFrame,
   MUTATION_PREVIEW_KEY,
+  PERMISSION_TERMS_KEY,
   permissionHintEntries,
   ClioEditor,
   writeInputWedgeDump,
   getActiveRenderTrace,
   createProcessInteractiveShell,
+  CLIO_APP_KEYBINDING_IDS,
   validateKeybindings,
   formatInvalidKeybindingNotice,
   detectTerminalKeySupport,
@@ -2505,4 +2650,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-7TKWWPD7.js.map
+//# sourceMappingURL=chunk-U3TPUXOQ.js.map