@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-M6YLF66Z.js

@@ -1,2687 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  Box,
-  Editor,
-  Input,
-  KeybindingsManager,
-  ProcessTerminal,
-  SelectList,
-  TUI_KEYBINDINGS,
-  TuiAltScreen,
-  TuiMainScreen,
-  decodePrintableKey,
-  getKeybindings,
-  setKeybindings,
-  stripTerminalSequences,
-  truncateToWidth,
-  visibleWidth
-} from "./chunk-434LRQ6Z.js";
-import {
-  combineBashOutput
-} from "./chunk-555E2WVV.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.deferredAdmission = new DeferredRenderAdmission(renderAdmission, (force) => super.requestRender(force));
-  }
-  renderObserver;
-  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/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();
-
-// src/interactive/theme/tokens.ts
-init_esm_shims();
-var TOKENS = {
-  accent: { rgb: [70, 229, 208], xterm: 80 },
-  accentDeep: { rgb: [31, 183, 166], xterm: 44 },
-  // Second brand color: neon orange. 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: [255, 126, 41], xterm: 208 },
-  success: { rgb: [87, 227, 137], xterm: 114 },
-  warning: { rgb: [255, 180, 84], xterm: 221 },
-  error: { rgb: [255, 92, 102], xterm: 203 },
-  info: { rgb: [91, 168, 255], xterm: 75 },
-  reason: { rgb: [157, 140, 255], xterm: 141 },
-  dim: { rgb: [106, 122, 133], xterm: 59 },
-  muted: { rgb: [138, 153, 164], xterm: 102 },
-  title: { rgb: [70, 229, 208], xterm: 80 },
-  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();
-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("frameStrong", 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"
-  });
-  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/clio-editor.ts
-init_esm_shims();
-
-// src/interactive/editor-bash.ts
-init_esm_shims();
-var PASTED_EDITOR_OPERATOR_GUARD = "\u2063";
-function guardPastedEditorOperator(text) {
-  return `${PASTED_EDITOR_OPERATOR_GUARD}${text}`;
-}
-function unguardPastedEditorOperator(text) {
-  return text.startsWith(PASTED_EDITOR_OPERATOR_GUARD) ? text.slice(PASTED_EDITOR_OPERATOR_GUARD.length) : text;
-}
-function parseEditorBashCommand(text) {
-  if (text.startsWith(PASTED_EDITOR_OPERATOR_GUARD) || text.includes("\n") || text.includes("\r")) return null;
-  if (!text.startsWith("!")) return null;
-  const excludeFromContext = text.startsWith("!!");
-  const command = (excludeFromContext ? text.slice(2) : text.slice(1)).trim();
-  if (command.length === 0) return null;
-  return { command, excludeFromContext };
-}
-function appendStatusNotes(output, result, timeoutMs) {
-  const notes = [];
-  if (result.aborted) notes.push("command aborted");
-  if (result.timedOut) notes.push(`command timed out after ${timeoutMs}ms`);
-  if (result.outputCapped) notes.push("command output exceeded the inline output limit");
-  if (result.error && output.trim().length === 0) notes.push(result.error.message);
-  if (notes.length === 0) return output;
-  const suffix = notes.map((note) => `[${note}]`).join("\n");
-  return output.length > 0 ? `${output.replace(/\s+$/g, "")}
-${suffix}` : suffix;
-}
-function bashExecutionEntryInput(args) {
-  const output = appendStatusNotes(combineBashOutput(args.result), args.result, args.timeoutMs);
-  return {
-    kind: "bashExecution",
-    parentTurnId: args.parentTurnId,
-    command: args.command,
-    output,
-    exitCode: args.result.exitCode,
-    cancelled: args.result.aborted,
-    truncated: args.result.outputCapped,
-    excludeFromContext: args.excludeFromContext
-  };
-}
-
-// 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) {
-    this.child = child;
-    this.title = title;
-    this.footerHint = footerHint;
-    this.boxWidth = boxWidth;
-    this.align = align;
-    this.tone = tone;
-  }
-  child;
-  title;
-  footerHint;
-  boxWidth;
-  align;
-  tone;
-  /**
-   * 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 boxLines = [
-      brandedTopBorder(label, contentWidth + 2, tone),
-      ...fitBody(childLines, this.rowBudget, contentWidth).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, ...overlayOptions } = options;
-  const boxWidth = typeof width === "number" ? width : 0;
-  const frame2 = new ClioOverlayFrame(child, title, footerHint, boxWidth, frameAlignForAnchor(options.anchor), tone);
-  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));
-}
-
-// 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 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 }
-    ] : [{ key: MUTATION_PREVIEW_KEY, verb: "inspect mutation", 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/clio-editor.ts
-var REVERSE_VIDEO_BLANK = `${String.fromCharCode(27)}[7m ${String.fromCharCode(27)}[0m`;
-var EMPTY_PROMPT = "Ask Clio\u2026  / for commands";
-var CONFIRM_PROMPT = "A parked call is waiting for your decision";
-var PREPARING_PROMPT = "Clio has your prompt and is preparing the turn";
-var COMPACTING_PROMPT = "Clio has your prompt and is compacting the context first";
-var MIN_HINT_WIDTH = 60;
-function hasScrollIndicator(line) {
-  const stripped = stripTerminalSequences(line);
-  return stripped.includes(GLYPH.up) || stripped.includes(GLYPH.down);
-}
-function normalizeThinkingHint(value) {
-  return value.replace(/^think\s+/i, "").trim().toLowerCase();
-}
-function styledThinkingHint(theme, value) {
-  const hint = normalizeThinkingHint(value);
-  switch (hint) {
-    case "off":
-      return theme.fg("dim", hint);
-    case "minimal":
-    case "low":
-      return theme.fg("muted", hint);
-    case "xhigh":
-    case "max":
-    case "on":
-      return theme.style("reason", hint, { bold: true });
-    default:
-      return theme.fg("reason", hint);
-  }
-}
-function styledRailLabel(theme, chrome, width) {
-  const thinking = styledThinkingHint(theme, chrome.getThinkingLabel());
-  const identity2 = chrome.getModelLabel();
-  const room = Math.max(1, width - visibleWidth(thinking) - 3);
-  const model = typeof identity2 === "string" ? fitIdentityLabel(identity2, room) : formatTargetLabel(identity2.targetId, identity2.modelId, { width: room });
-  return `${theme.fg("dim", model)} ${theme.fg("dim", "\xB7")} ${thinking}`;
-}
-function composerMode(chrome, text) {
-  if (chrome.isAwaitingApproval?.() ?? false) return "CONFIRM";
-  if (!(chrome.isStreaming?.() ?? false)) {
-    const preparation = chrome.getTurnPreparation?.() ?? "idle";
-    if (preparation === "compacting") return "COMPACTING";
-    if (preparation === "preparing") return "PREPARING";
-    return "MESSAGE";
-  }
-  const willSteer = chrome.willEnterSteer?.(text) ?? text.trim().length > 0;
-  return willSteer ? "STEER" : "FOLLOW-UP";
-}
-function lowerRailHint(theme, chrome) {
-  return theme.fg(
-    "dim",
-    `${chrome.getSubmitKeyLabel?.() ?? "Enter"} send \xB7 ${chrome.getNewlineKeyLabel?.() ?? "Ctrl+J"} newline`
-  );
-}
-function confirmRailHint(theme, width, hasDraft, inspection) {
-  return theme.fg("warning", fitHintEntries(permissionHintEntries(hasDraft, inspection), Math.max(1, width - 3)));
-}
-function modeToken(mode) {
-  if (mode === "STEER" || mode === "PREPARING" || mode === "COMPACTING") return "action";
-  if (mode === "CONFIRM") return "warning";
-  return "accentDeep";
-}
-function emptyPromptFor(mode) {
-  if (mode === "CONFIRM") return CONFIRM_PROMPT;
-  if (mode === "PREPARING") return PREPARING_PROMPT;
-  if (mode === "COMPACTING") return COMPACTING_PROMPT;
-  return EMPTY_PROMPT;
-}
-function renderEmptyPrompt(line, width, theme, text = EMPTY_PROMPT) {
-  const cursorAt = line.indexOf(REVERSE_VIDEO_BLANK);
-  if (cursorAt < 0) return line;
-  const afterCursorAt = cursorAt + REVERSE_VIDEO_BLANK.length;
-  const available = Math.max(0, width - 1);
-  const prompt = truncateToWidth(theme.fg("dim", text), available, "\u2026", false);
-  const consumed = visibleWidth(prompt);
-  return `${line.slice(0, afterCursorAt)}${prompt}${line.slice(afterCursorAt + consumed)}`;
-}
-function findBottomRail(lines, width) {
-  const rail = "\u2500".repeat(Math.max(0, width));
-  for (let index = 1; index < lines.length; index += 1) {
-    if (stripTerminalSequences(lines[index] ?? "") === rail) return index;
-  }
-  return -1;
-}
-function cursorEndsDirectoryPath(editor) {
-  const cursor = editor.getCursor();
-  const line = editor.getLines()[cursor.line] ?? "";
-  return line.slice(0, cursor.col).endsWith("/");
-}
-function remapPastedBangOffsets(before, after, offsets, markInsertedAsPasted) {
-  let prefix = 0;
-  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
-  let beforeEnd = before.length;
-  let afterEnd = after.length;
-  while (beforeEnd > prefix && afterEnd > prefix && before[beforeEnd - 1] === after[afterEnd - 1]) {
-    beforeEnd -= 1;
-    afterEnd -= 1;
-  }
-  const next = /* @__PURE__ */ new Set();
-  const shift = afterEnd - prefix - (beforeEnd - prefix);
-  for (const offset of offsets) {
-    if (offset < prefix) next.add(offset);
-    else if (offset >= beforeEnd) next.add(offset + shift);
-  }
-  if (markInsertedAsPasted) {
-    for (let offset = prefix; offset < afterEnd; offset += 1) {
-      if (after[offset] === "!") next.add(offset);
-    }
-  }
-  return next;
-}
-function startsWithPastedOperator(text, pastedBangOffsets) {
-  const first = text.search(/\S/u);
-  return first >= 0 && text[first] === "!" && pastedBangOffsets.has(first);
-}
-var ClioEditor = class extends Editor {
-  constructor(tui, chrome) {
-    super(tui, editorTheme(clioTheme()));
-    this.chrome = chrome;
-  }
-  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;
-    const theme = clioTheme();
-    const safeWidth = Math.max(0, width);
-    const text = this.getText();
-    const mode = composerMode(this.chrome, text);
-    if (hasScrollIndicator(lines[0] ?? "")) {
-      const modeLabel = theme.style(modeToken(mode), mode, { bold: true });
-      lines[0] = truncateToWidth(`${modeLabel} ${lines[0] ?? ""}`, safeWidth, "", true);
-    } else {
-      lines[0] = rule(theme, safeWidth, {
-        left: mode,
-        leftToken: modeToken(mode),
-        right: styledRailLabel(theme, this.chrome, Math.max(1, safeWidth - visibleWidth(mode) - 5)),
-        fillToken: "frameStrong",
-        rightRaw: true,
-        rightTail: theme.style("frameStrong", "\u2500", { bold: true })
-      });
-    }
-    if (text.length === 0 && lines[1]) {
-      lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme, emptyPromptFor(mode));
-    }
-    const bottomRail = findBottomRail(lines, safeWidth);
-    if (bottomRail >= 0 && mode === "CONFIRM") {
-      lines[bottomRail] = rule(theme, safeWidth, {
-        right: confirmRailHint(theme, safeWidth, text.length > 0, this.chrome.getPermissionInspection?.() ?? "none"),
-        fillToken: "frameStrong",
-        rightRaw: true,
-        rightTail: theme.style("frameStrong", "\u2500", { bold: true })
-      });
-    } else if (bottomRail >= 0 && safeWidth >= MIN_HINT_WIDTH) {
-      lines[bottomRail] = rule(theme, safeWidth, {
-        right: lowerRailHint(theme, this.chrome),
-        fillToken: "frameStrong",
-        rightRaw: true,
-        rightTail: theme.style("frameStrong", "\u2500", { bold: true })
-      });
-    }
-    return lines;
-  }
-  /**
-   * Preserve paste provenance for every immediate-send binding, including the
-   * alternate paths that invoke the submit controller without an Editor Enter.
-   */
-  getTextForSubmit() {
-    const text = this.getExpandedText();
-    return this.startsWithLiteralOperator() ? guardPastedEditorOperator(text) : text;
-  }
-  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 (this.startsWithLiteralOperator() && keybindings.matches(data, "tui.input.submit")) {
-      const pastedText = this.getTextForSubmit();
-      this.pastedBangOffsets.clear();
-      this.bracketedPasteActive = false;
-      super.setText(pastedText);
-      super.handleInput(data);
-      return;
-    }
-    const completingDirectory = this.isShowingAutocomplete() && (keybindings.matches(data, "tui.input.tab") || keybindings.matches(data, "tui.select.confirm"));
-    const textBeforeCompletion = completingDirectory ? this.getText() : "";
-    super.handleInput(data);
-    if (completingDirectory && this.getText() !== textBeforeCompletion && cursorEndsDirectoryPath(this)) {
-      super.handleInput("	");
-    }
-    const textAfterInput = this.getText();
-    this.pastedBangOffsets = remapPastedBangOffsets(
-      textBeforeInput,
-      textAfterInput,
-      this.pastedBangOffsets,
-      pasteMutation
-    );
-    if (openedPaste) this.bracketedPasteActive = true;
-    if (closedPaste) this.bracketedPasteActive = false;
-    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);
-  }
-};
-
-// src/interactive/interactive-shell.ts
-init_esm_shims();
-
-// src/interactive/render-trace.ts
-init_esm_shims();
-import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { appendFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-var RENDER_TRACE_VERSION = 2;
-var INPUT_WEDGE_RING_CAPACITY = 256;
-var INPUT_WEDGE_DUMP_DIRNAME = "input-wedge";
-var INPUT_WEDGE_DUMP_RETAINED = 5;
-function createRing(capacity) {
-  const slots = [];
-  let next = 0;
-  return {
-    push(value) {
-      if (slots.length < capacity) slots.push(value);
-      else slots[next] = value;
-      next = (next + 1) % capacity;
-    },
-    toArray() {
-      if (slots.length < capacity) return [...slots];
-      return [...slots.slice(next), ...slots.slice(0, next)];
-    }
-  };
-}
-function classifyInputWedge(inputIngress, frames) {
-  const newest = [...inputIngress].reverse().find((record) => record.visualExpected) ?? inputIngress.at(-1);
-  if (newest === void 0) return "no-input-recorded";
-  return frames.some((frame2) => frame2.inputHighWater >= newest.inputSeq) ? "input-committed" : "input-not-committed";
-}
-function writeInputWedgeDump(stateDir, snapshot) {
-  const directory = join(stateDir, INPUT_WEDGE_DUMP_DIRNAME);
-  mkdirSync(directory, { recursive: true });
-  const stamp = new Date(snapshot.atEpochMs).toISOString().replace(/[:.]/gu, "-");
-  const path = join(directory, `${stamp}-${snapshot.pid}.json`);
-  writeFileSync(path, `${JSON.stringify(snapshot, null, 2)}
-`, "utf8");
-  try {
-    const existing = readdirSync(directory).filter((name) => name.endsWith(".json")).sort();
-    for (const name of existing.slice(0, Math.max(0, existing.length - INPUT_WEDGE_DUMP_RETAINED))) {
-      rmSync(join(directory, name), { force: true });
-    }
-  } catch {
-  }
-  return path;
-}
-function createAsyncTraceWriter(path, options = {}) {
-  const maxRecords = options.maxRecords ?? 4096;
-  const batchRecords = options.batchRecords ?? 128;
-  const append = options.append ?? ((target, payload) => appendFile(target, payload, "utf8"));
-  const recordTime = options.recordTime ?? (() => performance.now());
-  const appendTimeoutMs = options.appendTimeoutMs ?? 5e3;
-  const pending = [];
-  let dropped = 0;
-  let inFlight = false;
-  let scheduled = false;
-  let failed = false;
-  let closing = false;
-  let closePromise = null;
-  let resolveClose = null;
-  const settleClose = () => {
-    if (closing && !inFlight && pending.length === 0) resolveClose?.();
-  };
-  const pump = () => {
-    scheduled = false;
-    if (failed || inFlight || pending.length === 0) {
-      settleClose();
-      return;
-    }
-    inFlight = true;
-    const payload = pending.splice(0, batchRecords).join("");
-    let appendTimer = null;
-    const appendDeadline = new Promise((_resolve, reject) => {
-      appendTimer = setTimeout(() => reject(new Error("render trace append timed out")), appendTimeoutMs);
-    });
-    void Promise.race([append(path, payload), appendDeadline]).catch(() => {
-      failed = true;
-      pending.length = 0;
-    }).finally(() => {
-      if (appendTimer) clearTimeout(appendTimer);
-      inFlight = false;
-      if (pending.length > 0 && !failed) queueMicrotask(pump);
-      else settleClose();
-    });
-  };
-  const schedule = () => {
-    if (scheduled || inFlight || failed) return;
-    scheduled = true;
-    queueMicrotask(pump);
-  };
-  return {
-    enqueue(record) {
-      if (failed || closing) return;
-      if (pending.length >= maxRecords) {
-        pending.shift();
-        dropped += 1;
-      }
-      pending.push(`${JSON.stringify(record)}
-`);
-      schedule();
-    },
-    close() {
-      if (closePromise) return closePromise;
-      if (dropped > 0 && !failed) {
-        pending.push(
-          `${JSON.stringify({ type: "trace_drop", version: RENDER_TRACE_VERSION, at: recordTime(), records: dropped })}
-`
-        );
-      }
-      closing = true;
-      closePromise = new Promise((resolve) => {
-        resolveClose = resolve;
-      });
-      if (failed) {
-        pending.length = 0;
-        resolveClose?.();
-      } else {
-        schedule();
-        settleClose();
-      }
-      return closePromise;
-    }
-  };
-}
-function rounded(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
-function graphemeCount(text) {
-  const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-  let count = 0;
-  for (const _part of segmenter.segment(text)) count += 1;
-  return count;
-}
-function renderTracePath(env = process.env) {
-  const raw = env.CLIO_CODER_RENDER_TRACE?.trim();
-  return raw && raw.length > 0 ? raw : null;
-}
-function createRenderTrace(path, now = () => performance.now(), writerOptions = {}) {
-  if (path !== null) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, "", "utf8");
-  }
-  const openedAt = now();
-  const openedAtEpochMs = Date.now();
-  const at = () => rounded(now() - openedAt);
-  const writer = path === null ? null : createAsyncTraceWriter(path, { ...writerOptions, recordTime: at });
-  const inputRing = createRing(INPUT_WEDGE_RING_CAPACITY);
-  const frameRing = createRing(INPUT_WEDGE_RING_CAPACITY);
-  let frameSeq = 0;
-  let writeSeq = 0;
-  let eventSeq = 0;
-  let inputSeq = 0;
-  let generation = 0;
-  let panelHighWater = 0;
-  let inputHighWater = 0;
-  let queueDepth = 0;
-  let currentFrame = null;
-  let pendingPanel = null;
-  let lastCommitAt = null;
-  let firstCommitListener = null;
-  let firstCommitDelivered = false;
-  const ranges = /* @__PURE__ */ new Map();
-  const pendingDrains = /* @__PURE__ */ new Map();
-  writer?.enqueue({ type: "trace_start", version: RENDER_TRACE_VERSION, at: 0 });
-  const trace = {
-    recordPanelRender(metrics) {
-      pendingPanel = metrics;
-    },
-    beginGeneration() {
-      generation += 1;
-      ranges.clear();
-    },
-    recordVisibleEvent(fields) {
-      eventSeq += 1;
-      if (writer === null) return eventSeq;
-      const key = `${generation}:${fields.kind}:${fields.contentIndex}`;
-      const previous = ranges.get(key) ?? { codeUnits: 0, graphemes: 0 };
-      const graphemes = graphemeCount(fields.delta);
-      const next = { codeUnits: previous.codeUnits + fields.delta.length, graphemes: previous.graphemes + graphemes };
-      ranges.set(key, next);
-      writer?.enqueue({
-        type: "event_ingress",
-        version: RENDER_TRACE_VERSION,
-        eventSeq,
-        generation,
-        kind: fields.kind,
-        contentIndex: fields.contentIndex,
-        at: at(),
-        codeUnitStart: previous.codeUnits,
-        codeUnitEnd: next.codeUnits,
-        graphemeStart: previous.graphemes,
-        graphemeEnd: next.graphemes,
-        bytes: Buffer.byteLength(fields.delta, "utf8")
-      });
-      return eventSeq;
-    },
-    recordQueue(sequence, action) {
-      queueDepth = Math.max(0, queueDepth + (action === "admit" ? 1 : -1));
-      writer?.enqueue({
-        type: "queue",
-        version: RENDER_TRACE_VERSION,
-        eventSeq: sequence,
-        action,
-        at: at(),
-        depth: queueDepth
-      });
-    },
-    recordPanelApplied(sequence) {
-      panelHighWater = Math.max(panelHighWater, sequence);
-      writer?.enqueue({
-        type: "panel",
-        version: RENDER_TRACE_VERSION,
-        eventSeq: sequence,
-        at: at(),
-        highWater: panelHighWater
-      });
-    },
-    recordInputIngress(action, bytes, visualExpected = action !== "no-visual-change") {
-      inputSeq += 1;
-      if (visualExpected) inputHighWater = inputSeq;
-      const record = {
-        type: "input_ingress",
-        version: RENDER_TRACE_VERSION,
-        inputSeq,
-        action,
-        at: at(),
-        bytes,
-        visualExpected
-      };
-      inputRing.push(record);
-      writer?.enqueue(record);
-      return inputSeq;
-    },
-    beginFrame(fields) {
-      frameSeq += 1;
-      const frame2 = {
-        frameId: frameSeq,
-        ...fields,
-        beginAt: at(),
-        panelHighWater,
-        inputHighWater,
-        panel: pendingPanel,
-        phases: { component: 0, overlay: 0, normalization: 0, cursor: 0 },
-        commits: []
-      };
-      pendingPanel = null;
-      currentFrame = frame2;
-      return frame2;
-    },
-    endFrame(frameToken) {
-      const frame2 = frameToken;
-      const endAt = at();
-      const terminalEnqueueMs = frame2.commits.reduce((sum, commit) => sum + commit.enqueueMs, 0);
-      const measured = frame2.phases.component + frame2.phases.overlay + frame2.phases.normalization + frame2.phases.cursor + terminalEnqueueMs;
-      const record = {
-        type: "frame",
-        version: RENDER_TRACE_VERSION,
-        frameId: frame2.frameId,
-        mode: frame2.mode,
-        columns: frame2.columns,
-        rows: frame2.rows,
-        beginAt: frame2.beginAt,
-        endAt,
-        durationMs: rounded(Math.max(0, endAt - frame2.beginAt)),
-        sinceLastCommitMs: lastCommitAt === null || frame2.commits.length === 0 ? null : rounded(Math.max(0, (frame2.commits[0]?.at ?? endAt) - lastCommitAt)),
-        panelHighWater: frame2.panelHighWater,
-        inputHighWater: frame2.inputHighWater,
-        panel: frame2.panel,
-        pipeline: {
-          componentMs: rounded(frame2.phases.component),
-          overlayCompositionMs: rounded(frame2.phases.overlay),
-          normalizationMs: rounded(frame2.phases.normalization),
-          cursorExtractionMs: rounded(frame2.phases.cursor),
-          viewportDiffAnsiCursorMs: rounded(Math.max(0, endAt - frame2.beginAt - measured)),
-          terminalEnqueueMs: rounded(terminalEnqueueMs)
-        },
-        commits: frame2.commits
-      };
-      writer?.enqueue(record);
-      if (frame2.commits.length > 0) {
-        frameRing.push(record);
-        lastCommitAt = frame2.commits.at(-1)?.at ?? endAt;
-        if (!firstCommitDelivered) {
-          firstCommitDelivered = true;
-          firstCommitListener?.(frame2.frameId);
-        }
-      }
-      if (currentFrame === frame2) currentFrame = null;
-    },
-    beginPhase(_frame, _phase) {
-      return now();
-    },
-    endPhase(frameToken, phase, phaseToken) {
-      const frame2 = frameToken;
-      frame2.phases[phase] += Math.max(0, now() - phaseToken);
-    },
-    beginComponentRender() {
-      return currentFrame ? now() : null;
-    },
-    endComponentRender(token) {
-      if (currentFrame === null || token === null) return;
-      currentFrame.phases.component += Math.max(0, now() - token);
-    },
-    recordTerminalWrite(fields) {
-      writeSeq += 1;
-      const frameId = currentFrame?.frameId ?? null;
-      const commit = {
-        writeId: writeSeq,
-        at: at(),
-        bytes: fields.bytes,
-        enqueueMs: rounded(fields.enqueueMs),
-        returned: fields.returned,
-        backpressured: !fields.returned
-      };
-      currentFrame?.commits.push(commit);
-      if (writer === null) return writeSeq;
-      writer.enqueue({ type: "terminal_write", version: RENDER_TRACE_VERSION, frameId, ...commit });
-      if (!fields.returned) pendingDrains.set(writeSeq, { frameId, at: commit.at });
-      return writeSeq;
-    },
-    recordTerminalDrain(writeId) {
-      const pending = pendingDrains.get(writeId);
-      if (!pending) return;
-      pendingDrains.delete(writeId);
-      const drainAt = at();
-      writer?.enqueue({
-        type: "terminal_drain",
-        version: RENDER_TRACE_VERSION,
-        writeId,
-        frameId: pending.frameId,
-        at: drainAt,
-        waitMs: rounded(Math.max(0, drainAt - pending.at))
-      });
-    },
-    currentFrameId: () => currentFrame?.frameId ?? null,
-    onFirstFrameCommit(listener) {
-      firstCommitListener = listener;
-    },
-    snapshotInputWedge() {
-      const inputIngress = inputRing.toArray();
-      const frames = frameRing.toArray();
-      const nowAt = at();
-      const lastIngressAt = inputIngress.at(-1)?.at;
-      const lastFrame = frames.at(-1);
-      const lastFrameCommitAt = lastFrame?.commits.at(-1)?.at ?? lastFrame?.endAt;
-      return {
-        version: RENDER_TRACE_VERSION,
-        capacity: INPUT_WEDGE_RING_CAPACITY,
-        pid: process.pid,
-        openedAtEpochMs,
-        atEpochMs: Date.now(),
-        at: nowAt,
-        classification: classifyInputWedge(inputIngress, frames),
-        msSinceLastInputIngress: lastIngressAt === void 0 ? null : rounded(nowAt - lastIngressAt),
-        msSinceLastCommittedFrame: lastFrameCommitAt === void 0 ? null : rounded(nowAt - lastFrameCommitAt),
-        inputIngress,
-        frames
-      };
-    },
-    close: () => writer?.close() ?? Promise.resolve()
-  };
-  return trace;
-}
-function traceComponentRenders(component, trace) {
-  const original = component.render;
-  const wrapped = function(width) {
-    const token = trace.beginComponentRender();
-    try {
-      return original.call(this, width);
-    } finally {
-      trace.endComponentRender(token);
-    }
-  };
-  component.render = wrapped;
-  return () => {
-    if (component.render === wrapped) component.render = original;
-  };
-}
-function traceProcessStdout(trace, now = () => performance.now(), stdout = process.stdout) {
-  const original = stdout.write;
-  const pendingDrainWrites = [];
-  let drainListening = false;
-  const wrapped = function(...args) {
-    const chunk = args[0];
-    const start = now();
-    const returned = Reflect.apply(original, this, args);
-    const enqueueMs = Math.max(0, now() - start);
-    let bytes = 0;
-    try {
-      bytes = Buffer.isBuffer(chunk) ? chunk.byteLength : ArrayBuffer.isView(chunk) ? chunk.byteLength : Buffer.byteLength(String(chunk), typeof args[1] === "string" ? args[1] : "utf8");
-    } catch {
-      bytes = Buffer.byteLength(String(chunk), "utf8");
-    }
-    const writeId = trace.recordTerminalWrite({ bytes, enqueueMs, returned });
-    if (!returned) {
-      pendingDrainWrites.push(writeId);
-      if (!drainListening) {
-        drainListening = true;
-        stdout.once("drain", () => {
-          drainListening = false;
-          for (const pendingWriteId of pendingDrainWrites.splice(0)) trace.recordTerminalDrain(pendingWriteId);
-        });
-      }
-    }
-    return returned;
-  };
-  stdout.write = wrapped;
-  return () => {
-    if (stdout.write === wrapped) stdout.write = original;
-  };
-}
-
-// src/interactive/stdout-backpressure.ts
-init_esm_shims();
-function installStdoutBackpressureGate(stdout = process.stdout) {
-  const original = stdout.write;
-  const listeners = /* @__PURE__ */ new Set();
-  let blocked = false;
-  let observed = false;
-  let restored = false;
-  let drainListening = false;
-  const notifyWritable = () => {
-    drainListening = false;
-    if (!blocked) return;
-    blocked = false;
-    for (const listener of [...listeners]) listener();
-  };
-  const listenForDrain = () => {
-    if (drainListening || restored) return;
-    drainListening = true;
-    stdout.once("drain", notifyWritable);
-  };
-  const wrapped = function(...args) {
-    const returned = Reflect.apply(original, this, args);
-    if (!returned) {
-      observed = true;
-      blocked = true;
-      listenForDrain();
-    }
-    return returned;
-  };
-  stdout.write = wrapped;
-  return {
-    get blocked() {
-      return blocked;
-    },
-    get observed() {
-      return observed;
-    },
-    onWritable(listener) {
-      if (restored || !blocked) {
-        queueMicrotask(listener);
-        return () => {
-        };
-      }
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    whenWritable(timeoutMs) {
-      if (restored || !blocked) return Promise.resolve(true);
-      return new Promise((resolve) => {
-        let timer;
-        const release = this.onWritable(() => {
-          if (timer) clearTimeout(timer);
-          release();
-          resolve(true);
-        });
-        if (timeoutMs !== void 0 && Number.isFinite(timeoutMs) && timeoutMs >= 0) {
-          timer = setTimeout(() => {
-            release();
-            resolve(false);
-          }, timeoutMs);
-        }
-      });
-    },
-    restore() {
-      if (restored) return;
-      restored = true;
-      blocked = false;
-      if (drainListening) {
-        stdout.off("drain", notifyWritable);
-        drainListening = false;
-      }
-      if (stdout.write === wrapped) stdout.write = original;
-      for (const listener of [...listeners]) listener();
-      listeners.clear();
-    }
-  };
-}
-
-// src/interactive/interactive-shell.ts
-var KEEP_ALIVE_INTERVAL_MS = 1 << 30;
-function createInteractiveShell(deps) {
-  const terminal = deps.createTerminal();
-  const tui = deps.createTui(terminal);
-  const scheduleInterval = deps.scheduleInterval ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
-  const clearScheduledInterval = deps.clearScheduledInterval ?? ((handle) => clearInterval(handle));
-  let mounted = false;
-  let keepAlive = null;
-  let resolveRun = null;
-  let run = null;
-  let completedCode = null;
-  let stopped = false;
-  let stopSettlement = null;
-  return {
-    terminal,
-    tui,
-    mount(root, focus) {
-      if (mounted) return;
-      mounted = true;
-      deps.prepareRoot?.(root);
-      tui.addChild(root);
-      if (tui.mode === "fullscreen") tui.setLayoutRoot?.(root);
-      tui.setFocus(focus);
-      tui.start();
-    },
-    anchor() {
-      if (run) return run;
-      run = new Promise((resolve) => {
-        resolveRun = resolve;
-        if (completedCode !== null) resolve(completedCode);
-      });
-      keepAlive = scheduleInterval(() => {
-      }, KEEP_ALIVE_INTERVAL_MS);
-      return run;
-    },
-    releaseAnchor() {
-      if (!keepAlive) return;
-      clearScheduledInterval(keepAlive);
-      keepAlive = null;
-    },
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      try {
-        tui.stop();
-      } catch {
-      } finally {
-        try {
-          stopSettlement = Promise.resolve(deps.onStop?.()).then(() => void 0);
-        } catch {
-          stopSettlement = Promise.resolve();
-        }
-      }
-    },
-    async commitCurrentFrame() {
-      if (!tui.renderNow) {
-        tui.requestRender();
-        return null;
-      }
-      tui.renderNow(false);
-      return null;
-    },
-    hasObservedBackpressure: () => false,
-    setStreamPacingActive: () => {
-    },
-    settle() {
-      return stopSettlement ?? Promise.resolve();
-    },
-    nextCommittedFrame() {
-      return Promise.resolve(null);
-    },
-    complete(code) {
-      if (completedCode !== null) return;
-      completedCode = code;
-      resolveRun?.(code);
-    }
-  };
-}
-var activeRenderTrace = null;
-function getActiveRenderTrace() {
-  return activeRenderTrace;
-}
-async function settleLatestInteractiveFrame(gate, timeoutMs, renderFrame) {
-  const writableBeforeRender = gate ? await gate.whenWritable(timeoutMs) : true;
-  const frameId = await renderFrame();
-  if (writableBeforeRender && gate) await gate.whenWritable(timeoutMs);
-  return frameId;
-}
-function createProcessInteractiveShell(options = {}) {
-  const tracePath = renderTracePath();
-  let restoreStdout = null;
-  let restoreFirstFrameStdout = null;
-  let restoreRoot = null;
-  let backpressure = null;
-  let observedBackpressure = false;
-  let candidate = null;
-  try {
-    candidate = createRenderTrace(tracePath);
-    restoreStdout = traceProcessStdout(candidate);
-    activeRenderTrace = candidate;
-  } catch {
-    restoreStdout?.();
-    restoreStdout = null;
-    void candidate?.close().catch(() => {
-    });
-    activeRenderTrace = null;
-  }
-  const trace = activeRenderTrace;
-  if (trace && options.onFirstFrameCommit) trace.onFirstFrameCommit(options.onFirstFrameCommit);
-  let firstFrameDelivered = false;
-  let firstFrameSeq = 0;
-  let firstFrameActive = false;
-  let firstFrameWrote = false;
-  if (!trace && options.onFirstFrameCommit) {
-    const stdout = process.stdout;
-    const original = stdout.write;
-    const wrapped = function(...args) {
-      const returned = Reflect.apply(original, this, args);
-      if (firstFrameActive) firstFrameWrote = true;
-      return returned;
-    };
-    stdout.write = wrapped;
-    restoreFirstFrameStdout = () => {
-      if (stdout.write === wrapped) stdout.write = original;
-    };
-  }
-  const firstFrameOnlyObserver = {
-    isEnabled: () => !firstFrameDelivered,
-    beginFrame: () => {
-      firstFrameSeq += 1;
-      firstFrameActive = true;
-      firstFrameWrote = false;
-      return firstFrameSeq;
-    },
-    endFrame: (frame2) => {
-      firstFrameActive = false;
-      if (firstFrameDelivered || !firstFrameWrote) return;
-      firstFrameDelivered = true;
-      options.onFirstFrameCommit?.(frame2);
-      restoreFirstFrameStdout?.();
-      restoreFirstFrameStdout = null;
-    },
-    beginPhase: () => null,
-    endPhase: () => {
-    }
-  };
-  const primaryObserver = trace ?? (options.onFirstFrameCommit ? firstFrameOnlyObserver : null);
-  let committedFrameSequence = 0;
-  const frameWaiters = [];
-  const renderObserver = {
-    isEnabled: () => frameWaiters.length > 0 || primaryObserver !== null && (primaryObserver.isEnabled?.() ?? true),
-    beginFrame: (fields) => ({
-      primary: primaryObserver?.beginFrame(fields),
-      primaryActive: primaryObserver !== null && (primaryObserver.isEnabled?.() ?? true),
-      frameId: ++committedFrameSequence
-    }),
-    endFrame: (token) => {
-      const frame2 = token;
-      if (frame2.primaryActive) primaryObserver?.endFrame(frame2.primary);
-      for (const waiter of frameWaiters.splice(0)) waiter.resolve(frame2.frameId);
-    },
-    beginPhase: (token, phase) => {
-      const frame2 = token;
-      return frame2.primaryActive ? primaryObserver?.beginPhase(frame2.primary, phase) : null;
-    },
-    endPhase: (token, phase, phaseToken) => {
-      const frame2 = token;
-      if (frame2.primaryActive) primaryObserver?.endPhase(frame2.primary, phase, phaseToken);
-    }
-  };
-  const renderAdmission = {
-    get blocked() {
-      return backpressure?.blocked ?? false;
-    },
-    onWritable(listener) {
-      if (backpressure) return backpressure.onWritable(listener);
-      queueMicrotask(listener);
-      return () => {
-      };
-    }
-  };
-  const setStreamPacingActive = (active) => {
-    if (active) {
-      backpressure ??= installStdoutBackpressureGate();
-      return;
-    }
-    if (!backpressure) return;
-    observedBackpressure ||= backpressure.observed;
-    backpressure.restore();
-    backpressure = null;
-  };
-  let instrumentationCleanupStarted = false;
-  let instrumentationCleanupPromise = Promise.resolve();
-  const cleanupInstrumentation = () => {
-    if (instrumentationCleanupStarted) return instrumentationCleanupPromise;
-    instrumentationCleanupStarted = true;
-    const errors = [];
-    const attempt = (operation) => {
-      try {
-        operation();
-      } catch (error) {
-        errors.push(error);
-      }
-    };
-    attempt(() => setStreamPacingActive(false));
-    attempt(() => restoreRoot?.());
-    restoreRoot = null;
-    attempt(() => restoreStdout?.());
-    restoreStdout = null;
-    attempt(() => restoreFirstFrameStdout?.());
-    restoreFirstFrameStdout = null;
-    if (activeRenderTrace === trace) activeRenderTrace = null;
-    instrumentationCleanupPromise = (async () => {
-      if (trace) {
-        try {
-          await trace.close();
-        } catch (error) {
-          errors.push(error);
-        }
-      }
-      if (errors.length > 0) throw new AggregateError(errors, "interactive shell instrumentation cleanup failed");
-    })();
-    return instrumentationCleanupPromise;
-  };
-  let shell;
-  try {
-    setStreamPacingActive(options.streamPacingActive === true);
-    shell = createInteractiveShell({
-      createTerminal: options.testing?.createTerminal ?? (() => new ProcessTerminal()),
-      createTui: (terminal) => options.testing?.createTui?.(terminal) ?? (options.tuiMode === "fullscreen" ? new InstrumentedTuiAltScreen(terminal, renderObserver, void 0, void 0, void 0, renderAdmission) : new InstrumentedTuiMainScreen(terminal, renderObserver, void 0, void 0, renderAdmission)),
-      prepareRoot: (root) => {
-        if (trace) restoreRoot = traceComponentRenders(root, trace);
-      },
-      onStop: cleanupInstrumentation
-    });
-  } catch (error) {
-    void cleanupInstrumentation().catch(() => {
-    });
-    throw error;
-  }
-  return {
-    ...shell,
-    nextCommittedFrame() {
-      return new Promise((resolve) => {
-        frameWaiters.push({ resolve });
-      });
-    },
-    async commitCurrentFrame(timeoutMs = 3e4) {
-      return await settleLatestInteractiveFrame(backpressure, timeoutMs, async () => {
-        const tui = shell.tui;
-        const waiter = { resolve: () => {
-        } };
-        const frame2 = new Promise((resolve) => {
-          waiter.resolve = resolve;
-          frameWaiters.push(waiter);
-        });
-        try {
-          tui.renderNow(false);
-        } catch (error) {
-          const index = frameWaiters.indexOf(waiter);
-          if (index >= 0) frameWaiters.splice(index, 1);
-          throw error;
-        }
-        return await frame2;
-      });
-    },
-    hasObservedBackpressure: () => observedBackpressure || backpressure?.observed === true,
-    setStreamPacingActive
-  };
-}
-
-// 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",
-    scope: "composer",
-    kind: "toggle",
-    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);
-}
-
-export {
-  SelectList2 as SelectList,
-  createAgentProgress,
-  SGR_RESET,
-  SGR_DIM,
-  fgSequence,
-  isClioToken,
-  paintHex,
-  GLYPH,
-  spinnerFrame,
-  brandMark,
-  dotSep,
-  barSep,
-  sectionTag,
-  screenTitle,
-  listGroupHeader,
-  joinChips,
-  joinSections,
-  markdownTheme,
-  selectListTheme,
-  editorTheme,
-  fitIdentityLabel,
-  abbreviateModelId,
-  formatTargetLabel,
-  formatCompactMs,
-  formatContextPercent,
-  collapseHomePath,
-  padAnsi,
-  fitUnits,
-  rule,
-  frame,
-  innerDivider,
-  clioTheme,
-  MUTATION_PREVIEW_KEY,
-  PERMISSION_TERMS_KEY,
-  permissionHintEntries,
-  keyboardOwner,
-  focusedComponent,
-  localKey,
-  DEFAULT_SELECT_THEME,
-  FocusBox,
-  clioError,
-  fitHintEntries,
-  FILTER_HINT,
-  buildHint,
-  buildResponsiveHint,
-  formatRuntimeResolutionDiagnostic,
-  diagnosticSeverityToken,
-  showClioOverlayFrame,
-  unguardPastedEditorOperator,
-  parseEditorBashCommand,
-  bashExecutionEntryInput,
-  CLIO_APP_KEYBINDING_IDS,
-  ClioEditor,
-  writeInputWedgeDump,
-  getActiveRenderTrace,
-  createProcessInteractiveShell,
-  validateKeybindings,
-  formatInvalidKeybindingNotice,
-  detectTerminalKeySupport,
-  detectPlatformKeybindingWarnings,
-  formatPlatformKeybindingNotice,
-  createKeybindingManager
-};
-//# sourceMappingURL=chunk-M6YLF66Z.js.map