@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-R2UUNSNQ.js

@@ -0,0 +1,1605 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  GLYPH,
+  InstrumentedTuiAltScreen,
+  InstrumentedTuiMainScreen,
+  brandMark,
+  clioTheme,
+  collapseHomePath,
+  editorTheme,
+  fitHintEntries,
+  formatTargetLabel,
+  padAnsi,
+  permissionHintEntries,
+  rule
+} from "./chunk-3O5JWP4L.js";
+import {
+  Editor,
+  ProcessTerminal,
+  getKeybindings,
+  stripTerminalSequences,
+  truncateToWidth,
+  visibleWidth
+} from "./chunk-6OWUM2NC.js";
+import {
+  sanitizeCallTargetText
+} from "./chunk-XNIZBOFV.js";
+import {
+  readClioVersion
+} from "./chunk-ZPST2KQO.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// 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 };
+}
+
+// src/interactive/editor-rails.ts
+init_esm_shims();
+function renderEditorRail(theme, width, options, state) {
+  const line = rule(theme, width, { ...options, fillToken: "editor" });
+  return line.replace(/─+/gu, (fill) => {
+    const tokens = ["editorAction", "editorAction", "action", "editor", "editor", "accent", "accent"];
+    const center = Math.floor(state.now % 3600 / 3600 * (fill.length + 14)) - 7;
+    let output = "";
+    let runToken = null;
+    let run = "";
+    for (let column = 0; column < fill.length; column += 1) {
+      let token = "editor";
+      if (state.phase === "attention") {
+        token = state.animate && Math.floor(state.now / 900) % 2 === 1 ? "action" : "editorAction";
+      } else if (state.phase === "working" && state.animate) {
+        const distance = Math.abs(column - center);
+        if (distance < tokens.length) token = tokens[distance] ?? "editor";
+      }
+      if (state.fullAuto && (column < 3 || column >= fill.length - 3)) token = "editorDanger";
+      if (runToken !== token && runToken !== null) {
+        output += theme.style(runToken, run, { bold: true });
+        run = "";
+      }
+      runToken = token;
+      run += "\u2501";
+    }
+    return output + (runToken ? theme.style(runToken, run, { bold: true }) : "");
+  });
+}
+
+// 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 is compacting the session context";
+function hasScrollIndicator(line) {
+  const stripped = stripTerminalSequences(line);
+  return stripped.includes(GLYPH.up) || stripped.includes(GLYPH.down);
+}
+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 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);
+    const rail = {
+      phase: mode === "CONFIRM" ? "attention" : mode === "MESSAGE" ? "idle" : "working",
+      fullAuto: this.chrome.getAutonomy?.() === "full-auto",
+      animate: text.length === 0 && process.env.CLIO_CODER_REDUCE_MOTION !== "1" && process.env.CLIO_CODER_SCREEN_READER !== "1" && process.env.TERM !== "dumb" && process.env.NO_COLOR === void 0,
+      now: this.chrome.getAnimationTime?.() ?? performance.now()
+    };
+    if (!hasScrollIndicator(lines[0] ?? "")) {
+      const exceptional = mode === "CONFIRM" || mode === "PREPARING" || mode === "COMPACTING";
+      lines[0] = renderEditorRail(
+        theme,
+        safeWidth,
+        {
+          ...exceptional ? {
+            left: rail.fullAuto ? `${mode} \xB7 FULL-AUTO` : mode,
+            leftToken: rail.fullAuto ? "editorDanger" : modeToken(mode)
+          } : rail.fullAuto ? { left: "FULL-AUTO", leftToken: "editorDanger" } : {}
+        },
+        rail
+      );
+    }
+    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] = renderEditorRail(
+        theme,
+        safeWidth,
+        {
+          right: confirmRailHint(theme, safeWidth, text.length > 0, this.chrome.getPermissionInspection?.() ?? "none"),
+          fillToken: "editor",
+          rightRaw: true,
+          rightTail: theme.style("editor", "\u2500", { bold: true })
+        },
+        rail
+      );
+    }
+    if (bottomRail >= 0 && mode !== "CONFIRM") lines[bottomRail] = renderEditorRail(theme, safeWidth, {}, rail);
+    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((frame) => frame.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 frame = {
+        frameId: frameSeq,
+        ...fields,
+        beginAt: at(),
+        panelHighWater,
+        inputHighWater,
+        panel: pendingPanel,
+        phases: { component: 0, overlay: 0, normalization: 0, cursor: 0 },
+        commits: []
+      };
+      pendingPanel = null;
+      currentFrame = frame;
+      return frame;
+    },
+    endFrame(frameToken) {
+      const frame = frameToken;
+      const endAt = at();
+      const terminalEnqueueMs = frame.commits.reduce((sum, commit) => sum + commit.enqueueMs, 0);
+      const measured = frame.phases.component + frame.phases.overlay + frame.phases.normalization + frame.phases.cursor + terminalEnqueueMs;
+      const record = {
+        type: "frame",
+        version: RENDER_TRACE_VERSION,
+        frameId: frame.frameId,
+        mode: frame.mode,
+        columns: frame.columns,
+        rows: frame.rows,
+        beginAt: frame.beginAt,
+        endAt,
+        durationMs: rounded(Math.max(0, endAt - frame.beginAt)),
+        sinceLastCommitMs: lastCommitAt === null || frame.commits.length === 0 ? null : rounded(Math.max(0, (frame.commits[0]?.at ?? endAt) - lastCommitAt)),
+        panelHighWater: frame.panelHighWater,
+        inputHighWater: frame.inputHighWater,
+        panel: frame.panel,
+        pipeline: {
+          componentMs: rounded(frame.phases.component),
+          overlayCompositionMs: rounded(frame.phases.overlay),
+          normalizationMs: rounded(frame.phases.normalization),
+          cursorExtractionMs: rounded(frame.phases.cursor),
+          viewportDiffAnsiCursorMs: rounded(Math.max(0, endAt - frame.beginAt - measured)),
+          terminalEnqueueMs: rounded(terminalEnqueueMs)
+        },
+        commits: frame.commits
+      };
+      writer?.enqueue(record);
+      if (frame.commits.length > 0) {
+        frameRing.push(record);
+        lastCommitAt = frame.commits.at(-1)?.at ?? endAt;
+        if (!firstCommitDelivered) {
+          firstCommitDelivered = true;
+          firstCommitListener?.(frame.frameId);
+        }
+      }
+      if (currentFrame === frame) currentFrame = null;
+    },
+    beginPhase(_frame, _phase) {
+      return now();
+    },
+    endPhase(frameToken, phase, phaseToken) {
+      const frame = frameToken;
+      frame.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: (frame) => {
+      firstFrameActive = false;
+      if (firstFrameDelivered || !firstFrameWrote) return;
+      firstFrameDelivered = true;
+      options.onFirstFrameCommit?.(frame);
+      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 frame = token;
+      if (frame.primaryActive) primaryObserver?.endFrame(frame.primary);
+      for (const waiter of frameWaiters.splice(0)) waiter.resolve(frame.frameId);
+    },
+    beginPhase: (token, phase) => {
+      const frame = token;
+      return frame.primaryActive ? primaryObserver?.beginPhase(frame.primary, phase) : null;
+    },
+    endPhase: (token, phase, phaseToken) => {
+      const frame = token;
+      if (frame.primaryActive) primaryObserver?.endPhase(frame.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 frame = 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 frame;
+      });
+    },
+    hasObservedBackpressure: () => observedBackpressure || backpressure?.observed === true,
+    setStreamPacingActive
+  };
+}
+
+// src/interactive/welcome-dashboard.ts
+init_esm_shims();
+
+// src/interactive/welcome-art.ts
+init_esm_shims();
+var LETTERS = {
+  C: [" \u2588\u2588\u2588\u2588", "\u2588\u2588   ", "\u2588\u2588   ", "\u2588\u2588   ", " \u2588\u2588\u2588\u2588"],
+  L: ["\u2588\u2588   ", "\u2588\u2588   ", "\u2588\u2588   ", "\u2588\u2588   ", "\u2588\u2588\u2588\u2588\u2588"],
+  I: ["\u2588\u2588\u2588", " \u2588 ", " \u2588 ", " \u2588 ", "\u2588\u2588\u2588"],
+  O: [" \u2588\u2588\u2588 ", "\u2588\u2588 \u2588\u2588", "\u2588\u2588 \u2588\u2588", "\u2588\u2588 \u2588\u2588", " \u2588\u2588\u2588 "],
+  D: ["\u2588\u2588\u2588\u2588 ", "\u2588\u2588 \u2588\u2588", "\u2588\u2588 \u2588\u2588", "\u2588\u2588 \u2588\u2588", "\u2588\u2588\u2588\u2588 "],
+  E: ["\u2588\u2588\u2588\u2588\u2588", "\u2588\u2588   ", "\u2588\u2588\u2588\u2588 ", "\u2588\u2588   ", "\u2588\u2588\u2588\u2588\u2588"],
+  R: ["\u2588\u2588\u2588\u2588 ", "\u2588\u2588 \u2588\u2588", "\u2588\u2588\u2588\u2588 ", "\u2588\u2588 \u2588\u2588", "\u2588\u2588 \u2588\u2588"]
+};
+var WIDE_LETTERS = {
+  C: [" \u2588\u2588\u2588\u2588\u2588\u2588", "\u2588\u2588     ", "\u2588\u2588     ", "\u2588\u2588     ", " \u2588\u2588\u2588\u2588\u2588\u2588"],
+  L: ["\u2588\u2588     ", "\u2588\u2588     ", "\u2588\u2588     ", "\u2588\u2588     ", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588"],
+  I: ["\u2588\u2588", "\u2588\u2588", "\u2588\u2588", "\u2588\u2588", "\u2588\u2588"],
+  O: [" \u2588\u2588\u2588\u2588\u2588\u2588 ", "\u2588\u2588    \u2588\u2588", "\u2588\u2588    \u2588\u2588", "\u2588\u2588    \u2588\u2588", " \u2588\u2588\u2588\u2588\u2588\u2588 "],
+  D: ["\u2588\u2588\u2588\u2588\u2588\u2588 ", "\u2588\u2588   \u2588\u2588", "\u2588\u2588   \u2588\u2588", "\u2588\u2588   \u2588\u2588", "\u2588\u2588\u2588\u2588\u2588\u2588 "],
+  E: ["\u2588\u2588\u2588\u2588\u2588\u2588\u2588", "\u2588\u2588     ", "\u2588\u2588\u2588\u2588\u2588  ", "\u2588\u2588     ", "\u2588\u2588\u2588\u2588\u2588\u2588\u2588"],
+  R: ["\u2588\u2588\u2588\u2588\u2588\u2588 ", "\u2588\u2588   \u2588\u2588", "\u2588\u2588\u2588\u2588\u2588\u2588 ", "\u2588\u2588   \u2588\u2588", "\u2588\u2588   \u2588\u2588"],
+  " ": [" ", " ", " ", " ", " "]
+};
+function stacked(font) {
+  const word = (text) => Array.from({ length: 5 }, (_, row) => [...text].map((letter) => font[letter]?.[row] ?? "").join(" "));
+  const clio = word("CLIO");
+  const coder = word("CODER");
+  const width = coder[0]?.length ?? 0;
+  return [
+    ...clio.map((line) => line.padStart(line.length + Math.floor((width - line.length) / 2)).padEnd(width)),
+    " ".repeat(width),
+    ...coder
+  ];
+}
+var WELCOME_WORDMARK = stacked(LETTERS);
+var WELCOME_WORDMARK_WIDE = stacked(WIDE_LETTERS);
+
+// src/interactive/welcome-dashboard.ts
+var WELCOME_PROJECT_CONTEXT_TTL_MS = 1e4;
+var WELCOME_PROJECT_CONTEXT_RETRY_MS = 2e3;
+var ROUTE_REASON_MAX = 48;
+var ROUTE_TARGET_FLOOR = 12;
+var ROUTE_REASON_FLOOR = 8;
+function plainOneLine(value) {
+  return sanitizeCallTargetText(value);
+}
+function findCurrentStatus(statuses, settings) {
+  const targetId = settings?.chat?.target ?? null;
+  if (!targetId) return null;
+  return statuses.find((status) => status.target.id === targetId) ?? null;
+}
+function shortRouteReason(status) {
+  const cleaned = plainOneLine(status.health.lastError ?? status.reason ?? "");
+  if (cleaned.length === 0) return null;
+  return visibleWidth(cleaned) > ROUTE_REASON_MAX ? truncateToWidth(cleaned, ROUTE_REASON_MAX, GLYPH.ellipsis, false) : cleaned;
+}
+function deriveRoute(current, targetLabel, modelLabel) {
+  if (targetLabel === null || modelLabel === null) return { route: "unset", routeReason: null };
+  if (current === null) return { route: "unavailable", routeReason: "no such target in settings" };
+  if (!current.available || current.health.status === "down")
+    return { route: "unavailable", routeReason: shortRouteReason(current) };
+  if (current.health.status === "degraded") return { route: "degraded", routeReason: shortRouteReason(current) };
+  if (current.health.status === "healthy") return { route: "ready", routeReason: null };
+  return { route: "checking", routeReason: null };
+}
+function normalizeProjectContext(state) {
+  const value = state?.clioMd;
+  if (value === "ok" || value === "stale" || value === "none" || value === "malformed") return value;
+  return null;
+}
+function fitPathTail(path, max) {
+  if (max <= 0) return "";
+  if (visibleWidth(path) <= max) return path;
+  const segments = path.split("/").filter((segment) => segment.length > 0);
+  const leaf = segments.at(-1) ?? path;
+  let best = leaf;
+  for (let index = segments.length - 2; index >= 0; index -= 1) {
+    const candidate = `${segments[index]}/${best}`;
+    if (visibleWidth(`${GLYPH.ellipsis}/${candidate}`) > max) break;
+    best = candidate;
+  }
+  const marked = `${GLYPH.ellipsis}/${best}`;
+  if (visibleWidth(marked) <= max) return marked;
+  return truncateToWidth(leaf, max, GLYPH.ellipsis, false);
+}
+function fitByPriority(theme, units, maxWidth, protectRank = 0) {
+  const separator = " \xB7 ";
+  const sep = theme.fg("dim", separator);
+  const sepWidth = visibleWidth(separator);
+  const kept = units.map((unit) => ({ ...unit, dropped: false }));
+  const total = () => {
+    const live = kept.filter((unit) => !unit.dropped);
+    if (live.length === 0) return 0;
+    return live.reduce((sum, unit) => sum + visibleWidth(unit.text), 0) + sepWidth * (live.length - 1);
+  };
+  while (total() > maxWidth) {
+    const droppable = kept.filter((unit) => !unit.dropped && unit.rank > protectRank);
+    let worst = droppable[0];
+    if (worst === void 0) break;
+    for (const unit of droppable) if (unit.rank > worst.rank) worst = unit;
+    worst.dropped = true;
+  }
+  const joined = kept.filter((unit) => !unit.dropped).map((unit) => unit.text).join(sep);
+  return visibleWidth(joined) <= maxWidth ? joined : truncateToWidth(joined, maxWidth, GLYPH.ellipsis, false);
+}
+function workspacePath(stats) {
+  return plainOneLine(collapseHomePath(stats.cwd));
+}
+function workspaceBranch(stats) {
+  const workspace = stats.workspace;
+  if (workspace?.isGit !== true || !workspace.branch) return null;
+  const branch = plainOneLine(workspace.branch);
+  return branch.length === 0 ? null : branch;
+}
+function workspaceLabel(theme, stats, room) {
+  if (room <= 0) return "";
+  const path = workspacePath(stats);
+  const branch = workspaceBranch(stats);
+  const paint = (text) => theme.fg("muted", text);
+  if (branch === null) return paint(fitPathTail(path, room));
+  const dirty = stats.workspace?.dirty === true;
+  const branchText = `${theme.fg("info", branch)}${dirty ? theme.fg("warning", "*") : ""}`;
+  const pathRoom = room - visibleWidth(branch) - (dirty ? 1 : 0) - 3;
+  if (pathRoom > 0) {
+    const fitted = fitPathTail(path, pathRoom);
+    const leaf = path.split("/").filter((segment) => segment.length > 0).at(-1) ?? path;
+    if (fitted.endsWith(leaf)) return `${paint(fitted)}${theme.fg("dim", " \xB7 ")}${branchText}`;
+  }
+  return paint(fitPathTail(path, room));
+}
+function routeToken(route) {
+  if (route === "ready") return "success";
+  if (route === "degraded") return "warning";
+  if (route === "unavailable") return "error";
+  return "dim";
+}
+function routeGlyph(route) {
+  if (route === "ready") return GLYPH.ok;
+  if (route === "degraded") return GLYPH.warnInline;
+  if (route === "unavailable") return GLYPH.error;
+  return GLYPH.queued;
+}
+function routeRow(theme, stats, room) {
+  const target = plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel, { abbreviate: false }));
+  if (stats.route === "unset") return theme.fg("warning", truncateToWidth(target, room, GLYPH.ellipsis, false));
+  const token = routeToken(stats.route);
+  const prefix = `${theme.fg(token, routeGlyph(stats.route))} `;
+  const available = room - 2;
+  if (available <= 0) return theme.fg(token, routeGlyph(stats.route));
+  const muted = (text) => theme.fg("muted", text);
+  const reason = stats.routeReason;
+  if (reason === null) return `${prefix}${muted(truncateToWidth(target, available, GLYPH.ellipsis, false))}`;
+  const reasonWidth = visibleWidth(reason);
+  if (visibleWidth(target) + 1 + reasonWidth <= available) return `${prefix}${muted(target)} ${theme.fg(token, reason)}`;
+  const targetRoom = available - reasonWidth - 1;
+  if (targetRoom >= ROUTE_TARGET_FLOOR)
+    return `${prefix}${muted(truncateToWidth(target, targetRoom, GLYPH.ellipsis, false))} ${theme.fg(token, reason)}`;
+  const floor = Math.min(ROUTE_TARGET_FLOOR, available);
+  const reasonRoom = available - floor - 1;
+  if (reasonRoom >= ROUTE_REASON_FLOOR) {
+    return `${prefix}${muted(truncateToWidth(target, floor, GLYPH.ellipsis, false))} ${theme.fg(token, truncateToWidth(reason, reasonRoom, GLYPH.ellipsis, false))}`;
+  }
+  return `${prefix}${muted(truncateToWidth(target, available, GLYPH.ellipsis, false))}`;
+}
+function actionRow(theme, stats, room) {
+  const say = (token, text) => theme.fg(token, truncateToWidth(text, room, GLYPH.ellipsis, false));
+  if (stats.route === "unset") {
+    const detail = stats.targetLabel === null ? "no route selected" : "no model selected";
+    return say("warning", `${detail} \xB7 /model`);
+  }
+  if (stats.route === "unavailable") return say("error", "route unavailable \xB7 /settings targets");
+  if (stats.route === "degraded") return say("warning", "route degraded \xB7 /settings targets");
+  if (stats.projectContext === "malformed") return say("warning", "CLIO-CODER.md malformed \xB7 /context to inspect");
+  if (stats.projectContext === "none") return say("dim", "describe a task \xB7 /context init to index this repo");
+  if (stats.projectContext === "stale") return say("dim", "describe a task \xB7 /context refresh to update it");
+  const send = stats.submitKeyLabel === null ? null : `${stats.submitKeyLabel} to send`;
+  return say("dim", ["describe a task", send, "/ for commands"].filter((part) => part !== null).join(" \xB7 "));
+}
+function sessionRow(theme, stats, version, width) {
+  const mark = brandMark(theme);
+  const markWidth = visibleWidth(mark);
+  if (width <= markWidth + 1) return truncateToWidth(mark, width, "", false);
+  const room = width - markWidth - 1;
+  const branch = workspaceBranch(stats);
+  const units = [
+    { text: `${theme.style("title", "Clio Coder", { bold: true })} ${theme.fg("dim", `v${version}`)}`, rank: 3 },
+    {
+      text: theme.fg("muted", plainOneLine(formatTargetLabel(stats.targetLabel, stats.modelLabel, { abbreviate: false }))),
+      rank: 0
+    },
+    { text: theme.fg("muted", fitPathTail(workspacePath(stats), Math.max(8, Math.floor(room * 0.5)))), rank: 1 },
+    ...branch ? [
+      {
+        text: `${theme.fg("info", branch)}${stats.workspace?.dirty === true ? theme.fg("warning", "*") : ""}`,
+        rank: 2
+      }
+    ] : []
+  ];
+  return `${mark} ${fitByPriority(theme, units, room)}`;
+}
+function shortNames(names) {
+  return names.slice(0, 3).map(plainOneLine).join(", ") + (names.length > 3 ? ` +${names.length - 3}` : "");
+}
+function inventory(settings, statuses, agentCount) {
+  const configured = settings?.targets ?? statuses?.map((status) => status.target) ?? [];
+  const ready = statuses?.filter((status) => status.available && status.health.status === "healthy").length ?? 0;
+  const down = statuses?.filter((status) => !status.available || status.health.status === "down").length ?? 0;
+  const degraded = statuses?.filter((status) => status.available && status.health.status === "degraded").length ?? 0;
+  const targets = configured.length === 0 ? "None configured \xB7 /settings targets" : [
+    `${configured.length} configured`,
+    ...ready ? [`${ready} ready`] : [],
+    ...degraded ? [`${degraded} degraded`] : [],
+    ...down ? [`${down} unavailable`] : [],
+    shortNames(configured.map((target) => target.id))
+  ].join(" \xB7 ");
+  const profiles = Object.keys(settings?.fleet?.profiles ?? {});
+  const rosters = Object.keys(settings?.fleet?.rosters ?? {});
+  const fleet = [
+    ...agentCount === void 0 ? [] : [`${agentCount} agent recipes`],
+    ...rosters.length ? [`Rosters: ${shortNames(rosters)}`] : profiles.length ? [`${profiles.length} profiles`] : []
+  ].join(" \xB7 ") || "Uses main model \xB7 /agents to explore";
+  return { targets, fleet };
+}
+var WELCOME_HINT_INTERVAL_MS = 15e3;
+var WELCOME_HINT_MIN_WIDTH = 160;
+var WELCOME_HINTS = [
+  {
+    title: "Make Clio yours",
+    commands: [
+      ["/model", "Choose a model and target"],
+      ["/library", "Browse skills and extensions"],
+      ["/help", "Explore commands and shortcuts"]
+    ],
+    keys: [
+      ["tui.input.newLine", "New line"],
+      ["clio-coder.model.select", "Model picker"],
+      ["clio-coder.editor.external", "Open your external editor"]
+    ]
+  },
+  {
+    title: "Know your workspace",
+    commands: [
+      ["/context", "Inspect the active context"],
+      ["/fleet", "Explore your agent fleet"],
+      ["/help", "Find a command by name"]
+    ],
+    keys: [
+      ["clio-coder.files.toggle", "Browse files"],
+      ["clio-coder.status.toggle", "Cycle dashboard pages"],
+      ["clio-coder.session.tree", "Explore the session tree"]
+    ]
+  },
+  {
+    title: "Keep work moving",
+    commands: [
+      ["/skills", "See available skills"],
+      ["/model", "Switch the active model"],
+      ["/help", "Look up a shortcut"]
+    ],
+    keys: [
+      ["clio-coder.dispatchBoard.toggle", "Open the worker board"],
+      ["clio-coder.tasks.open", "Open tasks"],
+      ["clio-coder.thinking.cycle", "Cycle thinking effort"]
+    ]
+  }
+];
+function welcomeHints(theme, page, getKeyLabel) {
+  const hint = WELCOME_HINTS[page % WELCOME_HINTS.length];
+  if (!hint) return [];
+  const keys = hint.keys.flatMap(([action, description]) => {
+    const label = getKeyLabel?.(action);
+    return label ? [`${theme.fg("accent", label)}  ${theme.fg("muted", description)}`] : [];
+  });
+  return [
+    theme.style("accent", hint.title, { bold: true }) + theme.fg("dim", `  ${page % WELCOME_HINTS.length + 1}/${WELCOME_HINTS.length}`),
+    "",
+    ...hint.commands.map(([command, description]) => `${theme.fg("accent", command)}  ${theme.fg("muted", description)}`),
+    "",
+    ...keys.length ? [theme.fg("dim", "Keyboard shortcuts"), ...keys] : []
+  ];
+}
+function buildWelcomeDashboardLines(stats, version, width, mode, hintPage = 0, getKeyLabel) {
+  const theme = clioTheme();
+  const safeWidth = Math.max(1, width);
+  if (mode === "session") return [padAnsi(sessionRow(theme, stats, version, safeWidth), safeWidth)];
+  const panelWidth = safeWidth;
+  const room = Math.max(1, panelWidth - 4);
+  const frame = (text) => theme.fg("frame", text);
+  const row = (text) => `${frame("\u2502")} ${padAnsi(truncateToWidth(text, room, GLYPH.ellipsis, false), room)} ${frame("\u2502")}`;
+  const rule2 = (left, right) => frame(`${left}${"\u2500".repeat(Math.max(0, panelWidth - 2))}${right}`);
+  const title = ` Clio Coder v${version} `;
+  const heading = `${frame("\u256D\u2500")}${theme.fg("muted", title)}${frame(`${"\u2500".repeat(Math.max(0, panelWidth - visibleWidth(title) - 3))}\u256E`)}`;
+  const wordmark = panelWidth >= 100 ? WELCOME_WORDMARK_WIDE : WELCOME_WORDMARK;
+  const sideBySide = panelWidth >= 76;
+  const artWidth = sideBySide ? visibleWidth(wordmark[0] ?? "") : 0;
+  const showHints = panelWidth >= WELCOME_HINT_MIN_WIDTH;
+  const contentWidth = showHints ? Math.min(132, Math.floor((room - 3) * 0.58)) : room;
+  const hintWidth = room - contentWidth - 3;
+  const hints = showHints ? welcomeHints(theme, hintPage, getKeyLabel) : [];
+  const detailWidth = sideBySide ? contentWidth - artWidth - 3 : contentWidth;
+  const field = (label, value) => `${theme.fg("dim", `${label}  `)}${value}`;
+  const details = [
+    sideBySide ? theme.fg("muted", "Built for the code behind science.") : theme.style("title", "CLIO CODER", { bold: true }),
+    sideBySide ? "" : theme.fg("muted", "Built for the code behind science."),
+    theme.fg("dim", "Model"),
+    routeRow(theme, stats, detailWidth),
+    field("Workspace", workspaceLabel(theme, stats, Math.max(1, detailWidth - 11))),
+    field("Permissions", theme.fg(stats.autonomy === "full-auto" ? "warning" : "muted", stats.autonomy)),
+    theme.fg("dim", "Ask Clio how to use or extend her."),
+    theme.fg("dim", "Targets"),
+    theme.fg("muted", stats.targets),
+    theme.fg("dim", "Fleet"),
+    theme.fg("muted", stats.fleet)
+  ];
+  return [
+    heading,
+    ...details.map((detail, index) => {
+      const art = sideBySide ? `${theme.fg("accent", wordmark[index] ?? "")}   ` : "";
+      const content = `${art}${truncateToWidth(detail, detailWidth, GLYPH.ellipsis, false)}`;
+      return row(
+        showHints ? `${padAnsi(content, contentWidth)} ${frame("\u2502")} ${truncateToWidth(hints[index] ?? "", hintWidth, GLYPH.ellipsis, false)}` : content
+      );
+    }),
+    rule2("\u251C", "\u2524"),
+    row(actionRow(theme, stats, room)),
+    rule2("\u2570", "\u256F")
+  ].map((line) => padAnsi(truncateToWidth(line, safeWidth, GLYPH.ellipsis, false), safeWidth));
+}
+function statsSignature(stats) {
+  const workspace = stats.workspace;
+  return [
+    stats.cwd,
+    workspace && `${workspace.isGit}
${workspace.branch}
${workspace.dirty}`,
+    stats.targetLabel,
+    stats.modelLabel,
+    stats.route,
+    stats.routeReason,
+    stats.projectContext,
+    stats.submitKeyLabel,
+    stats.autonomy,
+    stats.targets,
+    stats.fleet
+  ].join("\0");
+}
+var WelcomeDashboard = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+    this.hintStartedAt = this.now();
+    this.schedule = deps.scheduleRefresh ?? ((run) => {
+      this.pendingTimer = setTimeout(() => {
+        this.pendingTimer = null;
+        run();
+      }, 0);
+      this.pendingTimer.unref?.();
+    });
+    this.version = readClioVersion();
+  }
+  deps;
+  cachedRender = null;
+  context = null;
+  /** Single-flight latch: a read slower than the TTL must not stack refreshes. */
+  contextRefreshing = false;
+  pendingTimer = null;
+  disposed = false;
+  mode = "launchpad";
+  now;
+  hintStartedAt;
+  schedule;
+  /**
+   * Read once, here, rather than inside a frame: resolving it walks up for
+   * package.json and parses it, which is filesystem work the render path must
+   * not do even once.
+   */
+  version;
+  render(width) {
+    const stats = this.stats();
+    const hintPage = this.mode === "launchpad" && width >= WELCOME_HINT_MIN_WIDTH ? Math.floor(Math.max(0, this.now() - this.hintStartedAt) / WELCOME_HINT_INTERVAL_MS) % WELCOME_HINTS.length : 0;
+    const shortcutSignature = this.mode === "launchpad" && width >= WELCOME_HINT_MIN_WIDTH ? WELCOME_HINTS[hintPage]?.keys.map(([action]) => this.deps.getKeyLabel?.(action)).join("|") : "";
+    const signature = `${this.mode}\0${statsSignature(stats)}\0${hintPage}\0${shortcutSignature}`;
+    const cached = this.cachedRender;
+    if (cached !== null && cached.width === width && cached.signature === signature) return cached.lines;
+    const lines = buildWelcomeDashboardLines(stats, this.version, width, this.mode, hintPage, this.deps.getKeyLabel);
+    this.cachedRender = { width, signature, lines };
+    return lines;
+  }
+  /** Collapse once, before first-submit dispatch can append transcript output. */
+  collapseToSessionHeader() {
+    if (this.mode === "session") return false;
+    this.mode = "session";
+    this.cachedRender = null;
+    return true;
+  }
+  /** A genuinely new session gets a fresh launchpad and a fresh one-time transition. */
+  resetToLaunchpad() {
+    if (this.mode === "launchpad") return false;
+    this.mode = "launchpad";
+    this.hintStartedAt = this.now();
+    this.cachedRender = null;
+    return true;
+  }
+  /**
+   * Drops the rendered lines only. The project-context reading is not
+   * width-dependent, and pi cascades `invalidate` on terminal cell-dimension
+   * reports; dropping the reading there would flash the header back to
+   * `checking` for a fact that had not changed.
+   */
+  invalidate() {
+    this.cachedRender = null;
+  }
+  /**
+   * After this, a refresh already in flight lands on the floor: it neither
+   * writes state nor asks for a frame from a presentation that is being torn
+   * down.
+   */
+  dispose() {
+    this.disposed = true;
+    if (this.pendingTimer !== null) {
+      clearTimeout(this.pendingTimer);
+      this.pendingTimer = null;
+    }
+  }
+  stats() {
+    const settings = this.deps.getSettings?.();
+    const statuses = this.deps.providers.list();
+    const current = findCurrentStatus(statuses, settings);
+    const targetLabel = current?.target.id ?? settings?.chat?.target ?? null;
+    const modelLabel = settings?.chat?.model ?? current?.target.defaultModel ?? null;
+    const workspace = this.deps.getWorkspaceSnapshot?.() ?? null;
+    const cwd = workspace?.cwd ?? process.cwd();
+    const { route, routeReason } = deriveRoute(current, targetLabel, modelLabel);
+    const launchpad = this.mode === "launchpad";
+    return {
+      cwd,
+      workspace,
+      targetLabel,
+      modelLabel,
+      route,
+      routeReason,
+      projectContext: launchpad ? this.projectContext(cwd) : "checking",
+      submitKeyLabel: launchpad ? this.deps.getSubmitKeyLabel?.() ?? null : null,
+      autonomy: settings?.safety?.autonomy ?? "auto-edit",
+      ...inventory(settings, statuses, this.deps.getAgentCount?.())
+    };
+  }
+  /**
+   * Returns immediately, always, and never touches the filesystem. On a miss it
+   * reports `checking` and schedules the authoritative read off the frame. A
+   * reading is only ever served for the cwd it was taken in, so a directory
+   * change reports `checking` again rather than the previous repository's answer.
+   */
+  projectContext(cwd) {
+    const cached = this.context;
+    if (cached === null || cached.cwd !== cwd) {
+      this.scheduleContextRefresh(cwd);
+      return "checking";
+    }
+    const at = this.now();
+    if (cached.failingSince !== null && at - cached.failingSince >= WELCOME_PROJECT_CONTEXT_TTL_MS) {
+      if (at - cached.attemptedAt >= WELCOME_PROJECT_CONTEXT_RETRY_MS) this.scheduleContextRefresh(cwd);
+      return "checking";
+    }
+    if (at - cached.readAt < WELCOME_PROJECT_CONTEXT_TTL_MS) return cached.state;
+    const due = cached.failingSince === null ? cached.attemptedAt : cached.attemptedAt + WELCOME_PROJECT_CONTEXT_RETRY_MS;
+    if (at >= due) this.scheduleContextRefresh(cwd);
+    return cached.state;
+  }
+  scheduleContextRefresh(cwd) {
+    const read = this.deps.getContextState;
+    if (read === void 0 || this.contextRefreshing || this.disposed) return;
+    this.contextRefreshing = true;
+    this.schedule(() => {
+      if (this.disposed) {
+        this.contextRefreshing = false;
+        return;
+      }
+      let resolved = null;
+      try {
+        resolved = normalizeProjectContext(read(cwd));
+      } catch {
+        resolved = null;
+      } finally {
+        this.contextRefreshing = false;
+      }
+      if (this.disposed) return;
+      const at = this.now();
+      const previous = this.context !== null && this.context.cwd === cwd ? this.context : null;
+      this.context = resolved === null ? {
+        cwd,
+        state: previous?.state ?? "checking",
+        // Deliberately not renewed: a failure must not extend the trust
+        // window of the value it failed to confirm.
+        readAt: previous?.readAt ?? 0,
+        attemptedAt: at,
+        failingSince: previous?.failingSince ?? at
+      } : { cwd, state: resolved, readAt: at, attemptedAt: at, failingSince: null };
+      this.cachedRender = null;
+      this.deps.onFactsRefreshed?.();
+    });
+  }
+};
+function createWelcomeDashboard(deps) {
+  return new WelcomeDashboard(deps);
+}
+function createBootWelcome(settings, submitKeyLabel, getKeyLabel) {
+  const target = settings.targets.find((entry) => entry.id === settings.chat.target);
+  const model = settings.chat.model ?? target?.defaultModel ?? null;
+  const version = readClioVersion();
+  const stats = {
+    cwd: process.cwd(),
+    workspace: null,
+    targetLabel: settings.chat.target ?? null,
+    modelLabel: model,
+    route: target && model ? "checking" : "unset",
+    routeReason: null,
+    projectContext: "checking",
+    submitKeyLabel,
+    autonomy: settings.safety.autonomy,
+    ...inventory(settings)
+  };
+  return {
+    render: (width) => buildWelcomeDashboardLines(stats, version, width, "launchpad", 0, getKeyLabel),
+    invalidate: () => {
+    }
+  };
+}
+
+export {
+  unguardPastedEditorOperator,
+  parseEditorBashCommand,
+  ClioEditor,
+  writeInputWedgeDump,
+  getActiveRenderTrace,
+  createProcessInteractiveShell,
+  createWelcomeDashboard,
+  createBootWelcome
+};
+//# sourceMappingURL=chunk-R2UUNSNQ.js.map