@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-MAW544W2.js

@@ -0,0 +1,1882 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/tui.ts
+init_esm_shims();
+import {
+  Box,
+  CombinedAutocompleteProvider,
+  Container,
+  Editor,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  isKeyRelease,
+  KeybindingsManager,
+  Markdown,
+  Marked,
+  matchesKey,
+  ProcessTerminal,
+  ScrollView,
+  setKeybindings,
+  stripTerminalSequences,
+  Text,
+  TUI_KEYBINDINGS,
+  TuiAltScreen as TuiAltScreen2,
+  TuiMainScreen as TuiMainScreen2,
+  truncateToWidth,
+  VStack,
+  visibleWidth,
+  wrapTextWithAnsi
+} from "@earendil-works/pi-tui";
+
+// src/engine/instrumented-tui.ts
+init_esm_shims();
+import { TuiAltScreen, TuiMainScreen } from "@earendil-works/pi-tui";
+var DeferredRenderAdmission = class {
+  constructor(admission, render) {
+    this.admission = admission;
+    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();
+import {
+  SelectList as EngineSelectList
+} from "@earendil-works/pi-tui";
+var PI_SELECT_CURSOR = "\u2192";
+var ESC = String.fromCharCode(27);
+var LEADING_CURSOR_PATTERN = new RegExp(`^((?:${ESC}\\[[0-9;]*m)*)${PI_SELECT_CURSOR} `);
+var SelectList = class extends EngineSelectList {
+  designCursor;
+  constructor(items, maxVisible, theme, layout) {
+    super(items, maxVisible, theme, layout);
+    this.designCursor = theme.cursor;
+  }
+  render(width) {
+    const lines = super.render(width);
+    const cursor = this.designCursor;
+    if (!cursor || cursor === PI_SELECT_CURSOR) return lines;
+    return lines.map((line) => line.replace(LEADING_CURSOR_PATTERN, `$1${cursor} `));
+  }
+};
+
+// src/engine/tui.ts
+function createAgentProgress(terminal) {
+  let active = false;
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      terminal.setProgress(true);
+    },
+    stop() {
+      if (!active) return;
+      active = false;
+      terminal.setProgress(false);
+    },
+    isActive() {
+      return active;
+    }
+  };
+}
+
+// src/interactive/theme/glyphs.ts
+init_esm_shims();
+var GLYPH = {
+  // Clio wordmark, shown in the welcome and dashboard headers only.
+  brand: ">C_",
+  // Agent voice glyph for the chat reply prefix. It renders in accent on a
+  // normal turn and error red on a failed one. The `>C_` wordmark is no longer
+  // the reply prefix; it survives only in the two headers above.
+  agent: "\u2726",
+  user: "\u203A",
+  // Selection focus marker for list overlays. It is deliberately distinct from
+  // the tool ledger's toolHeader so a focused row never reads as a tool line.
+  cursor: "\u276F",
+  toolHeader: "\u25B8",
+  running: "\u25CF",
+  queued: "\u25CC",
+  speed: "\u26A1",
+  ok: "\u2713",
+  error: "\u2717",
+  cancelled: "\u2298",
+  active: "\u25C6",
+  scoped: "\u25C7",
+  up: "\u2191",
+  down: "\u2193",
+  rail: "\u2502",
+  innerDivider: "\u254C",
+  barFull: "\u2588",
+  barEmpty: "\u2591",
+  contextFull: "\u25B0",
+  contextFree: "\u25B1",
+  // Autocompact reserve cells: held-back headroom is neither used nor free,
+  // so it carries its own glyph and never reads as filled when only color is
+  // lost. The medium-shade block is single-width in the same fonts that carry
+  // the barFull/barEmpty fallbacks.
+  contextReserve: "\u2592",
+  info: "\u2139",
+  warn: "\u26A0",
+  warnInline: "!",
+  phaseWaiting: "\u25D4",
+  phaseThinking: "\u25D0",
+  phaseWriting: "\u25D1",
+  phaseTool: "\u2699",
+  phaseBlocked: "\u23F8",
+  phaseRetry: "\u21BB",
+  phaseCompact: "\u267B",
+  phaseDispatch: "\u21F2",
+  // Marks a run that Clio started for itself (a shadow worker or an internal
+  // harness run) so internal activity reads as a sub-process of the current
+  // turn. It replaces the old `sh:`/`in:` agent-name prefixes; the two
+  // audiences are told apart by tone, not by a second glyph.
+  subProcess: "\u21B3",
+  // Who asked for a dispatched run. Hollow is the operator's own (/run,
+  // /delegate); filled is one the model started by calling a dispatch tool.
+  // The transcript block, the board row, and the footer count share the pair,
+  // so a running ◇ anywhere is work the operator started themselves.
+  workerHuman: "\u25C7",
+  workerAgent: "\u25C6",
+  // A run neither the operator nor the model asked for: wiki documenting, a
+  // bootstrap scout, a judge. It stays off the transcript entirely, so the
+  // board is the only surface that shows it and it gets the quietest mark
+  // that still holds the origin column.
+  workerInternal: "\xB7",
+  ellipsis: "\u2026",
+  favorite: "\u2605"
+};
+var SPINNER_FRAMES = ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"];
+function spinnerFrame(tick) {
+  const index = (tick % SPINNER_FRAMES.length + SPINNER_FRAMES.length) % SPINNER_FRAMES.length;
+  return SPINNER_FRAMES[index] ?? SPINNER_FRAMES[0];
+}
+
+// src/interactive/theme/index.ts
+init_esm_shims();
+
+// src/interactive/theme/tokens.ts
+init_esm_shims();
+var TOKENS = {
+  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` : ""
+  };
+}
+
+// src/interactive/theme/components.ts
+init_esm_shims();
+
+// src/interactive/theme/segments.ts
+init_esm_shims();
+function present(parts) {
+  return parts.filter((part) => typeof part === "string" && part.length > 0);
+}
+function brandMark(theme) {
+  const prompt = GLYPH.brand.slice(0, 1);
+  const initial = GLYPH.brand.slice(1, 2);
+  const cursor = GLYPH.brand.slice(2, 3);
+  return `${theme.fg("dim", prompt)}${theme.style("accent", initial, { bold: true })}${theme.fg("dim", cursor)}`;
+}
+function dotSep(theme) {
+  return theme.fg("dim", " \xB7 ");
+}
+function barSep(theme) {
+  return theme.fg("frame", " \u2502 ");
+}
+function sectionTag(theme, token, label, pad = 0) {
+  const text = pad > 0 ? label.padEnd(pad) : label;
+  return theme.style(token, text, { bold: true });
+}
+function screenTitle(theme, label) {
+  return theme.style("title", label, { bold: true });
+}
+function listGroupHeader(theme, label) {
+  return theme.fg("dim", `\u2500\u2500 ${label}`);
+}
+function joinChips(theme, parts) {
+  return present(parts).join(dotSep(theme));
+}
+function joinSections(theme, parts) {
+  return present(parts).join(barSep(theme));
+}
+
+// src/interactive/theme/components.ts
+var identity = (text) => text;
+function markdownTheme(theme, highlightCode) {
+  return {
+    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();
+function abbreviateModelId(modelId) {
+  const base = (modelId ?? "").trim().split("/").filter(Boolean).pop() ?? "";
+  if (base.length === 0) return "model";
+  const parts = base.split("-").filter((part) => part.length > 0);
+  if (parts.length <= 1) return base.length > 18 ? base.slice(0, 18) : base;
+  const kept = [];
+  for (const part of parts) {
+    const next = [...kept, part].join("-");
+    if (kept.length > 0 && next.length > 18) break;
+    kept.push(part);
+  }
+  const joined = kept.join("-");
+  return joined.length > 18 ? joined.slice(0, 18) : joined;
+}
+function formatTargetLabel(targetId, modelId, options = {}) {
+  const target = (targetId ?? "").trim();
+  const model = (modelId ?? "").trim();
+  if (target.length === 0 && model.length === 0) return "not configured";
+  const shown = options.abbreviate === false ? model : abbreviateModelId(model);
+  if (target.length === 0) return `no target \xB7 ${shown}`;
+  if (model.length === 0) return `${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();
+var REVERSE_VIDEO_BLANK = `${String.fromCharCode(27)}[7m ${String.fromCharCode(27)}[0m`;
+var EMPTY_PROMPT = "Ask Clio\u2026  / for commands";
+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) {
+  return `${theme.fg("dim", chrome.getModelLabel())} ${theme.fg("dim", "\xB7")} ${styledThinkingHint(theme, chrome.getThinkingLabel())}`;
+}
+function composerMode(chrome, text) {
+  if (!(chrome.isStreaming?.() ?? false)) 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?.() ?? "Shift+Enter"} newline`
+  );
+}
+function renderEmptyPrompt(line, width, theme) {
+  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", EMPTY_PROMPT), 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;
+}
+var ClioEditor = class extends Editor {
+  constructor(tui, chrome) {
+    super(tui, editorTheme(clioTheme()));
+    this.chrome = chrome;
+  }
+  chrome;
+  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(mode === "STEER" ? "action" : "accentDeep", mode, { bold: true });
+      lines[0] = truncateToWidth(`${modeLabel} ${lines[0] ?? ""}`, safeWidth, "", true);
+    } else {
+      lines[0] = rule(theme, safeWidth, {
+        left: mode,
+        leftToken: mode === "STEER" ? "action" : "accentDeep",
+        right: styledRailLabel(theme, this.chrome),
+        fillToken: "frameStrong",
+        rightRaw: true,
+        rightTail: theme.style("frameStrong", "\u2500", { bold: true })
+      });
+    }
+    if (text.length === 0 && lines[1]) lines[1] = renderEmptyPrompt(lines[1], safeWidth, theme);
+    const bottomRail = findBottomRail(lines, safeWidth);
+    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;
+  }
+  /**
+   * pi-tui's bracketed-paste handling inserts pasted text (including a
+   * trailing newline the paste carried) without submitting: a pasted
+   * `/model\n` lands as two lines in the buffer and just sits there. Once
+   * the base handler has applied a chunk that closed a paste, check whether
+   * the buffer now reads as a completed slash command and, if so, submit it
+   * through the same handler the typed-Enter path uses.
+   */
+  handleInput(data) {
+    const closedPaste = data.includes("\x1B[201~");
+    super.handleInput(data);
+    if (!closedPaste) return;
+    const text = this.getText();
+    if (!text.endsWith("\n")) return;
+    const command = text.trimEnd();
+    if (!command.startsWith("/")) return;
+    this.setText("");
+    this.onSubmit?.(command);
+  }
+};
+
+// src/interactive/interactive-shell.ts
+init_esm_shims();
+
+// src/interactive/render-trace.ts
+init_esm_shims();
+import { mkdirSync, writeFileSync } from "node:fs";
+import { appendFile } from "node:fs/promises";
+import { dirname } from "node:path";
+var RENDER_TRACE_VERSION = 2;
+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 = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, "", "utf8");
+  const openedAt = now();
+  const at = () => rounded(now() - openedAt);
+  const writer = createAsyncTraceWriter(path, { ...writerOptions, recordTime: at });
+  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;
+      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;
+      writer.enqueue({
+        type: "input_ingress",
+        version: RENDER_TRACE_VERSION,
+        inputSeq,
+        action,
+        at: at(),
+        bytes,
+        visualExpected
+      });
+      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) {
+        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);
+      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;
+    },
+    close: () => writer.close()
+  };
+  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;
+  if (tracePath) {
+    let candidate = null;
+    try {
+      candidate = createRenderTrace(tracePath);
+      restoreStdout = traceProcessStdout(candidate);
+      activeRenderTrace = candidate;
+    } catch {
+      restoreStdout?.();
+      restoreStdout = null;
+      void candidate?.close().catch(() => {
+      });
+      activeRenderTrace = null;
+    }
+  } else 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.thinking.cycle": {
+    defaultKeys: "shift+tab",
+    description: "Cycle orchestrator thinking level"
+  },
+  "clio.exit": {
+    defaultKeys: "ctrl+d",
+    description: "Exit when the editor is empty"
+  },
+  "clio.status.toggle": {
+    defaultKeys: "alt+u",
+    description: "Toggle the footer dashboard (compact / expanded)"
+  },
+  "clio.session.tree": {
+    defaultKeys: "alt+t",
+    description: "Open the /tree navigator"
+  },
+  "clio.dispatchBoard.toggle": {
+    defaultKeys: "alt+w",
+    description: "Toggle the dispatch (workers) board overlay"
+  },
+  "clio.tasks.open": {
+    // Approved application-boundary override of pi-tui editor word-back.
+    defaultKeys: "alt+b",
+    description: "Open the composite session and operator task board"
+  },
+  "clio.decisions.open": {
+    // Approved application-boundary override of pi-tui editor word-delete.
+    defaultKeys: "alt+d",
+    description: "Open the settled interview decision board"
+  },
+  "clio.dispatch.background": {
+    // Ctrl+B alone is pi-tui's editor cursor-left, so the Claude Code chord
+    // cannot be the primary here. Alt+S ("send to background") keeps the app
+    // scheme and earns the Ctrl+G leader fallback, which only alt+<letter>
+    // bindings get; Ctrl+Alt+B stays for the b-for-background muscle memory.
+    defaultKeys: ["alt+s", "ctrl+alt+b"],
+    description: "Send the running attached dispatch to the background as a detached batch"
+  },
+  "clio.model.select": {
+    defaultKeys: "alt+l",
+    description: "Open the model + targets selector"
+  },
+  "clio.model.cycleForward": {
+    defaultKeys: "alt+j",
+    description: "Cycle to next scoped model"
+  },
+  "clio.model.cycleBackward": {
+    defaultKeys: "alt+k",
+    description: "Cycle to previous scoped model"
+  },
+  "clio.tool.expand": {
+    defaultKeys: "alt+o",
+    description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details (no effect while /output verbose pins them open)"
+  },
+  "clio.tool.expandAll": {
+    // Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
+    // Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
+    defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
+    description: "Fold or unfold every tool call and worker block at once (no effect while /output verbose pins them open)"
+  },
+  "clio.tool.liveOutput": {
+    defaultKeys: "alt+p",
+    description: "Toggle streaming partial tool output in expanded tool bodies"
+  },
+  "clio.thinking.expand": {
+    defaultKeys: "alt+r",
+    description: "Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)"
+  },
+  "clio.thinking.expandAll": {
+    // Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
+    // Alt+Shift+R as a distinct key event.
+    defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
+    description: "Toggle all thinking blocks between hidden markers and full bodies (no effect while /output verbose pins them open)"
+  },
+  "clio.editor.external": {
+    defaultKeys: "alt+g",
+    description: "Open the current input in an external editor"
+  },
+  "clio.message.followUp": {
+    defaultKeys: "alt+enter",
+    description: "End of turn: queue the current input for delivery when the active run settles (Enter delivers it at the next slot, between tool batches)"
+  },
+  "clio.message.interrupt": {
+    // Alt+I keeps the app scheme and earns the Ctrl+G leader fallback. A
+    // Ctrl+Enter chord was rejected because legacy terminals send it as a
+    // plain Enter, which would turn every send into a cancel.
+    defaultKeys: "alt+i",
+    description: "Interrupt: cancel the active run and deliver the current input now (refused while an attached dispatch runs or a permission ask is parked; the input then queues for the next slot)"
+  },
+  "clio.message.dequeue": {
+    defaultKeys: "alt+up",
+    description: "Restore queued steering and follow-up messages to the editor"
+  },
+  "clio.notifications.dismiss": {
+    defaultKeys: "alt+x",
+    description: "Dismiss footer notifications"
+  },
+  "clio.leader": {
+    defaultKeys: "ctrl+g",
+    description: "Start portable leader-key fallback for Alt shortcuts"
+  }
+};
+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"
+  },
+  ...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 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 (typeof value === "string") {
+      if (value.length === 0) continue;
+      if (isValidKeyId(value)) {
+        valid[id] = 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" || entry.length === 0) continue;
+        if (isValidKeyId(entry)) {
+          accepted.push(entry);
+        } else {
+          rejected.push(entry);
+        }
+      }
+      if (accepted.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" || key === "ctrl+q") return "terminal flow control may intercept this chord";
+  if (key === "ctrl+z") return "shell job control may suspend the process";
+  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.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(" / ");
+}
+function deriveLeaderTargets(inner) {
+  const targets = [];
+  for (const id of CLIO_APP_KEYBINDING_IDS) {
+    for (const key of inner.getKeys(id)) {
+      const base = altLetterBase(String(key));
+      if (base) targets.push({ key: base, id });
+    }
+  }
+  return targets;
+}
+function buildManager(inner, invalid, platformWarnings) {
+  const frozen = invalid.map((entry) => ({ id: entry.id, keys: [...entry.keys] }));
+  const frozenPlatformWarnings = platformWarnings.map((entry) => ({
+    id: entry.id,
+    keys: [...entry.keys],
+    terminal: entry.terminal,
+    reason: entry.reason,
+    source: entry.source
+  }));
+  const frozenLeaderTargets = deriveLeaderTargets(inner).map((entry) => ({ ...entry }));
+  return {
+    matches(data, id) {
+      return inner.matches(data, id);
+    },
+    getKeys(id) {
+      return inner.getKeys(id);
+    },
+    getDescription(id) {
+      return inner.getDefinition(id).description ?? "";
+    },
+    getConflicts() {
+      return inner.getConflicts();
+    },
+    overrideCount() {
+      return Object.keys(inner.getUserBindings()).length;
+    },
+    invalidCount() {
+      return frozen.reduce((sum, entry) => sum + entry.keys.length, 0);
+    },
+    invalidBindings() {
+      return frozen;
+    },
+    platformWarnings() {
+      return frozenPlatformWarnings;
+    },
+    leaderTargets() {
+      return frozenLeaderTargets;
+    },
+    hotkeyEntries() {
+      const userBindings = inner.getUserBindings();
+      return CLIO_APP_KEYBINDING_IDS.map((id) => ({
+        id,
+        keys: joinKeys(inner.getKeys(id)),
+        description: inner.getDefinition(id).description ?? "",
+        source: userBindings[id] === void 0 ? "default" : "user"
+      }));
+    }
+  };
+}
+function createKeybindingManager(settings, env = process.env) {
+  const { valid, invalid } = validateKeybindings(settings.keybindings ?? {});
+  const inner = new KeybindingsManager(CLIO_KEYBINDINGS, valid);
+  setKeybindings(inner);
+  return buildManager(inner, invalid, detectPlatformKeybindingWarnings(valid, detectTerminalKeySupport(env)));
+}
+
+export {
+  SelectList,
+  createAgentProgress,
+  Box,
+  CombinedAutocompleteProvider,
+  Container,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  isKeyRelease,
+  Markdown,
+  Marked,
+  matchesKey,
+  ScrollView,
+  stripTerminalSequences,
+  Text,
+  truncateToWidth,
+  VStack,
+  visibleWidth,
+  wrapTextWithAnsi,
+  SGR_RESET,
+  SGR_DIM,
+  fgSequence,
+  GLYPH,
+  spinnerFrame,
+  brandMark,
+  dotSep,
+  barSep,
+  sectionTag,
+  screenTitle,
+  listGroupHeader,
+  joinChips,
+  joinSections,
+  markdownTheme,
+  selectListTheme,
+  settingsListTheme,
+  abbreviateModelId,
+  formatTargetLabel,
+  formatCompactMs,
+  formatContextPercent,
+  collapseHomePath,
+  padAnsi,
+  fitUnits,
+  rule,
+  frame,
+  innerDivider,
+  clioTheme,
+  ClioEditor,
+  getActiveRenderTrace,
+  createProcessInteractiveShell,
+  validateKeybindings,
+  formatInvalidKeybindingNotice,
+  detectTerminalKeySupport,
+  detectPlatformKeybindingWarnings,
+  formatPlatformKeybindingNotice,
+  createKeybindingManager
+};
+//# sourceMappingURL=chunk-MAW544W2.js.map