@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-3O5JWP4L.js

@@ -0,0 +1,1670 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  Box,
+  Editor,
+  Input,
+  KeybindingsManager,
+  SelectList,
+  TUI_KEYBINDINGS,
+  TuiAltScreen,
+  TuiMainScreen,
+  decodePrintableKey,
+  setKeybindings,
+  stripTerminalSequences,
+  truncateToWidth,
+  visibleWidth
+} from "./chunk-6OWUM2NC.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-XNIZBOFV.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/engine/tui.ts
+init_esm_shims();
+
+// src/engine/instrumented-tui.ts
+init_esm_shims();
+var DeferredRenderAdmission = class {
+  constructor(admission, render) {
+    this.admission = admission;
+    this.render = render;
+  }
+  admission;
+  render;
+  pending = false;
+  force = false;
+  release = null;
+  request(force) {
+    if (!this.admission?.blocked) return false;
+    this.pending = true;
+    this.force ||= force;
+    this.release ??= this.admission.onWritable(() => {
+      this.release?.();
+      this.release = null;
+      if (!this.pending) return;
+      const pendingForce = this.force;
+      this.pending = false;
+      this.force = false;
+      this.render(pendingForce);
+    });
+    return true;
+  }
+  /** A direct/final render supersedes any older request held behind the gate. */
+  settled() {
+    this.pending = false;
+    this.force = false;
+    this.release?.();
+    this.release = null;
+  }
+};
+var InstrumentedTuiMainScreen = class extends TuiMainScreen {
+  constructor(terminal, renderObserver, showHardwareCursor, logDirectory, renderAdmission) {
+    super(terminal, showHardwareCursor, logDirectory);
+    this.renderObserver = renderObserver;
+    this.deferredAdmission = new DeferredRenderAdmission(renderAdmission, (force) => super.requestRender(force));
+  }
+  renderObserver;
+  requestRender(force = false) {
+    if (!this.deferredAdmission.request(force)) super.requestRender(force);
+  }
+  doRender() {
+    this.deferredAdmission.settled();
+    if (this.renderObserver.isEnabled?.() === false) {
+      super.doRender();
+      return;
+    }
+    const frame2 = this.renderObserver.beginFrame({
+      mode: this.mode,
+      columns: this.terminal.columns,
+      rows: this.terminal.rows
+    });
+    this.currentFrame = frame2;
+    try {
+      super.doRender();
+    } finally {
+      this.currentFrame = void 0;
+      this.renderObserver.endFrame(frame2);
+    }
+  }
+  compositeOverlays(lines, termWidth, termHeight) {
+    return this.measure("overlay", () => super.compositeOverlays(lines, termWidth, termHeight));
+  }
+  applyLineResets(lines) {
+    return this.measure("normalization", () => super.applyLineResets(lines));
+  }
+  extractCursorPosition(lines, height) {
+    return this.measure("cursor", () => super.extractCursorPosition(lines, height));
+  }
+  measure(phase, operation) {
+    if (this.renderObserver.isEnabled?.() === false) return operation();
+    const frame2 = this.currentFrame;
+    if (frame2 === void 0) return operation();
+    const phaseToken = this.renderObserver.beginPhase(frame2, phase);
+    try {
+      return operation();
+    } finally {
+      this.renderObserver.endPhase(frame2, phase, phaseToken);
+    }
+  }
+  currentFrame;
+  deferredAdmission;
+};
+var InstrumentedTuiAltScreen = class extends TuiAltScreen {
+  constructor(terminal, renderObserver, showHardwareCursor, logDirectory, options, renderAdmission) {
+    super(terminal, showHardwareCursor, logDirectory, options);
+    this.renderObserver = renderObserver;
+    this.capturesMouse = options?.mouse ?? true;
+    this.deferredAdmission = new DeferredRenderAdmission(renderAdmission, (force) => super.requestRender(force));
+  }
+  renderObserver;
+  terminalSelectionUsers = 0;
+  capturesMouse;
+  /** pi-tui selects transcript text, but capturing overlays consume its mouse path.
+   * Let the terminal select the stable interview screen until it closes. */
+  useTerminalSelection() {
+    if (!this.capturesMouse) return () => {
+    };
+    if (this.terminalSelectionUsers++ === 0) this.terminal.write("\x1B[?1006l\x1B[?1003l\x1B[?1002l\x1B[?1000l");
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      if (--this.terminalSelectionUsers !== 0) return;
+      const term = process.env.TERM?.toLowerCase() ?? "";
+      const multiplexed = process.env.TMUX !== void 0 || process.env.ZELLIJ !== void 0 || process.env.STY !== void 0 || term.startsWith("tmux") || term.startsWith("screen");
+      this.terminal.write(`\x1B[?1000h\x1B[?1002h${multiplexed ? "" : "\x1B[?1003h"}\x1B[?1006h`);
+    };
+  }
+  currentFrame;
+  requestRender(force = false) {
+    if (!this.deferredAdmission.request(force)) super.requestRender(force);
+  }
+  doRender() {
+    this.deferredAdmission.settled();
+    if (this.renderObserver.isEnabled?.() === false) {
+      super.doRender();
+      return;
+    }
+    const frame2 = this.renderObserver.beginFrame({
+      mode: this.mode,
+      columns: this.terminal.columns,
+      rows: this.terminal.rows
+    });
+    this.currentFrame = frame2;
+    try {
+      super.doRender();
+    } finally {
+      this.currentFrame = void 0;
+      this.renderObserver.endFrame(frame2);
+    }
+  }
+  compositeOverlays(lines, termWidth, termHeight) {
+    return this.measure("overlay", () => super.compositeOverlays(lines, termWidth, termHeight));
+  }
+  applyLineResets(lines) {
+    return this.measure("normalization", () => super.applyLineResets(lines));
+  }
+  extractCursorPosition(lines, height) {
+    return this.measure("cursor", () => super.extractCursorPosition(lines, height));
+  }
+  measure(phase, operation) {
+    if (this.renderObserver.isEnabled?.() === false) return operation();
+    const frame2 = this.currentFrame;
+    if (frame2 === void 0) return operation();
+    const phaseToken = this.renderObserver.beginPhase(frame2, phase);
+    try {
+      return operation();
+    } finally {
+      this.renderObserver.endPhase(frame2, phase, phaseToken);
+    }
+  }
+  deferredAdmission;
+};
+
+// src/engine/select-list.ts
+init_esm_shims();
+var PI_SELECT_CURSOR = "\u2192";
+var ESC = String.fromCharCode(27);
+var LEADING_CURSOR_PATTERN = new RegExp(`^((?:${ESC}\\[[0-9;]*m)*)${PI_SELECT_CURSOR} `);
+var SelectList2 = class extends SelectList {
+  designCursor;
+  constructor(items, maxVisible, theme, layout) {
+    super(items, maxVisible, theme, layout);
+    this.designCursor = theme.cursor;
+  }
+  render(width) {
+    const lines = super.render(width);
+    const cursor = this.designCursor;
+    if (!cursor || cursor === PI_SELECT_CURSOR) return lines;
+    return lines.map((line) => line.replace(LEADING_CURSOR_PATTERN, `$1${cursor} `));
+  }
+};
+
+// src/engine/tui.ts
+function createAgentProgress(terminal) {
+  let active = false;
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      terminal.setProgress(true);
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      terminal.setProgress(false);
+    },
+    isActive() {
+      return active;
+    }
+  };
+}
+
+// src/interactive/theme/glyphs.ts
+init_esm_shims();
+var GLYPH = {
+  // Clio wordmark, shown in the welcome and dashboard headers only.
+  brand: ">C_",
+  // Agent voice glyph for the chat reply prefix. It renders in accent on a
+  // normal turn and error red on a failed one. The `>C_` wordmark is no longer
+  // the reply prefix; it survives only in the two headers above.
+  agent: "\u2726",
+  user: "\u203A",
+  // Selection focus marker for list overlays. It is deliberately distinct from
+  // the tool ledger's toolHeader so a focused row never reads as a tool line.
+  cursor: "\u276F",
+  toolHeader: "\u25B8",
+  running: "\u25CF",
+  queued: "\u25CC",
+  speed: "\u26A1",
+  ok: "\u2713",
+  error: "\u2717",
+  cancelled: "\u2298",
+  active: "\u25C6",
+  scoped: "\u25C7",
+  up: "\u2191",
+  down: "\u2193",
+  rail: "\u2502",
+  innerDivider: "\u254C",
+  barFull: "\u2588",
+  barEmpty: "\u2591",
+  contextFull: "\u25B0",
+  contextFree: "\u25B1",
+  // Autocompact reserve cells: held-back headroom is neither used nor free,
+  // so it carries its own glyph and never reads as filled when only color is
+  // lost. The medium-shade block is single-width in the same fonts that carry
+  // the barFull/barEmpty fallbacks.
+  contextReserve: "\u2592",
+  info: "\u2139",
+  warn: "\u26A0",
+  warnInline: "!",
+  phaseWaiting: "\u25D4",
+  phaseThinking: "\u25D0",
+  phaseWriting: "\u25D1",
+  phaseTool: "\u2699",
+  phaseBlocked: "\u23F8",
+  phaseRetry: "\u21BB",
+  phaseCompact: "\u267B",
+  phaseDispatch: "\u21F2",
+  // Marks a run that Clio started for itself (a shadow worker or an internal
+  // harness run) so internal activity reads as a sub-process of the current
+  // turn. It replaces the old `sh:`/`in:` agent-name prefixes; the two
+  // audiences are told apart by tone, not by a second glyph.
+  subProcess: "\u21B3",
+  // Who asked for a dispatched run. Hollow is the operator's own (/run,
+  // /delegate); filled is one the model started by calling a dispatch tool.
+  // The transcript block, the board row, and the footer count share the pair,
+  // so a running ◇ anywhere is work the operator started themselves.
+  workerHuman: "\u25C7",
+  workerAgent: "\u25C6",
+  // A run neither the operator nor the model asked for: wiki documenting, a
+  // bootstrap scout, a judge. It stays off the transcript entirely, so the
+  // board is the only surface that shows it and it gets the quietest mark
+  // that still holds the origin column.
+  workerInternal: "\xB7",
+  ellipsis: "\u2026",
+  favorite: "\u2605"
+};
+var SPINNER_FRAMES = ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"];
+function spinnerFrame(tick) {
+  const index = (tick % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length;
+  return SPINNER_FRAMES[index] ?? SPINNER_FRAMES[0];
+}
+
+// src/interactive/theme/index.ts
+init_esm_shims();
+
+// src/interactive/theme/tokens.ts
+init_esm_shims();
+var TOKENS = {
+  // The composer rails alone own the neon intensity tier.
+  editor: { rgb: [64, 255, 191], xterm: 85 },
+  editorDanger: { rgb: [255, 80, 88], xterm: 203 },
+  editorAction: { rgb: [255, 171, 69], xterm: 215 },
+  accent: { rgb: [83, 177, 150], xterm: 72 },
+  accentDeep: { rgb: [62, 147, 137], xterm: 66 },
+  tool: { rgb: [111, 173, 165], xterm: 109 },
+  agent: { rgb: [207, 144, 91], xterm: 173 },
+  // Secondary orange remains below the composer intensity tier. The token name teaches the rule: orange
+  // means Clio is acting. It fires only for Clio's signature actions
+  // (dispatching, queued and running fleet work, steering) and for the border
+  // of a prompt that has taken the keyboard and is waiting on a decision, never
+  // as decoration, and never a metric, at most one orange element per region of
+  // the screen. warning stays the soft amber for actual warnings.
+  action: { rgb: [217, 155, 98], xterm: 179 },
+  success: { rgb: [119, 184, 145], xterm: 108 },
+  warning: { rgb: [211, 176, 107], xterm: 179 },
+  error: { rgb: [219, 130, 137], xterm: 174 },
+  info: { rgb: [128, 167, 206], xterm: 110 },
+  reason: { rgb: [175, 155, 201], xterm: 146 },
+  dim: { rgb: [106, 122, 133], xterm: 59 },
+  muted: { rgb: [138, 153, 164], xterm: 102 },
+  title: { rgb: [114, 184, 173], xterm: 109 },
+  frame: { rgb: [47, 93, 90], xterm: 23 },
+  frameStrong: { rgb: [42, 171, 158], xterm: 37 }
+};
+var SGR_RESET = "\x1B[0m";
+var SGR_DIM = "\x1B[2m";
+function colorDisabled(env = process.env) {
+  const raw = env.NO_COLOR;
+  return typeof raw === "string" && raw.length > 0;
+}
+function detectTruecolor(env = process.env) {
+  const colorTerm = (env.COLORTERM ?? "").toLowerCase();
+  if (colorTerm.includes("truecolor") || colorTerm.includes("24bit")) return true;
+  const term = (env.TERM ?? "").toLowerCase();
+  return term.includes("truecolor") || term.includes("24bit");
+}
+function fgCode(color, truecolor) {
+  return truecolor ? `38;2;${color.rgb[0]};${color.rgb[1]};${color.rgb[2]}` : `38;5;${color.xterm}`;
+}
+function bgCode(color, truecolor) {
+  return truecolor ? `48;2;${color.rgb[0]};${color.rgb[1]};${color.rgb[2]}` : `48;5;${color.xterm}`;
+}
+function fgSequence(token, truecolor = detectTruecolor()) {
+  if (colorDisabled()) return "";
+  return `\x1B[${fgCode(TOKENS[token], truecolor)}m`;
+}
+function createClioTheme(options = {}) {
+  const truecolor = options.truecolor ?? detectTruecolor();
+  const color = options.color ?? !colorDisabled();
+  const paint = (text, mods) => {
+    const codes = [];
+    if (mods.bold) codes.push("1");
+    if (mods.dim) codes.push("2");
+    if (mods.italic) codes.push("3");
+    if (mods.underline) codes.push("4");
+    if (color && mods.fg) codes.push(fgCode(TOKENS[mods.fg], truecolor));
+    if (color && mods.bg) codes.push(bgCode(TOKENS[mods.bg], truecolor));
+    if (codes.length === 0) return text;
+    return `\x1B[${codes.join(";")}m${text}${SGR_RESET}`;
+  };
+  return {
+    truecolor,
+    paint,
+    fg: (token, text) => paint(text, { fg: token }),
+    bg: (token, text) => paint(text, { bg: token }),
+    style: (token, text, mods = {}) => paint(text, { ...mods, fg: token }),
+    fgSequence: (token) => color ? `\x1B[${fgCode(TOKENS[token], truecolor)}m` : ""
+  };
+}
+function isClioToken(value) {
+  return Object.hasOwn(TOKENS, value);
+}
+var HEX_COLOR = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/u;
+function paintHex(text, hex, options = {}) {
+  const match = HEX_COLOR.exec(hex);
+  if (match === null) return text;
+  if (!(options.color ?? !colorDisabled())) return text;
+  const truecolor = options.truecolor ?? detectTruecolor();
+  const red = Number.parseInt(match[1] ?? "0", 16);
+  const green = Number.parseInt(match[2] ?? "0", 16);
+  const blue = Number.parseInt(match[3] ?? "0", 16);
+  if (truecolor) return `\x1B[38;2;${red};${green};${blue}m${text}${SGR_RESET}`;
+  const cube = (channel) => Math.round(channel / 255 * 5);
+  return `\x1B[38;5;${16 + 36 * cube(red) + 6 * cube(green) + cube(blue)}m${text}${SGR_RESET}`;
+}
+
+// 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));
+}
+
+// src/interactive/theme/components.ts
+var identity = (text) => text;
+function markdownTheme(theme, highlightCode) {
+  return {
+    heading: (text) => screenTitle(theme, text),
+    link: (text) => theme.fg("info", text),
+    linkUrl: (text) => theme.fg("dim", text),
+    code: (text) => theme.fg("muted", text),
+    codeBlock: (text) => text,
+    codeBlockBorder: (text) => theme.fg("frame", text),
+    quote: (text) => theme.fg("muted", text),
+    quoteBorder: (text) => theme.fg("frame", text),
+    hr: (text) => theme.fg("frame", text),
+    listBullet: (text) => theme.fg("accent", text),
+    bold: (text) => theme.paint(text, { bold: true }),
+    italic: (text) => theme.paint(text, { italic: true }),
+    strikethrough: identity,
+    underline: (text) => theme.paint(text, { underline: true }),
+    ...highlightCode ? { highlightCode } : {}
+  };
+}
+function selectListTheme(theme) {
+  return {
+    // The design cursor the engine SelectList swaps in for pi-tui's arrow.
+    cursor: GLYPH.cursor,
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.style("accent", text, { bold: true }),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("dim", text),
+    noMatch: (text) => theme.fg("warning", text)
+  };
+}
+function settingsListTheme(theme) {
+  return {
+    label: (text, selected) => selected ? theme.style("accent", text, { bold: true }) : text,
+    value: (text, selected) => selected ? theme.fg("success", text) : theme.fg("muted", text),
+    description: (text) => theme.fg("muted", text),
+    cursor: GLYPH.cursor,
+    hint: (text) => theme.fg("dim", text)
+  };
+}
+function editorTheme(theme) {
+  return {
+    borderColor: (text) => theme.style("editor", text, { bold: true }),
+    selectList: selectListTheme(theme)
+  };
+}
+
+// src/interactive/theme/labels.ts
+init_esm_shims();
+var identitySegments = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function fitIdentityLabel(value, width) {
+  value = sanitizeCallTargetText(value);
+  const room = Math.max(0, Math.floor(width));
+  if (visibleWidth(value) <= room) return value;
+  if (room <= 1) return room === 1 ? "\u2026" : "";
+  const tailBudget = Math.ceil((room - 1) / 2);
+  let tail = "";
+  for (const { segment } of [...identitySegments.segment(value)].reverse()) {
+    if (visibleWidth(segment + tail) > tailBudget) break;
+    tail = segment + tail;
+  }
+  const headBudget = room - 1 - visibleWidth(tail);
+  let head = "";
+  for (const { segment } of identitySegments.segment(value)) {
+    if (visibleWidth(head + segment) > headBudget) break;
+    head += segment;
+  }
+  return `${head}\u2026${tail}`;
+}
+function abbreviateModelId(modelId) {
+  const value = sanitizeCallTargetText(modelId ?? "");
+  if (value.length === 0) return "model";
+  if (visibleWidth(value) <= 24) return value;
+  const slash = value.lastIndexOf("/");
+  if (slash < 0) return fitIdentityLabel(value, 24);
+  const placement = value.slice(0, slash);
+  const model = value.slice(slash + 1);
+  const modelBudget = Math.min(18, visibleWidth(model));
+  return `${fitIdentityPrefix(placement, 23 - modelBudget)}/${fitIdentityLabel(model, modelBudget)}`;
+}
+function fitIdentityPrefix(value, width) {
+  return stripTerminalSequences(truncateToWidth(value, Math.max(0, width), "\u2026", false));
+}
+function formatTargetLabel(targetId, modelId, options = {}) {
+  const target = sanitizeCallTargetText(targetId ?? "");
+  const model = sanitizeCallTargetText(modelId ?? "");
+  const fit = (label) => options.width === void 0 ? label : fitIdentityLabel(label, options.width);
+  if (target.length === 0 && model.length === 0) return fit("not configured");
+  if (options.width !== void 0 && target.length > 0 && model.length > 0) {
+    const width = Math.max(0, Math.floor(options.width));
+    const separator = options.separator ?? " \xB7 ";
+    const full = `${target}${separator}${model}`;
+    if (visibleWidth(full) <= width) return full;
+    const leaf = model.slice(model.lastIndexOf("/") + 1);
+    const available = width - visibleWidth(separator);
+    if (available < 9) return fitIdentityLabel(leaf, width);
+    const modelBudget = Math.min(visibleWidth(leaf), Math.max(8, Math.ceil(available * 0.7)));
+    const targetBudget = Math.min(visibleWidth(target), available - modelBudget);
+    return `${fitIdentityPrefix(target, targetBudget)}${separator}${fitIdentityLabel(leaf, available - targetBudget)}`;
+  }
+  const shown = options.abbreviate === false ? model : abbreviateModelId(model);
+  if (target.length === 0) return fit(`no target \xB7 ${shown}`);
+  if (model.length === 0) return fit(`${target} \xB7 no model`);
+  return `${target}${options.separator ?? " \xB7 "}${shown}`;
+}
+function formatCompactMs(value) {
+  const ms = Math.max(0, Math.round(value));
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = ms / 1e3;
+  return seconds < 60 ? `${seconds.toFixed(seconds >= 10 ? 0 : 1)}s` : `${Math.floor(seconds / 60)}m${Math.round(seconds % 60)}s`;
+}
+function formatContextPercent(percent) {
+  return typeof percent === "number" && Number.isFinite(percent) ? `${percent.toFixed(1)}%` : "?%";
+}
+function collapseHomePath(path) {
+  const home = process.env.HOME;
+  if (!home || home.length === 0) return path;
+  if (path === home) return "~";
+  return path.startsWith(`${home}/`) ? `~/${path.slice(home.length + 1)}` : path;
+}
+
+// src/interactive/theme/rules.ts
+init_esm_shims();
+function padAnsi(text, width, ellipsis = "") {
+  return truncateToWidth(text, Math.max(0, width), ellipsis, true);
+}
+function fitUnits(theme, prefix, units, maxWidth) {
+  const sep = " \xB7 ";
+  let line = prefix;
+  for (let index = 0; index < units.length; index += 1) {
+    const candidate = index === 0 ? `${line}${units[index]}` : `${line}${sep}${units[index]}`;
+    const reserve = index < units.length - 1 ? 2 : 0;
+    if (visibleWidth(candidate) + reserve > maxWidth) {
+      if (index === 0) return truncateToWidth(candidate, Math.max(0, maxWidth), "\u2026", false);
+      return `${line} ${theme.fg("dim", "\u2026")}`;
+    }
+    line = candidate;
+  }
+  return line;
+}
+function rule(theme, width, options = {}) {
+  const safeWidth = Math.max(0, width);
+  if (safeWidth === 0) return "";
+  const left = options.left ? `${theme.style(options.leftToken ?? "accent", options.left, { bold: true })} ` : "";
+  const rightBody = options.rightRaw ? options.right : theme.fg(options.rightToken ?? "muted", options.right ?? "");
+  const right = options.right ? ` ${rightBody} ${options.rightTail ?? ""}` : "";
+  const labelsWidth = visibleWidth(left) + visibleWidth(right);
+  if (labelsWidth >= safeWidth) return truncateToWidth(`${left}${right}`.trim(), safeWidth, "", true);
+  const fill = theme.style(options.fillToken ?? "frame", "\u2500".repeat(safeWidth - labelsWidth), {
+    bold: options.fillToken === "frameStrong" || options.fillToken === "editor"
+  });
+  return `${left}${fill}${right}`;
+}
+function frame(theme, title, lines, width, opts = {}) {
+  const safeWidth = Math.max(4, width);
+  const contentWidth = Math.max(0, safeWidth - 4);
+  const frameFg = (text) => theme.fg("frame", text);
+  const hasTitle = title.length > 0;
+  const styledTitle = !hasTitle ? "" : title.includes("\x1B") ? title : theme.style("title", title, { bold: true });
+  const titleWidth = visibleWidth(title);
+  const meta = opts.rightMeta ?? "";
+  const hasMeta = meta.length > 0;
+  const metaWidth = hasMeta ? visibleWidth(meta) : 0;
+  const leftVisible = 2 + (hasTitle ? titleWidth + 2 : 0);
+  const rightVisible = hasMeta ? metaWidth + 4 : 1;
+  const fillWidth = Math.max(0, safeWidth - leftVisible - rightVisible);
+  const leftStr = hasTitle ? `${frameFg("\u250C\u2500")} ${styledTitle} ` : frameFg("\u250C\u2500");
+  const rightStr = hasMeta ? ` ${theme.fg("dim", meta)} ${frameFg("\u2500\u2510")}` : frameFg("\u2510");
+  const top = `${leftStr}${frameFg("\u2500".repeat(fillWidth))}${rightStr}`;
+  const body = lines.map((line) => `${frameFg("\u2502")} ${padAnsi(line, contentWidth)} ${frameFg("\u2502")}`);
+  const bottom = `${frameFg("\u2514")}${frameFg("\u2500".repeat(safeWidth - 2))}${frameFg("\u2518")}`;
+  return [top, ...body, bottom];
+}
+function innerDivider(theme, width) {
+  return theme.fg("frame", GLYPH.innerDivider.repeat(Math.max(0, width)));
+}
+
+// src/interactive/theme/index.ts
+var sharedTheme = null;
+function clioTheme() {
+  sharedTheme ??= createClioTheme();
+  return sharedTheme;
+}
+
+// src/interactive/keybinding-manager.ts
+init_esm_shims();
+
+// src/domains/config/keybindings.ts
+init_esm_shims();
+var CLIO_APP_KEYBINDINGS = {
+  "clio-coder.library.toggle": {
+    defaultKeys: "alt+l",
+    description: "Library",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "l"
+  },
+  "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: "Dashboard pages: Activity \u2192 Context \u2192 Status \u2192 closed",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false,
+    leader: "u"
+  },
+  "clio-coder.dispatchBoard.toggle": {
+    defaultKeys: "alt+w",
+    description: "Workers",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "w"
+  },
+  "clio-coder.files.toggle": {
+    defaultKeys: "alt+e",
+    description: "Files (from Clio focus)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false,
+    leader: "e"
+  },
+  "clio-coder.thinking.cycle": {
+    defaultKeys: "shift+tab",
+    description: "Thinking effort",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false,
+    leader: "t"
+  },
+  "clio-coder.message.followUp": {
+    defaultKeys: "ctrl+q",
+    description: "Send after the active run",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "f"
+  },
+  "clio-coder.message.dequeue": {
+    defaultKeys: "alt+q",
+    description: "Restore queued messages",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "q"
+  },
+  "clio-coder.exit": {
+    defaultKeys: "ctrl+d",
+    description: "Exit empty idle composer with no queued messages",
+    scope: "composer",
+    kind: "exit",
+    repeat: false
+  },
+  "clio-coder.leader": {
+    defaultKeys: "ctrl+g",
+    description: "Open contextual action menu",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
+  },
+  "clio-coder.tasks.open": {
+    defaultKeys: [],
+    description: "Tasks (/tasks)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
+  },
+  "clio-coder.decisions.open": {
+    defaultKeys: [],
+    description: "Decisions (/decisions)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
+  },
+  "clio-coder.session.tree": {
+    defaultKeys: [],
+    description: "Session tree (/tree)",
+    scope: "composer",
+    kind: "toggle",
+    repeat: false
+  },
+  "clio-coder.model.cycleForward": {
+    defaultKeys: [],
+    description: "Next scoped model",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false
+  },
+  "clio-coder.model.cycleBackward": {
+    defaultKeys: [],
+    description: "Previous scoped model",
+    scope: "composer",
+    kind: "cycle",
+    repeat: false
+  },
+  "clio-coder.dispatch.background": {
+    defaultKeys: [],
+    description: "Background attached dispatch",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "s"
+  },
+  "clio-coder.message.interrupt": {
+    defaultKeys: [],
+    description: "Interrupt with draft",
+    scope: "composer",
+    kind: "send",
+    repeat: false,
+    leader: "i"
+  },
+  "clio-coder.editor.external": {
+    defaultKeys: [],
+    description: "Edit expanded draft externally",
+    scope: "composer",
+    kind: "edit",
+    repeat: false,
+    leader: "g"
+  },
+  "clio-coder.notifications.dismiss": {
+    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.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);
+
+// src/interactive/keybinding-manager.ts
+var BASE_SPECIAL_KEYS = /* @__PURE__ */ new Set([
+  "escape",
+  "esc",
+  "enter",
+  "return",
+  "tab",
+  "space",
+  "backspace",
+  "delete",
+  "insert",
+  "clear",
+  "home",
+  "end",
+  "pageup",
+  "pagedown",
+  "up",
+  "down",
+  "left",
+  "right",
+  "f1",
+  "f2",
+  "f3",
+  "f4",
+  "f5",
+  "f6",
+  "f7",
+  "f8",
+  "f9",
+  "f10",
+  "f11",
+  "f12"
+]);
+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("+");
+  if (parts.length === 0) return false;
+  const base = parts[parts.length - 1];
+  if (!base) return false;
+  const mods = parts.slice(0, -1);
+  const seen = /* @__PURE__ */ new Set();
+  for (const mod of mods) {
+    if (!MODIFIERS.has(mod)) return false;
+    if (seen.has(mod)) return false;
+    seen.add(mod);
+  }
+  if (base.length === 1) {
+    const ch = base.charCodeAt(0);
+    const isLetter = ch >= 97 && ch <= 122;
+    const isDigit = ch >= 48 && ch <= 57;
+    return isLetter || isDigit || BASE_SYMBOL_KEYS.has(base);
+  }
+  return BASE_SPECIAL_KEYS.has(base);
+}
+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 (isValidKeyId(value)) {
+        valid[id] = canonicalKey(value);
+      } else {
+        invalid.push({ id, keys: [value] });
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      const accepted = [];
+      const rejected = [];
+      for (const entry of value) {
+        if (typeof entry !== "string") {
+          rejected.push(String(entry));
+          continue;
+        }
+        if (isValidKeyId(entry)) {
+          accepted.push(canonicalKey(entry));
+        } else {
+          rejected.push(entry);
+        }
+      }
+      if (accepted.length > 0 || value.length === 0) valid[id] = accepted;
+      if (rejected.length > 0) invalid.push({ id, keys: rejected });
+    }
+  }
+  return { valid, invalid };
+}
+function formatInvalidKeybindingNotice(invalid) {
+  const count = invalid.reduce((sum, entry) => sum + entry.keys.length, 0);
+  const detail = invalid.flatMap((entry) => entry.keys.map((key) => `${entry.id}="${key}"`)).join(", ");
+  return `Clio Coder: ${count} invalid keybinding${count === 1 ? "" : "s"} in settings.yaml (defaults kept): ${detail}. Fix settings.yaml or run \`clio-coder doctor\`.
+`;
+}
+function envValue(env, key) {
+  return env[key]?.trim() ?? "";
+}
+function detectTerminalKeySupport(env = process.env) {
+  const term = envValue(env, "TERM");
+  const termProgram = envValue(env, "TERM_PROGRAM");
+  const kittyWindow = envValue(env, "KITTY_WINDOW_ID");
+  const normalized = `${term} ${termProgram}`.toLowerCase();
+  if (kittyWindow.length > 0 || normalized.includes("xterm-kitty") || normalized.includes("kitty")) {
+    return { name: "kitty", supportsCsiU: true, reason: "Kitty keyboard protocol detected", altLetterMode: "meta" };
+  }
+  if (normalized.includes("wezterm") || normalized.includes("ghostty")) {
+    return {
+      name: termProgram || term || "modern terminal",
+      supportsCsiU: true,
+      reason: "CSI-u capable terminal",
+      altLetterMode: "meta"
+    };
+  }
+  if (termProgram === "Apple_Terminal") {
+    return {
+      name: termProgram,
+      supportsCsiU: false,
+      reason: "Terminal.app sends Option-letter as composed text unless Use Option as Meta key is enabled",
+      altLetterMode: "text"
+    };
+  }
+  if (termProgram === "iTerm.app") {
+    return {
+      name: termProgram,
+      supportsCsiU: true,
+      reason: "iTerm2 reports modified keys as Meta or CSI-u",
+      altLetterMode: "meta"
+    };
+  }
+  if (termProgram.toLowerCase() === "vscode") {
+    return {
+      name: "vscode",
+      supportsCsiU: false,
+      reason: "VS Code terminal does not reliably emit CSI-u",
+      altLetterMode: "meta",
+      ideReservedKeys: ["ctrl+p", "shift+ctrl+p", "ctrl+l"]
+    };
+  }
+  if (term.startsWith("screen") || term.startsWith("tmux")) {
+    return { name: term, supportsCsiU: false, reason: "terminal multiplexer may block CSI-u", altLetterMode: "meta" };
+  }
+  return {
+    name: termProgram || term || "legacy terminal",
+    supportsCsiU: false,
+    reason: "CSI-u support not detected",
+    altLetterMode: "meta"
+  };
+}
+function keyRequiresCsiU(keyId) {
+  const parts = keyId.toLowerCase().split("+");
+  if (parts.length < 3) return false;
+  const base = parts[parts.length - 1] ?? "";
+  const modifiers = new Set(parts.slice(0, -1));
+  if (!modifiers.has("shift") || !modifiers.has("ctrl")) return false;
+  if (base.length !== 1) return false;
+  const code = base.charCodeAt(0);
+  const isLetter = code >= 97 && code <= 122;
+  const isDigit = code >= 48 && code <= 57;
+  return isLetter || isDigit || BASE_SYMBOL_KEYS.has(base);
+}
+function normalizeBindingValue(value) {
+  if (value === void 0) return [];
+  return (Array.isArray(value) ? value : [value]).map(String);
+}
+function defaultBindingValue(id) {
+  const value = CLIO_APP_KEYBINDINGS[id].defaultKeys;
+  return normalizeBindingValue(value);
+}
+function normalizeKeyForRisk(keyId) {
+  return keyId.toLowerCase().replace(/^ctrl\+shift\+/, "shift+ctrl+");
+}
+function altLetterBase(keyId) {
+  const parts = keyId.toLowerCase().split("+");
+  if (parts.length !== 2 || parts[0] !== "alt") return null;
+  const base = parts[1] ?? "";
+  return base.length === 1 && base >= "a" && base <= "z" ? base : null;
+}
+function keyUsesAltLetter(keyId) {
+  return altLetterBase(keyId) !== null;
+}
+function terminalReservedReason(keyId) {
+  const key = normalizeKeyForRisk(keyId);
+  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) {
+  const key = normalizeKeyForRisk(keyId);
+  if (!support.supportsCsiU && keyRequiresCsiU(key)) return `needs CSI-u; ${support.reason}`;
+  if (support.altLetterMode === "text" && keyUsesAltLetter(key)) return support.reason;
+  if (support.ideReservedKeys?.map(normalizeKeyForRisk).includes(key)) return `${support.name} may reserve this chord`;
+  return terminalReservedReason(key);
+}
+var MACOS_OPTION_DEFAULT_WARNING_ID = "clio-coder.macos.option-letter.defaults";
+function detectPlatformKeybindingWarnings(userBindings, support = detectTerminalKeySupport()) {
+  const warnings = [];
+  const macosDefaultAltKeys = [];
+  for (const id of CLIO_APP_KEYBINDING_IDS) {
+    const userValue = userBindings[id];
+    const source = userValue === void 0 ? "default" : "user";
+    const keys = userValue === void 0 ? defaultBindingValue(id) : normalizeBindingValue(userValue);
+    const risky = keys.filter((key) => keyRiskReason(key, support) !== null);
+    if (risky.length === 0) continue;
+    const firstReason = keyRiskReason(risky[0] ?? "", support) ?? support.reason;
+    if (source === "default" && support.name === "Apple_Terminal" && risky.every(keyUsesAltLetter)) {
+      macosDefaultAltKeys.push(...risky);
+      continue;
+    }
+    warnings.push({ id, keys: risky, terminal: support.name, reason: firstReason, source });
+  }
+  if (macosDefaultAltKeys.length > 0) {
+    warnings.unshift({
+      id: MACOS_OPTION_DEFAULT_WARNING_ID,
+      keys: [...new Set(macosDefaultAltKeys)],
+      terminal: support.name,
+      reason: support.reason,
+      source: "default"
+    });
+  }
+  return warnings;
+}
+function isMacosOptionDefaultWarning(warning) {
+  return warning.id === MACOS_OPTION_DEFAULT_WARNING_ID;
+}
+function formatPlatformKeybindingNotice(warnings) {
+  const macosOption = warnings.find(isMacosOptionDefaultWarning);
+  if (macosOption && warnings.length === 1) {
+    const keys = macosOption.keys.map((key) => {
+      const base = altLetterBase(key);
+      return base ? `Alt+${base.toUpperCase()}` : key;
+    }).join(", ");
+    return `Clio keybinding notice: Terminal.app may not send Option-letter shortcuts by default (${keys}). Enable Use Option as Meta key in Settings \u25B8 Profiles \u25B8 Keyboard for native Alt, or use Ctrl+G then the shortcut letter, slash commands (/help lists commands), and /help.
+`;
+  }
+  const count = warnings.reduce((sum, entry) => sum + entry.keys.length, 0);
+  const detail = warnings.flatMap((entry) => entry.keys.map((key) => `${entry.id}="${key}" (${entry.source}, ${entry.reason})`)).join(", ");
+  return `Clio keybinding notice: ${count} keybinding${count === 1 ? "" : "s"} may not fire reliably in this terminal: ${detail}. Rebind in settings.yaml or inspect /help.
+`;
+}
+function joinKeys(keys) {
+  if (keys.length === 0) return "(unbound)";
+  if (keys.length === 1) return String(keys[0]);
+  return keys.join(" / ");
+}
+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 canonical = legacyKey(key);
+      const ids = keys.get(canonical) ?? [];
+      if (!ids.includes(id)) ids.push(id);
+      keys.set(canonical, ids);
+    }
+  }
+  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)))
+  }));
+}
+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) => inner.matches(data, id),
+    getKeys: (id) => inner.getKeys(id),
+    getDescription: (id) => inner.getDefinition(id).description ?? "",
+    getConflicts: () => effectiveConflicts(inner),
+    get generation() {
+      return generation;
+    },
+    reload(next) {
+      validated = validateKeybindings(next);
+      inner.setUserBindings(validated.valid);
+      if (install) setKeybindings(inner);
+      generation += 1;
+      for (const listener of listeners) listener();
+    },
+    onReload(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    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) {
+  return buildManager(settings.interface.keybindings ?? {}, env, true);
+}
+function formatKeyLabel(keyId, fallback = "unbound") {
+  if (!keyId || keyId.length === 0) return fallback;
+  return keyId.split("+").map((segment) => segment.length === 0 ? segment : segment.charAt(0).toUpperCase() + segment.slice(1)).join("+");
+}
+
+// src/interactive/permission-hint.ts
+init_esm_shims();
+var MUTATION_PREVIEW_KEY = "v";
+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", 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 details", short: "hide", critical: false }
+    ] : [{ key: MUTATION_PREVIEW_KEY, verb: "inspect details", short: "inspect", critical: false }],
+    { key: "s", verb: "stop turn", short: "stop", critical: true },
+    // With a draft, deny and stop are the only immediate answers, so Esc
+    // outranks the narrowing that would otherwise drop it first.
+    { key: "Esc", verb: "deny", critical: composerHasDraft }
+  ];
+}
+
+// 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";
+function formatModalMarkerTitle(stack) {
+  const top = stack.at(-1);
+  if (top === void 0) return MODAL_MARKER_BASE_TITLE;
+  const beneath = stack.length - 1;
+  return `${MODAL_MARKER_BASE_TITLE} [modal:${top}${beneath > 0 ? `+${beneath}` : ""}]`;
+}
+function createModalMarkerRegistry() {
+  const entries = [];
+  let sink = null;
+  let published = null;
+  function activeIds() {
+    return entries.filter((entry) => entry.active).map((entry) => entry.id);
+  }
+  function publish() {
+    if (sink === null) return;
+    const title = formatModalMarkerTitle(activeIds());
+    if (published === null && title === MODAL_MARKER_BASE_TITLE) return;
+    if (title === published) return;
+    published = title;
+    sink.setTitle(title);
+  }
+  function enter(id, nextSink) {
+    if (nextSink) sink = nextSink;
+    const entry = { id, active: true };
+    entries.push(entry);
+    publish();
+    let released = false;
+    return {
+      release() {
+        if (released) return;
+        released = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1) entries.splice(index, 1);
+        publish();
+      },
+      setActive(active) {
+        if (released || entry.active === active) return;
+        entry.active = active;
+        publish();
+      },
+      raise() {
+        if (released) return;
+        entry.active = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1 && index !== entries.length - 1) {
+          entries.splice(index, 1);
+          entries.push(entry);
+        }
+        publish();
+      }
+    };
+  }
+  return { enter, stack: () => activeIds() };
+}
+var registry = createModalMarkerRegistry();
+function enterModal(id, sink) {
+  return registry.enter(id, sink);
+}
+
+// src/interactive/overlay-frame.ts
+var DEFAULT_SELECT_THEME = selectListTheme(clioTheme());
+var DEFAULT_SETTINGS_THEME = settingsListTheme(clioTheme());
+var FocusBox = class extends Box {
+  inputTarget;
+  onInput;
+  constructor(children, options) {
+    super(options?.x ?? 1, options?.y ?? 0);
+    const childList = Array.isArray(children) ? children : [children];
+    for (const child of childList) this.addChild(child);
+    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);
+      return;
+    }
+    this.inputTarget?.handleInput?.(data);
+  }
+};
+function resolveTone(tone) {
+  return typeof tone === "function" ? tone() : tone;
+}
+function clioFrame(text, token = "frame") {
+  return clioTheme().fg(token, text);
+}
+function clioTitle(text, token) {
+  return token === void 0 ? screenTitle(clioTheme(), text) : clioTheme().style(token, text, { bold: true });
+}
+function clioError(text) {
+  return clioTheme().fg("error", text);
+}
+function brandedTopBorder(label, innerWidth, tone) {
+  const frame2 = (text) => clioFrame(text, tone ?? "frame");
+  const clean = label.replace(/^[┌┐└┘├┤─│\s]+/, "").replace(/[┌┐└┘├┤─│\s]+$/, "");
+  const formatted = clean.length > 0 ? `\u2500 ${clean} ` : "\u2500";
+  const clipped = visibleWidth(formatted) > innerWidth ? truncateToWidth(formatted, innerWidth, "\u2026", true) : formatted;
+  const fill = "\u2500".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+  const cleanIndex = clipped.indexOf(clean);
+  if (cleanIndex !== -1) {
+    const prefix = clipped.slice(0, cleanIndex);
+    const suffix = clipped.slice(cleanIndex + clean.length);
+    return `${frame2("\u250C")}${frame2(prefix)}${clioTitle(clean, tone)}${frame2(suffix)}${frame2(fill)}${frame2("\u2510")}`;
+  }
+  return `${frame2("\u250C")}${frame2(clipped)}${frame2(fill)}${frame2("\u2510")}`;
+}
+function isCriticalHintKey(key) {
+  const canonical = canonicalizeKey(key);
+  return canonical === "Esc" || canonical === "Enter" || canonical === "Enter/Space" || canonical === "type";
+}
+function isCriticalEntry(entry) {
+  return entry.critical ?? isCriticalHintKey(entry.key);
+}
+function renderHintEntries(entries, short) {
+  return entries.map((entry) => `[${canonicalizeKey(entry.key)}] ${short ? entry.short ?? entry.verb : entry.verb}`).join(" \xB7 ");
+}
+function fitHintEntries(entries, maxWidth) {
+  if (entries.length === 0) return "";
+  for (const short of [false, true]) {
+    const rendered = renderHintEntries(entries, short);
+    if (visibleWidth(rendered) <= maxWidth) return rendered;
+  }
+  const kept = [...entries];
+  for (const criticalPass of [false, true]) {
+    while (kept.length > 1) {
+      const index = kept.findIndex((entry) => criticalPass || !isCriticalEntry(entry));
+      if (index === -1) break;
+      kept.splice(index, 1);
+      const rendered = renderHintEntries(kept, true);
+      if (visibleWidth(rendered) <= maxWidth) return rendered;
+    }
+  }
+  return renderHintEntries(kept, true);
+}
+var FILTER_HINT = { key: "type", verb: "filter" };
+function canonicalizeKey(key) {
+  const trimmed = key.trim();
+  if (trimmed === "R") return "R";
+  const lower = trimmed.toLowerCase();
+  if (lower === "up/down" || lower === "updown" || lower === "\u2191/\u2193" || lower === "up/down/j/k" || lower === "\u2191\u2193")
+    return "\u2191\u2193";
+  if (lower === "enter/space") return "Enter/Space";
+  if (lower === "enter") return "Enter";
+  if (lower === "esc" || lower === "escape") return "Esc";
+  if (lower === "space") return "Space";
+  if (lower === "tab") return "Tab";
+  if (lower === "r") return "r";
+  if (lower === "type") return "type";
+  return trimmed;
+}
+function buildHint(entries, esc = "close") {
+  const finalEntries = [
+    ...entries.map((e) => ({ key: canonicalizeKey(e.key), verb: e.verb })),
+    { key: "Esc", verb: esc }
+  ];
+  return finalEntries.map((e) => `[${e.key}] ${e.verb}`).join(" \xB7 ");
+}
+function buildResponsiveHint(entries, esc = "close") {
+  const escEntry = esc === null ? null : typeof esc === "string" ? { key: "Esc", verb: esc } : esc;
+  const all = escEntry ? [...entries, escEntry] : [...entries];
+  return (innerWidth) => fitHintEntries(all, innerWidth - 3);
+}
+function elideHint(hint, maxCleanWidth) {
+  const parts = hint.split(" \xB7 ");
+  if (parts.length <= 2) return hint;
+  const entries = parts.map((part) => {
+    const match = /^\[([^\]]+)\] ([\s\S]+)$/u.exec(part);
+    if (!match) return { key: "", verb: part, critical: false };
+    return { key: match[1] ?? "", verb: match[2] ?? "" };
+  });
+  const rendered = fitHintEntries(entries, maxCleanWidth);
+  return rendered.replace(/\[\] /gu, "");
+}
+function brandedBottomBorder(innerWidth, hint, tone) {
+  const frame2 = (text) => clioFrame(text, tone ?? "frame");
+  if (!hint || hint.trim().length === 0) {
+    return `${frame2("\u2514")}${frame2("\u2500".repeat(innerWidth))}${frame2("\u2518")}`;
+  }
+  let clean = hint.trim();
+  const maxCleanWidth = innerWidth - 3;
+  if (clean.includes(" \xB7 ") && visibleWidth(`\u2500 ${clean} `) > innerWidth) {
+    clean = elideHint(clean, maxCleanWidth);
+  }
+  const formatted = `\u2500 ${clean} `;
+  const clipped = visibleWidth(formatted) > innerWidth ? truncateToWidth(formatted, innerWidth, "\u2026", true) : formatted;
+  const fill = "\u2500".repeat(Math.max(0, innerWidth - visibleWidth(clipped)));
+  const cleanIndex = clipped.indexOf(clean);
+  if (cleanIndex !== -1) {
+    const prefix = clipped.slice(0, cleanIndex);
+    const suffix = clipped.slice(cleanIndex + clean.length);
+    return `${frame2("\u2514")}${frame2(prefix)}${clioTheme().fg("dim", clean)}${frame2(suffix)}${frame2(fill)}${frame2("\u2518")}`;
+  }
+  return `${frame2("\u2514")}${frame2(clipped)}${frame2(fill)}${frame2("\u2518")}`;
+}
+function formatRuntimeResolutionDiagnostic(diagnostic) {
+  return `${diagnostic.severity}: ${diagnostic.code}: ${diagnostic.message}`;
+}
+function diagnosticSeverityToken(severity) {
+  return severity === "error" ? "error" : severity === "warning" ? "warning" : "muted";
+}
+function frameAlignForAnchor(anchor) {
+  if (anchor === void 0) return "center";
+  if (anchor === "left-center" || anchor.endsWith("-left")) return "left";
+  if (anchor === "right-center" || anchor.endsWith("-right")) return "right";
+  return "center";
+}
+function fitBody(lines, rowBudget, contentWidth) {
+  if (rowBudget <= 0) return lines;
+  const bodyBudget = Math.max(1, rowBudget - 2);
+  if (lines.length <= bodyBudget) return lines;
+  const kept = lines.slice(0, bodyBudget - 1);
+  const hidden = lines.length - kept.length;
+  return [...kept, clioTheme().fg("dim", truncateToWidth(`\u2026 ${hidden} more rows`, contentWidth, "", true))];
+}
+var ClioOverlayFrame = class {
+  constructor(child, title, footerHint, boxWidth = 0, align = "center", tone, fullscreen = false) {
+    this.child = child;
+    this.title = title;
+    this.footerHint = footerHint;
+    this.boxWidth = boxWidth;
+    this.align = align;
+    this.tone = tone;
+    this.fullscreen = fullscreen;
+  }
+  child;
+  title;
+  footerHint;
+  boxWidth;
+  align;
+  tone;
+  fullscreen;
+  /**
+   * Rows the box may occupy, or zero while unknown.
+   *
+   * `Component.render` is handed a width and nothing else, so the frame learns
+   * its height budget from the engine's `visible` predicate, which is called
+   * with the live terminal size immediately before the render pass that
+   * composites this overlay.
+   */
+  rowBudget = 0;
+  /**
+   * Last rendered box, keyed by everything that shapes it. `childLines` is
+   * compared by array identity: a child that rebuilds its rows returns a fresh
+   * array and correctly misses, and one that serves a cache returns the same
+   * array and correctly hits.
+   */
+  cachedRender;
+  setRowBudget(rows) {
+    this.rowBudget = Math.max(0, Math.floor(rows));
+  }
+  render(width) {
+    const boxWidth = Math.max(5, Math.min(this.boxWidth > 0 ? this.boxWidth : width, width));
+    const contentWidth = Math.max(1, boxWidth - 4);
+    const childLines = this.child.render(contentWidth);
+    const titleText = typeof this.title === "function" ? this.title() : this.title;
+    const hint = typeof this.footerHint === "function" ? this.footerHint(contentWidth + 2) : this.footerHint;
+    const tone = resolveTone(this.tone);
+    const cached = this.cachedRender;
+    if (cached !== void 0 && cached.width === width && cached.rowBudget === this.rowBudget && cached.childLines === childLines && cached.title === titleText && cached.hint === hint && cached.tone === tone) {
+      return cached.lines;
+    }
+    const label = titleText.length > 0 ? `\u2500 ${titleText} ` : "\u2500 ";
+    const side = clioFrame("\u2502", tone ?? "frame");
+    const body = [...fitBody(childLines, this.rowBudget, contentWidth)];
+    if (this.fullscreen) {
+      while (body.length < Math.max(0, this.rowBudget - 2)) body.push("");
+    }
+    const boxLines = this.fullscreen ? [
+      padAnsi(`  ${clioTitle(titleText, tone)}`, boxWidth),
+      ...body.map((line) => `  ${padAnsi(line, contentWidth)}  `),
+      padAnsi(`  ${clioTheme().fg("muted", hint ?? "")}`, boxWidth)
+    ] : [
+      brandedTopBorder(label, contentWidth + 2, tone),
+      ...body.map((line) => `${side} ${padAnsi(line, contentWidth)} ${side}`),
+      brandedBottomBorder(contentWidth + 2, hint, tone)
+    ];
+    const slack = Math.max(0, width - boxWidth);
+    const lines = (() => {
+      if (slack === 0) return boxLines;
+      const leading = this.align === "left" ? 0 : this.align === "right" ? slack : Math.floor(slack / 2);
+      const lead = " ".repeat(leading);
+      const trail = " ".repeat(slack - leading);
+      return boxLines.map((line) => `${lead}${line}${trail}`);
+    })();
+    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);
+  }
+  invalidate() {
+    this.cachedRender = void 0;
+    this.child.invalidate?.();
+  }
+};
+function showClioOverlayFrame(tui, child, options) {
+  const { title, footerHint, tone, width, visible, maxHeight, margin, markerId, fullscreen, ...overlayOptions } = options;
+  const boxWidth = typeof width === "number" ? width : 0;
+  const frame2 = new ClioOverlayFrame(
+    child,
+    title,
+    footerHint,
+    boxWidth,
+    frameAlignForAnchor(options.anchor),
+    tone,
+    fullscreen
+  );
+  const handle = tui.showOverlay(frame2, {
+    ...overlayOptions,
+    ...margin !== void 0 ? { margin } : {},
+    width: "100%",
+    visible: (termWidth, termHeight) => {
+      const shown = visible ? visible(termWidth, termHeight) : true;
+      const marginRows = typeof margin === "number" ? margin * 2 : (margin?.top ?? 0) + (margin?.bottom ?? 0);
+      const available = Math.max(1, termHeight - marginRows);
+      const requested = resolveRowSize(maxHeight, termHeight);
+      frame2.setRowBudget(requested === null ? available : Math.min(requested, available));
+      return shown;
+    }
+  });
+  const marker = enterModal(markerId, modalMarkerSink(tui));
+  return {
+    hide() {
+      marker.release();
+      handle.hide();
+    },
+    setHidden(hidden) {
+      marker.setActive(!hidden);
+      handle.setHidden(hidden);
+    },
+    isHidden: () => handle.isHidden(),
+    focus() {
+      marker.raise();
+      handle.focus();
+    },
+    // A pure passthrough on purpose. The engine hands focus to the next
+    // visible capturing overlay, which is another modal, so the stack is
+    // unchanged; the surface that gives the keyboard back to the composer
+    // does it by hiding, which `setHidden` already reports.
+    unfocus: (unfocusOptions) => unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
+    isFocused: () => handle.isFocused(),
+    getBounds: () => handle.getBounds()
+  };
+}
+function modalMarkerSink(tui) {
+  const terminal = tui.terminal;
+  return typeof terminal?.setTitle === "function" ? terminal : null;
+}
+function resolveRowSize(value, termHeight) {
+  if (typeof value === "number") return Math.max(1, Math.floor(value));
+  if (typeof value !== "string") return null;
+  const percent = /^(\d+(?:\.\d+)?)%$/u.exec(value.trim());
+  if (!percent?.[1]) return null;
+  return Math.max(1, Math.floor(termHeight * Number.parseFloat(percent[1]) / 100));
+}
+
+export {
+  InstrumentedTuiMainScreen,
+  InstrumentedTuiAltScreen,
+  SelectList2 as SelectList,
+  createAgentProgress,
+  SGR_RESET,
+  SGR_DIM,
+  fgSequence,
+  isClioToken,
+  paintHex,
+  GLYPH,
+  spinnerFrame,
+  brandMark,
+  dotSep,
+  barSep,
+  sectionTag,
+  screenTitle,
+  listGroupHeader,
+  joinChips,
+  markdownTheme,
+  selectListTheme,
+  editorTheme,
+  fitIdentityLabel,
+  abbreviateModelId,
+  formatTargetLabel,
+  formatCompactMs,
+  formatContextPercent,
+  collapseHomePath,
+  padAnsi,
+  fitUnits,
+  rule,
+  frame,
+  innerDivider,
+  clioTheme,
+  MUTATION_PREVIEW_KEY,
+  PERMISSION_TERMS_KEY,
+  permissionHintEntries,
+  CLIO_APP_KEYBINDINGS,
+  CLIO_APP_KEYBINDING_IDS,
+  validateKeybindings,
+  formatInvalidKeybindingNotice,
+  detectTerminalKeySupport,
+  detectPlatformKeybindingWarnings,
+  formatPlatformKeybindingNotice,
+  createKeybindingManager,
+  formatKeyLabel,
+  keyboardOwner,
+  focusedComponent,
+  localKey,
+  DEFAULT_SELECT_THEME,
+  FocusBox,
+  clioError,
+  fitHintEntries,
+  FILTER_HINT,
+  buildHint,
+  buildResponsiveHint,
+  formatRuntimeResolutionDiagnostic,
+  diagnosticSeverityToken,
+  showClioOverlayFrame
+};
+//# sourceMappingURL=chunk-3O5JWP4L.js.map