flavor-code 1.2.1

package/dist/app-WC2XXGLM.js

@@ -0,0 +1,3185 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import {
+  statusPresentation
+} from "./chunk-DM64TM4Z.js";
+import {
+  COMMAND_DESCRIPTIONS,
+  MVP_COMMANDS,
+  createGlobTool,
+  createProductionRuntime,
+  createTranscriptState,
+  isDestructiveTool,
+  message,
+  modelContentTranscriptText,
+  redactErrorText,
+  transcriptReducer
+} from "./chunk-BU64GNXE.js";
+import "./chunk-MVIMQEQT.js";
+import {
+  Box_default,
+  ClockContext,
+  OSC,
+  ScrollBox_default,
+  StdinContext_default,
+  TerminalSizeContext,
+  TerminalWriteContext,
+  Text,
+  instances_default,
+  osc,
+  shiftAnchor,
+  stripAnsi,
+  useStdout,
+  use_app_default,
+  use_input_default
+} from "./chunk-XS2JU6S3.js";
+import {
+  execFileNoThrow
+} from "./chunk-VOCZVFP7.js";
+import "./chunk-JZ322RCJ.js";
+
+// src/ui/app.tsx
+import { basename as basename3 } from "path";
+import { useEffect as useEffect3, useReducer, useRef as useRef4, useState as useState2 } from "react";
+
+// src/claude-ink/hooks/use-animation-frame.ts
+import { useContext as useContext2, useEffect, useState } from "react";
+
+// src/claude-ink/hooks/use-terminal-viewport.ts
+import { useCallback, useContext, useLayoutEffect, useRef } from "react";
+function useTerminalViewport() {
+  const terminalSize = useContext(TerminalSizeContext);
+  const elementRef = useRef(null);
+  const entryRef = useRef({ isVisible: true });
+  const setElement = useCallback((el) => {
+    elementRef.current = el;
+  }, []);
+  useLayoutEffect(() => {
+    const element = elementRef.current;
+    if (!element?.yogaNode || !terminalSize) {
+      return;
+    }
+    const height = element.yogaNode.getComputedHeight();
+    const rows = terminalSize.rows;
+    let absoluteTop = element.yogaNode.getComputedTop();
+    let parent = element.parentNode;
+    let root = element.yogaNode;
+    while (parent) {
+      if (parent.yogaNode) {
+        absoluteTop += parent.yogaNode.getComputedTop();
+        root = parent.yogaNode;
+      }
+      if (parent.scrollTop) absoluteTop -= parent.scrollTop;
+      parent = parent.parentNode;
+    }
+    const screenHeight = root.getComputedHeight();
+    const bottom = absoluteTop + height;
+    const cursorRestoreScroll = screenHeight > rows ? 1 : 0;
+    const viewportY = Math.max(0, screenHeight - rows) + cursorRestoreScroll;
+    const viewportBottom = viewportY + rows;
+    const visible = bottom > viewportY && absoluteTop < viewportBottom;
+    if (visible !== entryRef.current.isVisible) {
+      entryRef.current = { isVisible: visible };
+    }
+  });
+  return [setElement, entryRef.current];
+}
+
+// src/claude-ink/hooks/use-animation-frame.ts
+function useAnimationFrame(intervalMs = 16) {
+  const clock = useContext2(ClockContext);
+  const [viewportRef, { isVisible }] = useTerminalViewport();
+  const [time, setTime] = useState(() => clock?.now() ?? 0);
+  const active = isVisible && intervalMs !== null;
+  useEffect(() => {
+    if (!clock || !active) return;
+    let lastUpdate = clock.now();
+    const onChange = () => {
+      const now = clock.now();
+      if (now - lastUpdate >= intervalMs) {
+        lastUpdate = now;
+        setTime(now);
+      }
+    };
+    return clock.subscribe(onChange, true);
+  }, [clock, intervalMs, active]);
+  return [viewportRef, time];
+}
+
+// src/claude-ink/hooks/use-selection.ts
+import { useContext as useContext3, useMemo, useSyncExternalStore } from "react";
+function useSelection() {
+  useContext3(StdinContext_default);
+  const ink = instances_default.get(process.stdout);
+  return useMemo(() => {
+    if (!ink) {
+      return {
+        copySelection: () => "",
+        copySelectionNoClear: () => "",
+        clearSelection: () => {
+        },
+        hasSelection: () => false,
+        getState: () => null,
+        subscribe: () => () => {
+        },
+        shiftAnchor: () => {
+        },
+        shiftSelection: () => {
+        },
+        moveFocus: () => {
+        },
+        captureScrolledRows: () => {
+        },
+        setSelectionBgColor: () => {
+        }
+      };
+    }
+    return {
+      copySelection: () => ink.copySelection(),
+      copySelectionNoClear: () => ink.copySelectionNoClear(),
+      clearSelection: () => ink.clearTextSelection(),
+      hasSelection: () => ink.hasTextSelection(),
+      getState: () => ink.selection,
+      subscribe: (cb) => ink.subscribeToSelectionChange(cb),
+      shiftAnchor: (dRow, minRow, maxRow) => shiftAnchor(ink.selection, dRow, minRow, maxRow),
+      shiftSelection: (dRow, minRow, maxRow) => ink.shiftSelectionForScroll(dRow, minRow, maxRow),
+      moveFocus: (move) => ink.moveSelectionFocus(move),
+      captureScrolledRows: (firstRow, lastRow, side) => ink.captureScrolledRows(firstRow, lastRow, side),
+      setSelectionBgColor: (color) => ink.setSelectionBgColor(color)
+    };
+  }, [ink]);
+}
+
+// src/claude-ink/hooks/use-terminal-title.ts
+import { useContext as useContext4, useEffect as useEffect2 } from "react";
+function useTerminalTitle(title) {
+  const writeRaw = useContext4(TerminalWriteContext);
+  useEffect2(() => {
+    if (title === null || !writeRaw) return;
+    const clean = stripAnsi(title);
+    writeRaw(osc(OSC.SET_TITLE_AND_ICON, clean));
+  }, [title, writeRaw]);
+}
+
+// src/ui/assistant-text.tsx
+import React2 from "react";
+
+// src/ui/markdown.tsx
+import React, { useMemo as useMemo2, useRef as useRef2 } from "react";
+import chalk2 from "chalk";
+import { marked } from "marked";
+
+// src/ui/highlight.ts
+import chalk from "chalk";
+chalk.level = Math.max(chalk.level, 3);
+var KEYWORD = chalk.hex("#c586c0");
+var STRING = chalk.hex("#ce9178");
+var COMMENT = chalk.gray.italic;
+var NUMBER = chalk.hex("#b5cea8");
+var FUNCTION = chalk.hex("#dcdcaa");
+var ATTRIBUTE = chalk.hex("#d7ba7d");
+var KEYWORDS = {
+  javascript: /* @__PURE__ */ new Set([
+    "await",
+    "async",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "let",
+    "new",
+    "of",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "false",
+    "null",
+    "try",
+    "typeof",
+    "undefined",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+  ]),
+  typescript: /* @__PURE__ */ new Set([
+    "abstract",
+    "any",
+    "as",
+    "async",
+    "await",
+    "boolean",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "constructor",
+    "continue",
+    "declare",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "is",
+    "keyof",
+    "let",
+    "namespace",
+    "never",
+    "new",
+    "null",
+    "number",
+    "object",
+    "of",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "return",
+    "set",
+    "static",
+    "string",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "undefined",
+    "unique",
+    "unknown",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+  ]),
+  python: /* @__PURE__ */ new Set([
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield",
+    "self"
+  ]),
+  bash: /* @__PURE__ */ new Set([
+    "if",
+    "then",
+    "else",
+    "elif",
+    "fi",
+    "for",
+    "while",
+    "until",
+    "do",
+    "done",
+    "case",
+    "esac",
+    "in",
+    "function",
+    "return",
+    "export",
+    "local",
+    "echo",
+    "printf",
+    "test"
+  ]),
+  json: /* @__PURE__ */ new Set(["true", "false", "null"]),
+  rust: /* @__PURE__ */ new Set([
+    "as",
+    "async",
+    "await",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "dyn",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    "while"
+  ]),
+  go: /* @__PURE__ */ new Set([
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var",
+    "true",
+    "false",
+    "nil"
+  ])
+};
+function normalizeLanguage(input) {
+  if (input === void 0) return void 0;
+  const lower = input.trim().toLowerCase();
+  switch (lower) {
+    case "js":
+    case "jsx":
+    case "javascript":
+      return "javascript";
+    case "ts":
+    case "tsx":
+    case "typescript":
+      return "typescript";
+    case "py":
+    case "python":
+      return "python";
+    case "sh":
+    case "shell":
+    case "bash":
+    case "zsh":
+      return "bash";
+    case "json":
+      return "json";
+    case "rs":
+    case "rust":
+      return "rust";
+    case "go":
+    case "golang":
+      return "go";
+    default:
+      return void 0;
+  }
+}
+function isIdentifierStart(ch) {
+  return /[A-Za-z_]/.test(ch) || ch === "@";
+}
+function isIdentifierPart(ch) {
+  return /[A-Za-z0-9_]/.test(ch);
+}
+function isDigit(ch) {
+  return ch >= "0" && ch <= "9";
+}
+function isNumberPrefix(line, i) {
+  const ch = line[i] ?? "";
+  if (isDigit(ch)) return true;
+  if (ch === "." && isDigit(line[i + 1] ?? "")) return true;
+  if (ch === "0" && (line[i + 1] === "x" || line[i + 1] === "X")) return true;
+  return false;
+}
+function readNumberToken(line, i) {
+  let j = i + 1;
+  const len = line.length;
+  while (j < len) {
+    const cj = line[j] ?? "";
+    if (isDigit(cj)) {
+      j += 1;
+      continue;
+    }
+    if (cj === "." && isDigit(line[j + 1] ?? "")) {
+      j += 1;
+      continue;
+    }
+    if (cj === "_") {
+      j += 1;
+      continue;
+    }
+    if ((cj === "e" || cj === "E") && /[+\-0-9]/.test(line[j + 1] ?? "")) {
+      j += 1;
+      if (line[j] === "+" || line[j] === "-") j += 1;
+      while (j < len && isDigit(line[j] ?? "")) j += 1;
+      continue;
+    }
+    break;
+  }
+  return j;
+}
+function readIdentifierToken(line, i) {
+  let j = i + 1;
+  while (j < line.length && isIdentifierPart(line[j] ?? "")) j += 1;
+  return j;
+}
+function readStringToken(line, i) {
+  const quote = line[i] ?? "";
+  let j = i + 1;
+  const len = line.length;
+  while (j < len) {
+    const cj = line[j] ?? "";
+    if (cj === "\\") {
+      j += 2;
+      continue;
+    }
+    if (cj === quote) {
+      j += 1;
+      return j;
+    }
+    j += 1;
+  }
+  return j;
+}
+function readBlockCommentToken(line, i) {
+  let j = i + 2;
+  const len = line.length;
+  while (j < len) {
+    if (line[j] === "*" && line[j + 1] === "/") return j + 2;
+    j += 1;
+  }
+  return len;
+}
+function highlightSingleLine(line, keywords) {
+  const tokens = [];
+  let i = 0;
+  const len = line.length;
+  const commentStart = line[0] === "#";
+  while (i < len) {
+    const ch = line[i] ?? "";
+    if (ch === "/" && line[i + 1] === "*") {
+      const end = readBlockCommentToken(line, i);
+      tokens.push({ text: line.slice(i, end), paint: COMMENT });
+      i = end;
+      continue;
+    }
+    if (commentStart && ch === "#") {
+      tokens.push({ text: line.slice(i), paint: COMMENT });
+      i = len;
+      continue;
+    }
+    if (ch === "/" && line[i + 1] === "/") {
+      tokens.push({ text: line.slice(i), paint: COMMENT });
+      i = len;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const end = readStringToken(line, i);
+      tokens.push({ text: line.slice(i, end), paint: STRING });
+      i = end;
+      continue;
+    }
+    if (isNumberPrefix(line, i)) {
+      const end = readNumberToken(line, i);
+      tokens.push({ text: line.slice(i, end), paint: NUMBER });
+      i = end;
+      continue;
+    }
+    if (isIdentifierStart(ch)) {
+      const end = readIdentifierToken(line, i);
+      const word = line.slice(i, end);
+      if (ch === "@") {
+        tokens.push({ text: word, paint: ATTRIBUTE });
+      } else if (keywords.has(word)) {
+        tokens.push({ text: word, paint: KEYWORD });
+      } else if (line[end] === "(") {
+        tokens.push({ text: word, paint: FUNCTION });
+      } else {
+        tokens.push({ text: word, paint: (s) => s });
+      }
+      i = end;
+      continue;
+    }
+    let j = i + 1;
+    while (j < len) {
+      const cj = line[j] ?? "";
+      if (isIdentifierStart(cj) || isDigit(cj) || cj === "'" || cj === '"' || cj === "`" || cj === "@" || cj === "/") break;
+      j += 1;
+    }
+    tokens.push({ text: line.slice(i, j), paint: (s) => s });
+    i = j;
+  }
+  let out = "";
+  for (const token of tokens) {
+    out += token.paint(token.text);
+  }
+  return out;
+}
+function highlightCode(source, language = void 0) {
+  if (source.length === 0) return "";
+  const lang = normalizeLanguage(language);
+  const keywords = lang !== void 0 ? KEYWORDS[lang] : KEYWORDS.javascript;
+  return source.split("\n").map((line) => highlightSingleLine(line, keywords)).join("\n");
+}
+
+// src/ui/char-width.ts
+function charWidth(codePoint) {
+  if (codePoint === 8203 || // ZERO WIDTH SPACE
+  codePoint === 8204 || // ZERO WIDTH NON-JOINER
+  codePoint === 8205 || // ZERO WIDTH JOINER
+  codePoint === 65279 || // BOM / ZERO WIDTH NO-BREAK SPACE
+  codePoint >= 768 && codePoint <= 879 || // Combining Diacritical Marks
+  codePoint >= 1155 && codePoint <= 1161 || // Cyrillic combining marks
+  codePoint >= 1425 && codePoint <= 1469 || // Hebrew combining marks
+  codePoint >= 1552 && codePoint <= 1562 || // Arabic combining marks
+  codePoint >= 1611 && codePoint <= 1631 || // Arabic combining marks
+  codePoint >= 1648 && codePoint <= 1648 || // Arabic combining marks
+  codePoint >= 1750 && codePoint <= 1756 || // Arabic combining marks
+  codePoint >= 1759 && codePoint <= 1764 || // Arabic combining marks
+  codePoint >= 1767 && codePoint <= 1768 || // Arabic combining marks
+  codePoint >= 1770 && codePoint <= 1773 || // Arabic combining marks
+  codePoint >= 1809 && codePoint <= 1809 || // Syriac combining marks
+  codePoint >= 1840 && codePoint <= 1866 || // Syriac combining marks
+  codePoint >= 1958 && codePoint <= 1968 || // Thaana combining marks
+  codePoint >= 2304 && codePoint <= 2306 || // Devanagari combining marks
+  codePoint >= 2362 && codePoint <= 2362 || // Devanagari combining marks
+  codePoint >= 2364 && codePoint <= 2364 || // Devanagari combining marks
+  codePoint >= 2369 && codePoint <= 2376 || // Devanagari combining marks
+  codePoint >= 2381 && codePoint <= 2381 || // Devanagari combining marks
+  codePoint >= 2385 && codePoint <= 2391 || // Devanagari combining marks
+  codePoint >= 2402 && codePoint <= 2403 || // Devanagari combining marks
+  codePoint >= 2433 && codePoint <= 2433 || // Bengali combining marks
+  codePoint >= 2492 && codePoint <= 2492 || // Bengali combining marks
+  codePoint >= 2497 && codePoint <= 2500 || // Bengali combining marks
+  codePoint >= 2509 && codePoint <= 2509 || // Bengali combining marks
+  codePoint >= 2530 && codePoint <= 2531 || // Bengali combining marks
+  codePoint >= 2561 && codePoint <= 2562 || // Gurmukhi combining marks
+  codePoint >= 2620 && codePoint <= 2620 || // Gurmukhi combining marks
+  codePoint >= 2625 && codePoint <= 2626 || // Gurmukhi combining marks
+  codePoint >= 2631 && codePoint <= 2632 || // Gurmukhi combining marks
+  codePoint >= 2635 && codePoint <= 2637 || // Gurmukhi combining marks
+  codePoint >= 2672 && codePoint <= 2673 || // Gurmukhi combining marks
+  codePoint >= 2689 && codePoint <= 2690 || // Gujarati combining marks
+  codePoint >= 2748 && codePoint <= 2748 || // Gujarati combining marks
+  codePoint >= 2753 && codePoint <= 2757 || // Gujarati combining marks
+  codePoint >= 2759 && codePoint <= 2760 || // Gujarati combining marks
+  codePoint >= 2765 && codePoint <= 2765 || // Gujarati combining marks
+  codePoint >= 2786 && codePoint <= 2787 || // Gujarati combining marks
+  codePoint >= 2817 && codePoint <= 2817 || // Oriya combining marks
+  codePoint >= 2876 && codePoint <= 2876 || // Oriya combining marks
+  codePoint >= 2879 && codePoint <= 2879 || // Oriya combining marks
+  codePoint >= 2881 && codePoint <= 2883 || // Oriya combining marks
+  codePoint >= 2893 && codePoint <= 2893 || // Oriya combining marks
+  codePoint >= 2902 && codePoint <= 2902 || // Oriya combining marks
+  codePoint >= 2946 && codePoint <= 2946 || // Tamil combining marks
+  codePoint >= 3008 && codePoint <= 3008 || // Tamil combining marks
+  codePoint >= 3021 && codePoint <= 3021 || // Tamil combining marks
+  codePoint >= 3134 && codePoint <= 3136 || // Telugu combining marks
+  codePoint >= 3142 && codePoint <= 3144 || // Telugu combining marks
+  codePoint >= 3146 && codePoint <= 3149 || // Telugu combining marks
+  codePoint >= 3157 && codePoint <= 3158 || // Telugu combining marks
+  codePoint >= 3260 && codePoint <= 3260 || // Kannada combining marks
+  codePoint >= 3263 && codePoint <= 3263 || // Kannada combining marks
+  codePoint >= 3270 && codePoint <= 3270 || // Kannada combining marks
+  codePoint >= 3276 && codePoint <= 3277 || // Kannada combining marks
+  codePoint >= 3298 && codePoint <= 3299 || // Kannada combining marks
+  codePoint >= 3393 && codePoint <= 3395 || // Malayalam combining marks
+  codePoint >= 3405 && codePoint <= 3405 || // Malayalam combining marks
+  codePoint >= 3530 && codePoint <= 3530 || // Sinhala combining marks
+  codePoint >= 3538 && codePoint <= 3540 || // Sinhala combining marks
+  codePoint >= 3542 && codePoint <= 3542 || // Sinhala combining marks
+  codePoint >= 3633 && codePoint <= 3633 || // Thai combining marks
+  codePoint >= 3636 && codePoint <= 3642 || // Thai combining marks
+  codePoint >= 3655 && codePoint <= 3662 || // Thai combining marks
+  codePoint >= 3761 && codePoint <= 3761 || // Lao combining marks
+  codePoint >= 3764 && codePoint <= 3769 || // Lao combining marks
+  codePoint >= 3771 && codePoint <= 3772 || // Lao combining marks
+  codePoint >= 3784 && codePoint <= 3789 || // Lao combining marks
+  codePoint >= 3864 && codePoint <= 3865 || // Tibetan combining marks
+  codePoint >= 3893 && codePoint <= 3893 || // Tibetan combining marks
+  codePoint >= 3895 && codePoint <= 3895 || // Tibetan combining marks
+  codePoint >= 3897 && codePoint <= 3897 || // Tibetan combining marks
+  codePoint >= 3953 && codePoint <= 3966 || // Tibetan combining marks
+  codePoint >= 3968 && codePoint <= 3972 || // Tibetan combining marks
+  codePoint >= 3974 && codePoint <= 3975 || // Tibetan combining marks
+  codePoint >= 3984 && codePoint <= 3991 || // Tibetan combining marks
+  codePoint >= 3993 && codePoint <= 4028 || // Tibetan combining marks
+  codePoint >= 4038 && codePoint <= 4038 || // Tibetan combining marks
+  codePoint >= 4146 && codePoint <= 4151 || // Myanmar combining marks
+  codePoint >= 4153 && codePoint <= 4154 || // Myanmar combining marks
+  codePoint >= 4157 && codePoint <= 4158 || // Myanmar combining marks
+  codePoint >= 4184 && codePoint <= 4185 || // Myanmar combining marks
+  codePoint >= 4190 && codePoint <= 4192 || // Myanmar combining marks
+  codePoint >= 4209 && codePoint <= 4212 || // Myanmar combining marks
+  codePoint >= 4226 && codePoint <= 4226 || // Myanmar combining marks
+  codePoint >= 4229 && codePoint <= 4230 || // Myanmar combining marks
+  codePoint >= 4237 && codePoint <= 4237 || // Myanmar combining marks
+  codePoint >= 4957 && codePoint <= 4959 || // Ethiopic combining marks
+  codePoint >= 5906 && codePoint <= 5908 || // Tagalog combining marks
+  codePoint >= 5938 && codePoint <= 5940 || // Hanunoo combining marks
+  codePoint >= 5970 && codePoint <= 5971 || // Buhid combining marks
+  codePoint >= 6002 && codePoint <= 6003 || // Tagbanwa combining marks
+  codePoint >= 6068 && codePoint <= 6069 || // Khmer combining marks
+  codePoint >= 6071 && codePoint <= 6077 || // Khmer combining marks
+  codePoint >= 6086 && codePoint <= 6086 || // Khmer combining marks
+  codePoint >= 6089 && codePoint <= 6099 || // Khmer combining marks
+  codePoint >= 6109 && codePoint <= 6109 || // Khmer combining marks
+  codePoint >= 6155 && codePoint <= 6157 || // Mongolian combining marks
+  codePoint >= 6313 && codePoint <= 6313 || // Mongolian combining marks
+  codePoint >= 6432 && codePoint <= 6434 || // Limbu combining marks
+  codePoint >= 6439 && codePoint <= 6440 || // Limbu combining marks
+  codePoint >= 6450 && codePoint <= 6450 || // Limbu combining marks
+  codePoint >= 6457 && codePoint <= 6459 || // Limbu combining marks
+  codePoint >= 6679 && codePoint <= 6680 || // Buginese combining marks
+  codePoint >= 6912 && codePoint <= 6915 || // Balinese combining marks
+  codePoint >= 6964 && codePoint <= 6964 || // Balinese combining marks
+  codePoint >= 6966 && codePoint <= 6970 || // Balinese combining marks
+  codePoint >= 6972 && codePoint <= 6972 || // Balinese combining marks
+  codePoint >= 6978 && codePoint <= 6978 || // Balinese combining marks
+  codePoint >= 7019 && codePoint <= 7027 || // Balinese combining marks
+  codePoint >= 7616 && codePoint <= 7679 || // Combining Diacritical Marks Supplement
+  codePoint >= 8400 && codePoint <= 8432 || // Combining Diacritical Marks for Symbols
+  codePoint >= 11503 && codePoint <= 11505 || // Coptic combining marks
+  codePoint >= 11647 && codePoint <= 11647 || // Tifinagh combining marks
+  codePoint >= 11744 && codePoint <= 11775 || // Cyrillic Extended-A combining marks
+  codePoint >= 42607 && codePoint <= 42610 || // Cyrillic Extended-B combining marks
+  codePoint >= 42612 && codePoint <= 42621 || // Cyrillic Extended-B combining marks
+  codePoint >= 42654 && codePoint <= 42655 || // Cyrillic Extended-B combining marks
+  codePoint >= 42736 && codePoint <= 42737 || // Bamum combining marks
+  codePoint >= 43010 && codePoint <= 43010 || // Syloti Nagri combining marks
+  codePoint >= 43014 && codePoint <= 43014 || // Syloti Nagri combining marks
+  codePoint >= 43019 && codePoint <= 43019 || // Syloti Nagri combining marks
+  codePoint >= 43045 && codePoint <= 43046 || // Syloti Nagri combining marks
+  codePoint >= 43204 && codePoint <= 43204 || // Saurashtra combining marks
+  codePoint >= 43232 && codePoint <= 43249 || // Devanagari Extended combining marks
+  codePoint >= 43302 && codePoint <= 43309 || // Kayah Li combining marks
+  codePoint >= 43335 && codePoint <= 43345 || // Rejang combining marks
+  codePoint >= 43392 && codePoint <= 43394 || // Javanese combining marks
+  codePoint >= 43443 && codePoint <= 43443 || // Javanese combining marks
+  codePoint >= 43446 && codePoint <= 43449 || // Javanese combining marks
+  codePoint >= 43452 && codePoint <= 43452 || // Javanese combining marks
+  codePoint >= 43561 && codePoint <= 43566 || // Cham combining marks
+  codePoint >= 43569 && codePoint <= 43570 || // Cham combining marks
+  codePoint >= 43573 && codePoint <= 43574 || // Cham combining marks
+  codePoint >= 43587 && codePoint <= 43587 || // Cham combining marks
+  codePoint >= 43596 && codePoint <= 43596 || // Cham combining marks
+  codePoint >= 43696 && codePoint <= 43696 || // Tai Viet combining marks
+  codePoint >= 43698 && codePoint <= 43700 || // Tai Viet combining marks
+  codePoint >= 43703 && codePoint <= 43704 || // Tai Viet combining marks
+  codePoint >= 43710 && codePoint <= 43711 || // Tai Viet combining marks
+  codePoint >= 43713 && codePoint <= 43713 || // Tai Viet combining marks
+  codePoint >= 44005 && codePoint <= 44005 || // Meetei Mayek combining marks
+  codePoint >= 44008 && codePoint <= 44008 || // Meetei Mayek combining marks
+  codePoint >= 44013 && codePoint <= 44013 || // Meetei Mayek combining marks
+  codePoint >= 64286 && codePoint <= 64286 || // Hebrew combining marks
+  codePoint >= 65024 && codePoint <= 65039 || // Variation Selectors
+  codePoint >= 65056 && codePoint <= 65071 || // Combining Half Marks
+  codePoint >= 917760 && codePoint <= 917999) {
+    return 0;
+  }
+  if (codePoint >= 4352 && codePoint <= 4447 || // Hangul Jamo
+  codePoint >= 9001 && codePoint <= 9002 || // Left/Right-pointing angle bracket
+  codePoint >= 11904 && codePoint <= 12350 || // CJK Radicals Supplement, Kangxi Radicals, CJK Symbols
+  codePoint >= 12352 && codePoint <= 13247 || // Hiragana, Katakana, Bopomofo, Hangul Compatibility, Kanbun, CJK Strokes, Enclosed CJK
+  codePoint >= 13312 && codePoint <= 19903 || // CJK Unified Ideographs Extension A
+  codePoint >= 19968 && codePoint <= 42191 || // CJK Unified Ideographs, Yi Syllables, Yi Radicals
+  codePoint >= 43360 && codePoint <= 43388 || // Hangul Jamo Extended-A
+  codePoint >= 44032 && codePoint <= 55203 || // Hangul Syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK Compatibility Ideographs
+  codePoint >= 65040 && codePoint <= 65049 || // Vertical forms
+  codePoint >= 65072 && codePoint <= 65135 || // CJK Compatibility Forms, Small Form Variants
+  codePoint >= 65281 && codePoint <= 65376 || // Fullwidth Forms
+  codePoint >= 65504 && codePoint <= 65510 || // Fullwidth Signs
+  codePoint >= 110592 && codePoint <= 111359 || // Kana Supplement, Kana Extended-A, Small Kana Extension
+  codePoint >= 126980 && codePoint <= 126980 || // Mahjong tile
+  codePoint >= 127183 && codePoint <= 127183 || // Playing card
+  codePoint >= 127232 && codePoint <= 129535 || // Enclosed Alphanumeric Supplement, Emoticons, Transport, etc.
+  codePoint >= 129536 && codePoint <= 129647 || // Chess Symbols
+  codePoint >= 129648 && codePoint <= 129791 || // Symbols and Pictographs Extended-A
+  codePoint >= 131072 && codePoint <= 196605 || // CJK Unified Ideographs Extension B–G, CJK Compatibility Supplement
+  codePoint >= 196608 && codePoint <= 262141) {
+    return 2;
+  }
+  return 1;
+}
+
+// src/ui/markdown.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function MarkdownViewInner({ text }) {
+  const stablePrefixRef = useRef2("");
+  if (!text.startsWith(stablePrefixRef.current)) stablePrefixRef.current = "";
+  const boundary = stablePrefixRef.current.length;
+  const suffixTokens = useMemo2(() => {
+    try {
+      return marked.lexer(text.substring(boundary), { gfm: true, async: false });
+    } catch {
+      return [];
+    }
+  }, [text, boundary]);
+  let lastContentIndex = suffixTokens.length - 1;
+  while (lastContentIndex >= 0 && suffixTokens[lastContentIndex]?.type === "space") lastContentIndex--;
+  let advance = 0;
+  for (let index = 0; index < lastContentIndex; index++) advance += suffixTokens[index]?.raw.length ?? 0;
+  if (advance > 0) stablePrefixRef.current = text.substring(0, boundary + advance);
+  const stablePrefix = stablePrefixRef.current;
+  const unstableSuffix = text.substring(stablePrefix.length);
+  return /* @__PURE__ */ jsxs(Box_default, { flexDirection: "column", width: "100%", children: [
+    stablePrefix.length > 0 ? /* @__PURE__ */ jsx(MarkdownSegment, { text: stablePrefix }) : null,
+    unstableSuffix.length > 0 ? /* @__PURE__ */ jsx(MarkdownSegment, { text: unstableSuffix }) : null
+  ] });
+}
+var MarkdownSegment = React.memo(function MarkdownSegment2({ text }) {
+  const tokens = useMemo2(() => {
+    try {
+      return marked.lexer(text, { gfm: true, async: false });
+    } catch {
+      return [];
+    }
+  }, [text]);
+  return /* @__PURE__ */ jsx(Fragment, { children: tokens.map((token, index) => /* @__PURE__ */ jsx(BlockToken, { token }, index)) });
+});
+var MarkdownView = React.memo(MarkdownViewInner);
+var BlockToken = React.memo(function BlockToken2({ token }) {
+  switch (token.type) {
+    case "space":
+      return /* @__PURE__ */ jsx(Box_default, { height: 1 });
+    case "heading":
+      return /* @__PURE__ */ jsx(HeadingView, { token });
+    case "paragraph":
+      return /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsx(InlineTokens, { tokens: token.tokens ?? [] }) });
+    case "code":
+      return /* @__PURE__ */ jsx(CodeBlock, { token });
+    case "blockquote":
+      return /* @__PURE__ */ jsx(BlockquoteView, { token });
+    case "list":
+      return /* @__PURE__ */ jsx(ListView, { token });
+    case "hr":
+      return /* @__PURE__ */ jsx(HrView, {});
+    case "table":
+      return /* @__PURE__ */ jsx(TableView, { token });
+    case "html":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[html]" });
+    default:
+      if ("text" in token && typeof token.text === "string") {
+        return /* @__PURE__ */ jsx(Text, { children: token.text });
+      }
+      return null;
+  }
+});
+function HeadingView({ token }) {
+  const styled = useMemo2(() => {
+    const inner = renderInlineText(token.tokens);
+    switch (token.depth) {
+      case 1:
+        return chalk2.bold.hex("#7dd3fc")(inner);
+      case 2:
+        return chalk2.bold.hex("#67e8f9")(inner);
+      case 3:
+        return chalk2.bold.hex("#93c5fd")(inner);
+      default:
+        return chalk2.italic.hex("#93c5fd")(inner);
+    }
+  }, [token.depth, token.tokens]);
+  return /* @__PURE__ */ jsx(Text, { children: styled });
+}
+function CodeBlock({ token }) {
+  const { stdout } = useStdout();
+  const columns = stdout?.columns ?? 80;
+  const innerWidth = Math.max(20, columns - 6);
+  const styledSource = useMemo2(() => highlightCode(token.text, token.lang), [token.text, token.lang]);
+  const lines = useMemo2(() => styledSource.split("\n"), [styledSource]);
+  const truncated = useMemo2(() => lines.map((line) => truncateToWidth(line, innerWidth - 2)), [lines, innerWidth]);
+  const langLabel = token.lang?.trim();
+  const label = langLabel && langLabel.length > 0 ? langLabel : "code";
+  const topBarWidth = Math.max(0, columns - 4 - label.length - 4);
+  return /* @__PURE__ */ jsxs(Box_default, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "\u256D\u2500 ",
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: label }),
+      " ",
+      "\u2500".repeat(topBarWidth),
+      "\u256E"
+    ] }),
+    /* @__PURE__ */ jsx(Box_default, { flexDirection: "column", paddingX: 1, children: truncated.map((line, i) => /* @__PURE__ */ jsx(Text, { color: "gray", children: line }, i)) }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "\u2570",
+      "\u2500".repeat(Math.max(0, columns - 6)),
+      "\u256F"
+    ] })
+  ] });
+}
+function BlockquoteView({ token }) {
+  return /* @__PURE__ */ jsx(Box_default, { flexDirection: "column", children: token.tokens.map((child, i) => {
+    const inline = "tokens" in child ? child.tokens ?? [] : [];
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2502 " }),
+      /* @__PURE__ */ jsx(InlineTokens, { tokens: inline })
+    ] }, i);
+  }) });
+}
+function HrView() {
+  const { stdout } = useStdout();
+  const width = Math.max(8, (stdout?.columns ?? 80) - 4);
+  return /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2500".repeat(width) });
+}
+function ListView({ token }) {
+  const start = typeof token.start === "number" ? token.start : 1;
+  return /* @__PURE__ */ jsx(Box_default, { flexDirection: "column", children: token.items.map((item, i) => /* @__PURE__ */ jsx(ListItemView, { item, index: start + i, ordered: token.ordered }, i)) });
+}
+function ListItemView({
+  item,
+  index,
+  ordered
+}) {
+  const bullet = ordered ? `${index}.` : "-";
+  const inlineTokens = [];
+  const blockTokens = [];
+  let firstParagraphConsumed = false;
+  for (const child of item.tokens) {
+    if (child.type === "paragraph") {
+      const paragraph = child;
+      if (!firstParagraphConsumed) {
+        inlineTokens.push(paragraph);
+        firstParagraphConsumed = true;
+      } else {
+        blockTokens.push(child);
+      }
+    } else if (child.type === "text") {
+      inlineTokens.push(child);
+    } else {
+      blockTokens.push(child);
+    }
+  }
+  return /* @__PURE__ */ jsxs(Box_default, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+        bullet,
+        " "
+      ] }),
+      inlineTokens.map((child, i) => {
+        if (child.type === "paragraph") {
+          return /* @__PURE__ */ jsx(InlineTokens, { tokens: child.tokens ?? [] }, i);
+        }
+        const tokens = child.tokens ?? [];
+        return tokens.length > 0 ? /* @__PURE__ */ jsx(InlineTokens, { tokens }, i) : /* @__PURE__ */ jsx(Text, { children: child.text }, i);
+      })
+    ] }),
+    blockTokens.map((child, i) => /* @__PURE__ */ jsx(Box_default, { marginLeft: 2, children: /* @__PURE__ */ jsx(BlockToken, { token: child }) }, i))
+  ] });
+}
+function TableView({ token }) {
+  const { stdout } = useStdout();
+  const maxWidth = stdout?.columns ?? 80;
+  const colCount = token.header.length;
+  if (colCount === 0) return /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[empty table]" });
+  const colWidth = Math.max(8, Math.floor((maxWidth - colCount * 3) / colCount));
+  const pad = (value, w, align) => {
+    const stripped = stripAnsi2(value);
+    const width = Math.max(0, w);
+    if (stripped.length > width) return stripped.slice(0, width - 1) + "\u2026";
+    const diff = width - stripped.length;
+    if (align === "right") return " ".repeat(diff) + stripped;
+    if (align === "center") {
+      const left = Math.floor(diff / 2);
+      const right = diff - left;
+      return " ".repeat(left) + stripped + " ".repeat(right);
+    }
+    return stripped + " ".repeat(diff);
+  };
+  const separator = token.header.map((cell) => {
+    const align = cell.align;
+    if (align === "left") return ":" + "\u2500".repeat(colWidth - 2) + " ";
+    if (align === "right") return " " + "\u2500".repeat(colWidth - 2) + ":";
+    if (align === "center") return ":" + "\u2500".repeat(colWidth - 2) + ":";
+    return "\u2500".repeat(colWidth);
+  });
+  return /* @__PURE__ */ jsxs(Box_default, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { children: token.header.map((cell, i) => pad(cell.text, colWidth, cell.align ?? "left")).join(" \u2502 ") }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: separator.join(" \u2502 ") }),
+    token.rows.map((row, ri) => /* @__PURE__ */ jsx(Text, { children: row.map((cell, i) => pad(cell.text, colWidth, token.header[i]?.align ?? "left")).join(" \u2502 ") }, ri))
+  ] });
+}
+function InlineTokens({ tokens }) {
+  return /* @__PURE__ */ jsx(Text, { children: tokens.map((token, i) => /* @__PURE__ */ jsx(InlineToken, { token }, i)) });
+}
+function InlineToken({ token }) {
+  switch (token.type) {
+    case "text":
+      return /* @__PURE__ */ jsx(Text, { children: token.raw ?? token.text });
+    case "strong":
+      return /* @__PURE__ */ jsx(Text, { bold: true, children: renderInlineText(token.tokens) });
+    case "em":
+      return /* @__PURE__ */ jsx(Text, { italic: true, children: renderInlineText(token.tokens) });
+    case "del":
+      return /* @__PURE__ */ jsx(Text, { strikethrough: true, children: renderInlineText(token.tokens) });
+    case "codespan":
+      return /* @__PURE__ */ jsx(Text, { color: "black", backgroundColor: "gray", children: token.text });
+    case "link": {
+      const link = token;
+      const inner = renderInlineText(link.tokens);
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        inner,
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, color: "blue", children: [
+          " (",
+          link.href,
+          ")"
+        ] })
+      ] });
+    }
+    case "image": {
+      const img = token;
+      return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "[image: ",
+        img.text,
+        "]"
+      ] });
+    }
+    case "br":
+      return /* @__PURE__ */ jsx(Text, { children: "\n" });
+    case "escape":
+      return /* @__PURE__ */ jsx(Text, { children: token.text });
+    case "html":
+      return null;
+    default:
+      if ("text" in token && typeof token.text === "string") {
+        return /* @__PURE__ */ jsx(Text, { children: token.text });
+      }
+      return null;
+  }
+}
+var ANSI_RE = /\x1B\[[0-?]*[ -/]*[@-~]/g;
+function stripAnsi2(value) {
+  return value.replace(ANSI_RE, "");
+}
+function visibleWidth(value) {
+  let width = 0;
+  for (const ch of stripAnsi2(value)) {
+    width += charWidth(ch.codePointAt(0) ?? 0);
+  }
+  return width;
+}
+function truncateToWidth(value, width) {
+  if (width <= 0) return "";
+  const stripped = stripAnsi2(value);
+  if (visibleWidth(stripped) <= width) return value;
+  const prefix = value.match(/^\x1B\[[0-?]*[ -/]*[@-~]*/)?.[0] ?? "";
+  const suffix = "\x1B[0m";
+  let out = "";
+  let visual = 0;
+  for (const ch of stripped) {
+    const cw = charWidth(ch.codePointAt(0) ?? 0);
+    if (visual + cw > width - 1) break;
+    out += ch;
+    visual += cw;
+  }
+  return prefix + out + "\u2026" + suffix;
+}
+function renderInlineText(tokens) {
+  let out = "";
+  for (const tok of tokens) {
+    out += inlineTokenToString(tok);
+  }
+  return out;
+}
+function inlineTokenToString(token) {
+  switch (token.type) {
+    case "text":
+      return token.raw ?? token.text;
+    case "strong":
+      return chalk2.bold(renderInlineText(token.tokens));
+    case "em":
+      return chalk2.italic(renderInlineText(token.tokens));
+    case "del":
+      return chalk2.strikethrough(renderInlineText(token.tokens));
+    case "codespan":
+      return chalk2.bgGray.black(` ${token.text} `);
+    case "escape":
+      return token.text;
+    case "br":
+      return "\n";
+    case "link": {
+      const link = token;
+      const inner = renderInlineText(link.tokens);
+      return `${inner} ${chalk2.blue.underline.dim(`(${link.href})`)}`;
+    }
+    default:
+      if ("text" in token && typeof token.text === "string") return token.text;
+      return "";
+  }
+}
+
+// src/ui/assistant-text.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function AssistantTextInner({ text }) {
+  return /* @__PURE__ */ jsx2(MarkdownView, { text });
+}
+var AssistantText = React2.memo(AssistantTextInner);
+
+// src/ui/signals.ts
+function createSessionInterruptHandler(getSession, shutdown) {
+  return () => {
+    if (getSession()?.interrupt() === "cancelled") return;
+    void shutdown();
+  };
+}
+function installSigintHandler(source, handler) {
+  source.on("SIGINT", handler);
+  return () => {
+    source.off("SIGINT", handler);
+  };
+}
+
+// src/ui/wrap-prompt.ts
+function wrapPromptInput(input, codePointCursor, options) {
+  const indent = Math.max(0, options.indent ?? 2);
+  const columns = Math.max(1, options.columns);
+  const usable = Math.max(1, columns - indent);
+  const points = [...input];
+  const len = points.length;
+  const clamped = Math.max(0, Math.min(len, codePointCursor));
+  const lines = [];
+  let i = 0;
+  while (i < len) {
+    let lineVisualWidth = 0;
+    const lineStart = i;
+    while (i < len) {
+      const cp = points[i].codePointAt(0) ?? 0;
+      const cw = charWidth(cp);
+      if (lineVisualWidth + cw > usable) break;
+      lineVisualWidth += cw;
+      i += 1;
+    }
+    if (i === lineStart) i += 1;
+    lines.push(points.slice(lineStart, i).join(""));
+  }
+  if (lines.length === 0) lines.push("");
+  let cursor = { line: 0, column: 0 };
+  let consumed = 0;
+  for (let line = 0; line < lines.length; line += 1) {
+    const lineLength = [...lines[line] ?? ""].length;
+    const next = consumed + lineLength;
+    if (clamped <= next) {
+      cursor = { line, column: clamped - consumed };
+      break;
+    }
+    consumed = next;
+  }
+  return { lines, cursor, height: lines.length };
+}
+
+// src/ui/task-progress.tsx
+import { useRef as useRef3 } from "react";
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function TaskStatusLine({ block, interactive }) {
+  const running = block.state === "running";
+  const foreground = interactive && (block.activity === "model" || block.task?.role === "main");
+  const [ref, time] = useAnimationFrame(running && foreground ? 120 : null);
+  const startedAt = useRef3(void 0);
+  const previousState = useRef3(block.state);
+  if (running && (startedAt.current === void 0 || previousState.current !== "running")) startedAt.current = time;
+  if (!running) startedAt.current = void 0;
+  previousState.current = block.state;
+  const elapsed = block.startedAt === void 0 ? startedAt.current === void 0 ? 0 : Math.max(0, time - startedAt.current) : Math.max(0, Date.now() - block.startedAt);
+  const presentation = statusPresentation(block, elapsed, foreground);
+  const { statusLabel, statusColor, text } = presentation;
+  let before = text;
+  let after = "";
+  if (statusLabel !== void 0) {
+    const marker = ` \xB7 ${statusLabel}`;
+    const idx = before.indexOf(marker);
+    if (idx >= 0) {
+      after = before.slice(idx + marker.length);
+      before = before.slice(0, idx);
+    }
+  }
+  return /* @__PURE__ */ jsxs2(Box_default, { ref, flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs2(Text, { ...presentation.color === void 0 ? {} : { color: presentation.color }, children: [
+      presentation.glyph,
+      " "
+    ] }),
+    presentation.badge ? /* @__PURE__ */ jsxs2(Text, { color: presentation.badgeColor, children: [
+      presentation.badge,
+      " "
+    ] }) : null,
+    /* @__PURE__ */ jsx3(Text, { ...presentation.color === void 0 ? {} : { color: presentation.color }, children: before }),
+    statusLabel !== void 0 ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx3(Text, { ...presentation.color === void 0 ? {} : { color: presentation.color }, children: " \xB7 " }),
+      /* @__PURE__ */ jsx3(Text, { color: statusColor ?? presentation.color, children: statusLabel })
+    ] }) : null,
+    after ? /* @__PURE__ */ jsx3(Text, { ...presentation.color === void 0 ? {} : { color: presentation.color }, children: after }) : null
+  ] });
+}
+function TaskProgressPanel({
+  blocks,
+  interactive,
+  maxHeight = 8,
+  scrollRef,
+  onHoverChange
+}) {
+  if (blocks.length === 0 || maxHeight <= 0) return null;
+  return /* @__PURE__ */ jsxs2(
+    Box_default,
+    {
+      flexDirection: "column",
+      flexShrink: 0,
+      maxHeight,
+      onMouseEnter: () => onHoverChange?.(true),
+      onMouseLeave: () => onHoverChange?.(false),
+      children: [
+        /* @__PURE__ */ jsx3(Text, { dimColor: true, children: "\u2500\u2500 task progress \u2500\u2500" }),
+        maxHeight > 1 ? /* @__PURE__ */ jsx3(
+          ScrollBox_default,
+          {
+            ...scrollRef === void 0 ? {} : { ref: scrollRef },
+            flexDirection: "column",
+            flexShrink: 1,
+            maxHeight: maxHeight - 1,
+            children: blocks.map((block) => /* @__PURE__ */ jsx3(TaskStatusLine, { block, interactive }, block.id))
+          }
+        ) : null
+      ]
+    }
+  );
+}
+
+// src/ui/file-diff-style.ts
+var CONTENT = "#f8f8f2";
+function fileDiffLineStyle(kind) {
+  if (kind === "removed") {
+    return { backgroundColor: "#3d0100", markerColor: "#ff5f56", contentColor: CONTENT };
+  }
+  if (kind === "added") {
+    return { backgroundColor: "#022800", markerColor: "#50c878", contentColor: CONTENT };
+  }
+  return { markerColor: CONTENT, contentColor: CONTENT };
+}
+
+// src/ui/slash-completion.ts
+function slashCandidatePresentation(selected) {
+  return {
+    marker: selected ? "\u203A " : "  ",
+    rowStyle: {},
+    matchStyle: { color: "ansi:cyan", bold: true }
+  };
+}
+function buildSlashCandidates(commands, plugins, skills) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const command of commands) {
+    candidates.set(command.name, { name: command.name, kind: "command", description: command.description });
+  }
+  for (const name of plugins) {
+    if (!candidates.has(name)) candidates.set(name, { name, kind: "plugin" });
+  }
+  for (const skill of skills) {
+    if (!candidates.has(skill.name)) {
+      candidates.set(skill.name, {
+        name: skill.name,
+        kind: "skill",
+        description: skill.description,
+        source: skill.source
+      });
+    }
+  }
+  return [...candidates.values()];
+}
+function completedSlashTokenLength(input, candidates, menuOpen) {
+  if (menuOpen) return 0;
+  const points = [...input];
+  if (points[0] !== "/") return 0;
+  const whitespace = points.findIndex((point) => /\s/u.test(point));
+  let tokenEnd = whitespace < 0 ? points.length : whitespace;
+  const name = points.slice(1, tokenEnd).join("");
+  const matches = candidates.some((candidate) => candidate.name === name);
+  return matches ? tokenEnd : 0;
+}
+function completedSlashTokenPresentation() {
+  return { color: "rgb(120,155,255)", bold: true };
+}
+function deriveSlashCompletion(input, cursor, candidates, selectedIndex, visibleLimit = 6) {
+  const points = [...input];
+  const safeCursor = Math.max(0, Math.min(points.length, cursor));
+  if (points[0] !== "/") return null;
+  const whitespace = points.findIndex((point) => /\s/u.test(point));
+  const tokenEnd = whitespace < 0 ? points.length : whitespace;
+  if (safeCursor < 1 || safeCursor > tokenEnd) return null;
+  const query = points.slice(1, tokenEnd).join("");
+  const normalized = query.toLowerCase();
+  const items = candidates.filter(({ name }) => name.toLowerCase().includes(normalized)).sort((left, right) => {
+    const leftPrefix = left.name.toLowerCase().startsWith(normalized);
+    const rightPrefix = right.name.toLowerCase().startsWith(normalized);
+    if (leftPrefix !== rightPrefix) return leftPrefix ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+  if (items.length === 0) return null;
+  const selected = Math.max(0, Math.min(items.length - 1, selectedIndex));
+  const limit = Math.max(1, visibleLimit);
+  const windowStart = Math.max(0, Math.min(selected, items.length - limit));
+  return { query, items, selectedIndex: selected, windowStart };
+}
+function moveSlashSelection(index, delta, count) {
+  if (count <= 0) return 0;
+  return (index + delta + count) % count;
+}
+function completeSlashSelection(input, cursor, name) {
+  const points = [...input];
+  const safeCursor = Math.max(0, Math.min(points.length, cursor));
+  const tokenEndOffset = points.slice(safeCursor).findIndex((point) => /\s/u.test(point));
+  const tokenEnd = tokenEndOffset < 0 ? points.length : safeCursor + tokenEndOffset;
+  const suffix = points.slice(tokenEnd).join("").replace(/^\s*/u, "");
+  const prefix = `/${name} `;
+  return { text: prefix + suffix, cursor: [...prefix].length };
+}
+function matchRanges(value, query) {
+  if (query.length === 0) return [];
+  const normalizedValue = value.toLowerCase();
+  const normalizedQuery = query.toLowerCase();
+  const ranges = [];
+  let start = 0;
+  while (start < normalizedValue.length) {
+    const index = normalizedValue.indexOf(normalizedQuery, start);
+    if (index < 0) break;
+    ranges.push([index, index + normalizedQuery.length]);
+    start = index + normalizedQuery.length;
+  }
+  return ranges;
+}
+
+// src/ui/compact-progress.ts
+var COMPACT_PROGRESS_CELLS = 10;
+var COMPACT_PROGRESS_COMPLETE = "#5b8cff";
+var COMPACT_PROGRESS_REMAINING = "#525761";
+function compactProgressPresentation(progress) {
+  const normalized = Math.max(0, Math.min(100, Math.floor(progress / 10) * 10));
+  const completed = normalized / 10;
+  return {
+    progress: normalized,
+    cells: Array.from({ length: COMPACT_PROGRESS_CELLS }, (_, index) => ({
+      completed: index < completed,
+      color: index < completed ? COMPACT_PROGRESS_COMPLETE : COMPACT_PROGRESS_REMAINING
+    }))
+  };
+}
+
+// src/ui/mention-completion.ts
+function basename(path) {
+  const normalized = path.replaceAll("\\", "/");
+  const index = normalized.lastIndexOf("/");
+  return index < 0 ? path : normalized.slice(index + 1);
+}
+function mentionCandidatePresentation(selected) {
+  if (selected) {
+    const selectedText = { color: "rgb(120,155,255)", bold: true };
+    return {
+      marker: "\u203A ",
+      textStyle: selectedText,
+      highlightMatches: false,
+      matchStyle: { color: "ansi:cyan", bold: true }
+    };
+  }
+  return {
+    marker: "  ",
+    textStyle: {},
+    highlightMatches: true,
+    matchStyle: { color: "ansi:cyan", bold: true }
+  };
+}
+function buildMentionCandidates(paths) {
+  return [...new Set(paths.map((path) => path.replaceAll("\\", "/")))].sort(comparePaths);
+}
+function deriveMentionCompletion(input, cursor, candidates, selectedIndex, visibleLimit = 6) {
+  const token = mentionTokenAtCursor(input, cursor);
+  if (token === null) return null;
+  const normalizedQuery = token.query.toLowerCase();
+  const items = candidates.filter((path) => path.toLowerCase().includes(normalizedQuery)).sort((left, right) => {
+    const rankDelta = mentionRank(left, normalizedQuery) - mentionRank(right, normalizedQuery);
+    return rankDelta || comparePaths(left, right);
+  });
+  if (items.length === 0) return null;
+  const selected = Math.max(0, Math.min(items.length - 1, selectedIndex));
+  const limit = Math.max(1, visibleLimit);
+  const windowStart = Math.max(0, Math.min(selected, items.length - limit));
+  return { query: token.query, items, selectedIndex: selected, windowStart };
+}
+function moveMentionSelection(index, delta, count) {
+  if (count <= 0) return 0;
+  return (index + delta + count) % count;
+}
+function completeMentionSelection(input, cursor, path) {
+  const points = [...input];
+  const token = mentionTokenAtCursor(input, cursor);
+  const safeCursor = Math.max(0, Math.min(points.length, cursor));
+  if (token === null) return { text: input, cursor: safeCursor };
+  const escapedPath = path.replaceAll("\\", "/").replaceAll(" ", "\\ ");
+  const inserted = `@${escapedPath} `;
+  const prefix = points.slice(0, token.start).join("");
+  const suffix = points.slice(token.end).join("").replace(/^\s*/u, "");
+  return {
+    text: prefix + inserted + suffix,
+    cursor: [...prefix + inserted].length,
+    span: { start: [...prefix].length, end: [...prefix + inserted].length }
+  };
+}
+function mentionTokenAtCursor(input, cursor) {
+  const points = [...input];
+  const safeCursor = Math.max(0, Math.min(points.length, cursor));
+  let start = safeCursor;
+  while (start > 0 && !isTokenBoundary(points, start - 1)) start -= 1;
+  if (points[start] !== "@" || safeCursor <= start) return null;
+  let end = safeCursor;
+  while (end < points.length && !isTokenBoundary(points, end)) end += 1;
+  return {
+    start,
+    end,
+    query: unescapeQuery(points.slice(start + 1, end).join(""))
+  };
+}
+function isTokenBoundary(points, index) {
+  if (!/\s/u.test(points[index] ?? "")) return false;
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && points[cursor] === "\\"; cursor -= 1) slashCount += 1;
+  return slashCount % 2 === 0;
+}
+function unescapeQuery(value) {
+  return value.replace(/\\(\s)/gu, "$1");
+}
+function mentionRank(path, query) {
+  const normalizedPath = path.toLowerCase();
+  const filename = basename(normalizedPath);
+  if (filename.startsWith(query)) return 0;
+  if (normalizedPath.startsWith(query)) return 1;
+  return 2;
+}
+function comparePaths(left, right) {
+  return left.localeCompare(right, "en");
+}
+
+// src/ui/welcome.tsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var WIDE_WELCOME_COLUMNS = 72;
+var FLAVOR_ACCENT = "#67D4FF";
+var FLAVOR_WORDMARK = [
+  "\u250C\u2500\u2510\u252C  \u250C\u2500\u2510\u252C  \u252C\u250C\u2500\u2510\u252C\u2500\u2510",
+  "\u251C\u2524 \u2502  \u251C\u2500\u2524\u2514\u2510\u250C\u2518\u2502 \u2502\u251C\u252C\u2518",
+  "\u2514  \u2534\u2500\u2518\u2534 \u2534 \u2514\u2518 \u2514\u2500\u2518\u2534\u2514\u2500"
+].join("\n");
+function WelcomeCard({ model, serviceName, workspaceName, columns }) {
+  const wide = Math.max(1, Math.floor(columns)) >= WIDE_WELCOME_COLUMNS;
+  return /* @__PURE__ */ jsx4(Box_default, { width: "100%", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: wide ? /* @__PURE__ */ jsxs3(Box_default, { width: "100%", flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs3(
+      Box_default,
+      {
+        width: "36%",
+        flexDirection: "column",
+        alignItems: "center",
+        borderStyle: "single",
+        borderTop: false,
+        borderBottom: false,
+        borderLeft: false,
+        borderColor: "yellow",
+        paddingRight: 1,
+        children: [
+          /* @__PURE__ */ jsx4(Text, { bold: true, color: "yellowBright", children: "Welcome back!" }),
+          /* @__PURE__ */ jsx4(Text, { color: FLAVOR_ACCENT, children: FLAVOR_WORDMARK }),
+          serviceName === void 0 ? null : /* @__PURE__ */ jsx4(Text, { color: "cyan", wrap: "truncate-end", children: serviceName }),
+          /* @__PURE__ */ jsx4(Text, { dimColor: true, wrap: "truncate-end", children: model }),
+          /* @__PURE__ */ jsx4(Text, { dimColor: true, wrap: "truncate-end", children: workspaceName })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxs3(Box_default, { flexGrow: 1, flexDirection: "column", paddingLeft: 1, children: [
+      /* @__PURE__ */ jsx4(Text, { bold: true, color: "yellowBright", children: "Tips for getting started" }),
+      /* @__PURE__ */ jsxs3(Text, { children: [
+        "Run ",
+        /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/init" }),
+        " to create or refresh FLAVOR.md"
+      ] }),
+      /* @__PURE__ */ jsxs3(Text, { children: [
+        "Type ",
+        /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "@" }),
+        " to attach a project file"
+      ] }),
+      /* @__PURE__ */ jsx4(Box_default, { height: 1 }),
+      /* @__PURE__ */ jsx4(Text, { bold: true, color: "yellowBright", children: "Quick commands" }),
+      /* @__PURE__ */ jsxs3(Text, { children: [
+        /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/help" }),
+        " \xB7 ",
+        /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/config" }),
+        " \xB7 ",
+        /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/tasks" })
+      ] })
+    ] })
+  ] }) : /* @__PURE__ */ jsxs3(Box_default, { width: "100%", flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text, { bold: true, color: FLAVOR_ACCENT, children: "\u25C6 Flavor Code" }),
+    /* @__PURE__ */ jsx4(Text, { children: "Welcome back!" }),
+    /* @__PURE__ */ jsxs3(Text, { dimColor: true, wrap: "truncate-end", children: [
+      model,
+      " \xB7 ",
+      workspaceName
+    ] }),
+    /* @__PURE__ */ jsxs3(Text, { children: [
+      /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/init" }),
+      " setup \xB7 ",
+      /* @__PURE__ */ jsx4(Text, { color: "cyan", children: "/help" }),
+      " commands"
+    ] })
+  ] }) });
+}
+
+// src/session/assets.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import { mkdir, open, rename, rm } from "fs/promises";
+import { basename as basename2, join, resolve } from "path";
+var DEFAULT_MAX_IMAGES = 5;
+var DEFAULT_MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var DEFAULT_MAX_TOTAL_IMAGE_BYTES = 20 * 1024 * 1024;
+var SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var SessionAssetStore = class {
+  #root;
+  #maxImages;
+  #maxImageBytes;
+  #maxTotalBytes;
+  constructor(options) {
+    this.#root = join(resolve(options.workspace), ".flavor", "session-assets");
+    this.#maxImages = positiveInteger(options.maxImages ?? DEFAULT_MAX_IMAGES, "maxImages");
+    this.#maxImageBytes = positiveInteger(options.maxImageBytes ?? DEFAULT_MAX_IMAGE_BYTES, "maxImageBytes");
+    this.#maxTotalBytes = positiveInteger(options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_IMAGE_BYTES, "maxTotalBytes");
+  }
+  async store(sessionId, inputs) {
+    if (!SESSION_ID.test(sessionId)) throw new Error("Invalid session id");
+    if (inputs.length > this.#maxImages) {
+      throw new Error(`A prompt can contain at most ${this.#maxImages} images`);
+    }
+    const decoded = inputs.map((input) => decodeAttachment(input, this.#maxImageBytes));
+    const total = decoded.reduce((sum, item) => sum + item.data.byteLength, 0);
+    if (total > this.#maxTotalBytes) {
+      throw new Error(`Image attachments exceed the maximum total size of ${this.#maxTotalBytes} bytes`);
+    }
+    if (decoded.length === 0) return [];
+    const directory = join(this.#root, sessionId);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    const output = [];
+    for (const item of decoded) {
+      const sha256 = createHash("sha256").update(item.data).digest("hex");
+      const target = join(directory, `${sha256}${extension(item.mediaType)}`);
+      await writeOnce(target, item.data);
+      output.push({
+        type: "image",
+        source: { type: "file", path: target },
+        mediaType: item.mediaType,
+        sha256,
+        bytes: item.data.byteLength,
+        name: safeName(item.name)
+      });
+    }
+    return output;
+  }
+};
+function decodeAttachment(input, maxBytes) {
+  if (!input.name || input.name.length > 255) throw new Error("Image name must be between 1 and 255 characters");
+  if (!["image/png", "image/jpeg", "image/webp"].includes(input.mediaType)) {
+    throw new Error(`Unsupported image media type: ${String(input.mediaType)}`);
+  }
+  if (!input.dataBase64 || !BASE64.test(input.dataBase64)) throw new Error("Image data is not valid base64");
+  const data = Buffer.from(input.dataBase64, "base64");
+  if (data.toString("base64") !== input.dataBase64) throw new Error("Image data is not canonical base64");
+  if (data.byteLength > maxBytes) throw new Error(`Image exceeds the maximum size of ${maxBytes} bytes`);
+  const detected = detectMediaType(data);
+  if (detected !== input.mediaType) {
+    throw new Error(`Image media type ${input.mediaType} does not match file bytes`);
+  }
+  return { ...input, data };
+}
+function detectMediaType(data) {
+  if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg";
+  if (data.length >= 12 && data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP") return "image/webp";
+  return void 0;
+}
+function extension(mediaType) {
+  if (mediaType === "image/png") return ".png";
+  if (mediaType === "image/jpeg") return ".jpg";
+  return ".webp";
+}
+function safeName(name) {
+  return basename2(name).replace(/[\u0000-\u001f\u007f]/g, "_").slice(0, 255) || "image";
+}
+async function writeOnce(target, data) {
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  let handle;
+  try {
+    handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+    await handle.writeFile(data);
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    try {
+      await rename(temporary, target);
+    } catch (error) {
+      if (!isCode(error, "EEXIST") && !isCode(error, "EPERM")) throw error;
+    }
+  } finally {
+    await handle?.close().catch(() => void 0);
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+}
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer`);
+  return value;
+}
+function isCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+
+// src/ui/clipboard-image.ts
+var CLIPBOARD_TIMEOUT_MS = 1e4;
+var NO_IMAGE_EXIT_CODE = 3;
+var READ_WINDOWS_CLIPBOARD_IMAGE = String.raw`
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$image = [Windows.Forms.Clipboard]::GetImage()
+if ($null -eq $image) { exit 3 }
+$stream = New-Object System.IO.MemoryStream
+try {
+  $image.Save($stream, [System.Drawing.Imaging.ImageFormat]::Png)
+  [Console]::Out.Write([Convert]::ToBase64String($stream.ToArray()))
+} finally {
+  $stream.Dispose()
+  $image.Dispose()
+}
+`.trim();
+var READ_MAC_CLIPBOARD_IMAGE = String.raw`
+ObjC.import("AppKit");
+ObjC.import("Foundation");
+ObjC.import("stdlib");
+
+const pasteboard = $.NSPasteboard.generalPasteboard;
+let data = pasteboard.dataForType($.NSPasteboardTypePNG);
+if (!data) {
+  const tiff = pasteboard.dataForType($.NSPasteboardTypeTIFF);
+  if (tiff) {
+    const representation = $.NSBitmapImageRep.imageRepWithData(tiff);
+    if (representation) {
+      data = representation.representationUsingTypeProperties(
+        $.NSBitmapImageFileTypePNG,
+        $({})
+      );
+    }
+  }
+}
+if (!data) {
+  $.exit(3);
+}
+const encoded = data.base64EncodedStringWithOptions(0);
+console.log(ObjC.unwrap(encoded));
+`.trim();
+function shouldReadClipboardImage(input, key, isPasted) {
+  return (key.ctrl || key.meta === true) && input.toLowerCase() === "v" || isPasted && input.length === 0;
+}
+async function readClipboardImage(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") return readWindowsClipboardImage({ ...options, platform });
+  if (platform === "darwin") return readMacClipboardImage({ ...options, platform });
+  throw new Error("Pasting clipboard images is currently supported on Windows and macOS only");
+}
+async function readWindowsClipboardImage(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    throw new Error("Pasting clipboard images is currently supported on Windows only");
+  }
+  const result = await (options.run ?? execFileNoThrow)(
+    "powershell.exe",
+    ["-NoProfile", "-NonInteractive", "-STA", "-Command", READ_WINDOWS_CLIPBOARD_IMAGE],
+    { timeout: CLIPBOARD_TIMEOUT_MS, useCwd: false }
+  );
+  return attachmentFromResult(result, options.now?.() ?? /* @__PURE__ */ new Date());
+}
+async function readMacClipboardImage(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "darwin") {
+    throw new Error("Pasting clipboard images through AppKit is supported on macOS only");
+  }
+  const result = await (options.run ?? execFileNoThrow)(
+    "osascript",
+    ["-l", "JavaScript", "-e", READ_MAC_CLIPBOARD_IMAGE],
+    { timeout: CLIPBOARD_TIMEOUT_MS, useCwd: false }
+  );
+  return attachmentFromResult(result, options.now?.() ?? /* @__PURE__ */ new Date());
+}
+function attachmentFromResult(result, now) {
+  if (result.code === NO_IMAGE_EXIT_CODE) return void 0;
+  if (result.code !== 0) {
+    const detail = result.stderr.trim() || result.error?.trim();
+    throw new Error(detail ? `Could not read the clipboard image: ${detail}` : "Could not read the clipboard image");
+  }
+  const dataBase64 = result.stdout.trim();
+  if (dataBase64.length === 0) return void 0;
+  return {
+    name: `clipboard-${timestamp(now)}.png`,
+    mediaType: "image/png",
+    dataBase64
+  };
+}
+function timestamp(value) {
+  const year = value.getUTCFullYear();
+  const month = String(value.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(value.getUTCDate()).padStart(2, "0");
+  const hour = String(value.getUTCHours()).padStart(2, "0");
+  const minute = String(value.getUTCMinutes()).padStart(2, "0");
+  const second = String(value.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}-${hour}${minute}${second}`;
+}
+
+// src/ui/app.tsx
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var HISTORY_CAP = 200;
+var BUILTIN_SLASH_CANDIDATES = MVP_COMMANDS.map((name) => ({ name, description: COMMAND_DESCRIPTIONS[name] }));
+var PROMPT_HORIZONTAL_PADDING = 1;
+function removeLastCliImageOnBackspace(input, cursor, images) {
+  if (input.length === 0 && cursor === 0 && images.length > 0) {
+    return { handled: true, images: images.slice(0, -1) };
+  }
+  return { handled: false, images: [...images] };
+}
+function prepareCliSubmission(input, images, activeSession) {
+  const entered = input.trim();
+  if (entered.length === 0 && images.length === 0) return { kind: "empty" };
+  if (images.length > 0 && entered.startsWith("/")) {
+    return { kind: "error", message: "Image attachments cannot be used with slash commands." };
+  }
+  if (images.length > 0 && activeSession) {
+    return { kind: "error", message: "Images can only be attached to a new prompt." };
+  }
+  const text = entered || "Analyze the attached image(s).";
+  if (images.length === 0) return { kind: "ready", text, displayText: text };
+  const content = [{ type: "text", text }, ...images];
+  return {
+    kind: "ready",
+    text,
+    displayText: modelContentTranscriptText(content),
+    content
+  };
+}
+function promptDelivery(activeSession, key) {
+  if (!activeSession) return "prompt";
+  return "followUp";
+}
+function resolvePromptDelivery(activeSession, key, input) {
+  if (activeSession) {
+    const followUp = input.match(/^\/follow-?up\s+([\s\S]+)$/iu);
+    if (followUp !== null) return { delivery: "followUp", prompt: followUp[1].trim() };
+    const steer = input.match(/^\/steer\s+([\s\S]+)$/iu);
+    if (steer !== null) return { delivery: "steer", prompt: steer[1].trim() };
+  }
+  return { delivery: promptDelivery(activeSession, key), prompt: input };
+}
+var SinglePendingPrompt = class {
+  #value;
+  get value() {
+    return this.#value;
+  }
+  queue(prompt) {
+    const value = prompt.trim();
+    if (value.length === 0 || this.#value !== void 0) return false;
+    this.#value = value;
+    return true;
+  }
+  cancel() {
+    const value = this.#value;
+    this.#value = void 0;
+    return value;
+  }
+  take() {
+    return this.cancel();
+  }
+};
+async function runTerminalSubmissionChain(options) {
+  let prompt = options.initialPrompt;
+  let initial = true;
+  while (prompt !== void 0) {
+    options.onStart(initial ? options.initialDisplayPrompt ?? prompt : prompt);
+    if (initial && options.initialSubmit !== void 0) {
+      try {
+        await options.initialSubmit(prompt);
+      } catch (error) {
+        safeReport(options.report, safeUiError(error));
+      }
+    } else {
+      await submitSafely(options.session, prompt, options.report);
+    }
+    options.onFinish();
+    if (options.shouldContinue?.() === false) return;
+    prompt = options.pending.take();
+    if (prompt !== void 0) options.onPendingConsumed();
+    initial = false;
+  }
+}
+function classifyTerminalInput(key) {
+  if (key.wheelUp) return { type: "scroll", rows: -3 };
+  if (key.wheelDown) return { type: "scroll", rows: 3 };
+  if (key.pageUp) return { type: "page", fraction: -0.5 };
+  if (key.pageDown) return { type: "page", fraction: 0.5 };
+  if (key.upArrow) return { type: "history", direction: "up" };
+  if (key.downArrow) return { type: "history", direction: "down" };
+  return null;
+}
+function completionKeyAction(key, menuOpen) {
+  if (!menuOpen) return null;
+  if (key.upArrow) return { type: "select", delta: -1 };
+  if (key.downArrow) return { type: "select", delta: 1 };
+  if (key.tab) return { type: "complete" };
+  if (key.escape) return { type: "dismiss" };
+  return null;
+}
+function slashKeyAction(key, completion) {
+  return completionKeyAction(key, completion !== null);
+}
+function App({ workspace, home, resumeSession }) {
+  const { exit } = use_app_default();
+  const { stdout } = useStdout();
+  const [runtime, setRuntime] = useState2();
+  const [input, setInput] = useState2("");
+  const [pastedBlocks, setPastedBlocks] = useState2([]);
+  const [imageAttachments, setImageAttachments] = useState2([]);
+  const [clipboardNotice, setClipboardNotice] = useState2();
+  const [history, setHistory] = useState2([]);
+  const [historyCursor, setHistoryCursor] = useState2(0);
+  const [promptCursor, setPromptCursor] = useState2(0);
+  const [slashCandidates, setSlashCandidates] = useState2(
+    () => buildSlashCandidates(BUILTIN_SLASH_CANDIDATES, [], [])
+  );
+  const [slashSelection, setSlashSelection] = useState2(0);
+  const [dismissedSlashInput, setDismissedSlashInput] = useState2();
+  const [mentionCandidates, setMentionCandidates] = useState2([]);
+  const [mentionSelection, setMentionSelection] = useState2(0);
+  const [dismissedMentionInput, setDismissedMentionInput] = useState2();
+  const [pendingPrompt, setPendingPrompt] = useState2();
+  const [revision, setRevision] = useState2(0);
+  const [ideContext, setIdeContext] = useState2();
+  const [questionIndex, setQuestionIndex] = useState2(0);
+  const [questionAnswers, setQuestionAnswers] = useState2({});
+  const [customQuestionActive, setCustomQuestionActive] = useState2(false);
+  const [columns, setColumns] = useState2(stdout?.columns ?? 80);
+  const [rows, setRows] = useState2(stdout?.rows ?? 24);
+  const [transcript, dispatch] = useReducer(transcriptReducer, void 0, createTranscriptState);
+  const scrollRef = useRef4(null);
+  const taskScrollRef = useRef4(null);
+  const taskPanelHovered = useRef4(false);
+  const runtimeRef = useRef4(void 0);
+  const pendingPromptRef = useRef4(void 0);
+  pendingPromptRef.current ??= new SinglePendingPrompt();
+  const closing = useRef4(false);
+  const clipboardBusy = useRef4(false);
+  const textBuf = useRef4({ pending: "", timer: null });
+  useTerminalTitle("Flavor Code");
+  const flushText = () => {
+    const t = textBuf.current;
+    if (t.timer !== null) {
+      clearTimeout(t.timer);
+      t.timer = null;
+    }
+    if (t.pending.length > 0) {
+      dispatch({ type: "session", event: { type: "text", text: t.pending } });
+      t.pending = "";
+    }
+  };
+  const shutdown = async (active) => {
+    if (closing.current) return;
+    closing.current = true;
+    await shutdownRuntime(active, exit, (error) => {
+      dispatch({ type: "submit-error", message: error });
+    });
+  };
+  const shutdownRef = useRef4(shutdown);
+  shutdownRef.current = shutdown;
+  const interruptRef = useRef4(void 0);
+  interruptRef.current ??= createSessionInterruptHandler(
+    () => runtimeRef.current?.session,
+    () => shutdownRef.current(runtimeRef.current)
+  );
+  const interrupt = interruptRef.current;
+  useEffect3(() => {
+    let disposed = false;
+    const FLUSH_MS = 100;
+    const receive = (event) => {
+      if (event.type === "exit") {
+        flushText();
+        void shutdownRef.current(runtimeRef.current);
+        return;
+      }
+      if (event.type === "clear") {
+        flushText();
+        dispatch({ type: "clear" });
+        return;
+      }
+      if (event.type === "text") {
+        const t = textBuf.current;
+        t.pending += event.text;
+        if (t.timer === null) t.timer = setTimeout(flushText, FLUSH_MS);
+        return;
+      }
+      flushText();
+      dispatch({ type: "session", event });
+    };
+    void createProductionRuntime({
+      workspace,
+      ...home === void 0 ? {} : { home },
+      ...resumeSession === void 0 ? {} : { resumeSession },
+      output: receive,
+      onApprovalChange: () => setRevision((value) => value + 1)
+    }).then(async (created) => {
+      if (disposed) {
+        await created.dispose();
+        return;
+      }
+      dispatch({ type: "restore", state: created.restoredTranscript });
+      runtimeRef.current = created;
+      setSlashCandidates(buildSlashCandidates(BUILTIN_SLASH_CANDIDATES, created.services.pluginCommands(), []));
+      setRuntime(created);
+      await created.session.start();
+      try {
+        const skills = await created.services.skills();
+        if (!disposed) {
+          setSlashCandidates(buildSlashCandidates(BUILTIN_SLASH_CANDIDATES, created.services.pluginCommands(), skills));
+        }
+      } catch {
+      }
+    }).catch((error) => {
+      dispatch({ type: "submit", prompt: "startup" });
+      dispatch({ type: "submit-error", message: safeUiError(error) });
+    });
+    return () => {
+      disposed = true;
+      flushText();
+      void closeAndDisposeRuntime(runtimeRef.current, (error) => process.stderr.write(`flavor cleanup: ${error}
+`));
+    };
+  }, [workspace, home, resumeSession]);
+  useEffect3(() => installSigintHandler(process, interrupt), [interrupt]);
+  useEffect3(() => {
+    if (runtime?.services.ideContext === void 0) {
+      setIdeContext(void 0);
+      return;
+    }
+    let disposed = false;
+    let refreshing = false;
+    let previous = "";
+    const refresh = async () => {
+      if (refreshing) return;
+      refreshing = true;
+      try {
+        const next = await runtime.services.ideContext().catch(() => void 0);
+        if (disposed) return;
+        const serialized = JSON.stringify(next);
+        if (serialized !== previous) {
+          previous = serialized;
+          setIdeContext(next);
+        }
+      } finally {
+        refreshing = false;
+      }
+    };
+    void refresh();
+    const timer = setInterval(() => void refresh(), 400);
+    return () => {
+      disposed = true;
+      clearInterval(timer);
+    };
+  }, [runtime]);
+  useEffect3(() => {
+    const controller = new AbortController();
+    let disposed = false;
+    void createGlobTool(workspace, { defaultLimit: 1e4 }).execute({ pattern: "**", limit: 1e4 }, controller.signal).then((result) => {
+      if (!disposed) {
+        setMentionCandidates(buildMentionCandidates(result.matches));
+      }
+    }).catch(() => {
+    });
+    return () => {
+      disposed = true;
+      controller.abort();
+    };
+  }, [workspace]);
+  useEffect3(() => {
+    if (!stdout || typeof stdout.on !== "function") return;
+    const onResize = () => {
+      setColumns(stdout.columns ?? 80);
+      setRows(stdout.rows ?? 24);
+    };
+    stdout.on("resize", onResize);
+    onResize();
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  const approval = runtime?.approvals.pending;
+  const questions = runtime?.services.questions.pending;
+  const memoryReviews = runtime?.memoryReviews.pending ?? [];
+  const memoryAutoDismissSeconds = runtime?.memoryReviews.autoDismissSeconds ?? 0;
+  useEffect3(() => {
+    setQuestionIndex(0);
+    setQuestionAnswers({});
+    setCustomQuestionActive(false);
+  }, [questions]);
+  const derivedSlashCompletion = deriveSlashCompletion(input, promptCursor, slashCandidates, slashSelection);
+  const slashCompletion = dismissedSlashInput === input || transcript.active !== void 0 || approval !== void 0 || questions !== void 0 ? null : derivedSlashCompletion;
+  const derivedMentionCompletion = slashCompletion === null ? deriveMentionCompletion(input, promptCursor, mentionCandidates, mentionSelection) : null;
+  const mentionCompletion = dismissedMentionInput === input || transcript.active !== void 0 || approval !== void 0 || questions !== void 0 ? null : derivedMentionCompletion;
+  const completedTokenLength = completedSlashTokenLength(input, slashCandidates, slashCompletion !== null);
+  const selection = useSelection();
+  const selectMention = (path) => {
+    const next = completeMentionSelection(input, promptCursor, path);
+    setInput(next.text);
+    setPromptCursor(next.cursor);
+    setMentionSelection(0);
+    setDismissedMentionInput(next.text);
+  };
+  const pasteClipboardImage = async () => {
+    const active = runtimeRef.current;
+    if (active === void 0) {
+      setClipboardNotice("Flavor is still starting; try pasting the image again.");
+      return;
+    }
+    if (transcript.active !== void 0) {
+      setClipboardNotice("Images can only be attached to a new prompt.");
+      return;
+    }
+    if (imageAttachments.length >= DEFAULT_MAX_IMAGES) {
+      setClipboardNotice(`A prompt can contain at most ${DEFAULT_MAX_IMAGES} images.`);
+      return;
+    }
+    if (clipboardBusy.current) return;
+    clipboardBusy.current = true;
+    setClipboardNotice("Reading image from clipboard...");
+    try {
+      const attachment = await readClipboardImage();
+      if (attachment === void 0) {
+        setClipboardNotice("Clipboard does not contain an image.");
+        return;
+      }
+      const incomingBytes = Buffer.byteLength(attachment.dataBase64, "base64");
+      const currentBytes = imageAttachments.reduce((sum, image) => sum + image.bytes, 0);
+      if (currentBytes + incomingBytes > DEFAULT_MAX_TOTAL_IMAGE_BYTES) {
+        throw new Error(`Image attachments exceed the maximum total size of ${DEFAULT_MAX_TOTAL_IMAGE_BYTES} bytes`);
+      }
+      const [stored] = await new SessionAssetStore({ workspace }).store(active.sessionId, [attachment]);
+      if (stored === void 0) throw new Error("Clipboard image could not be stored");
+      setImageAttachments((current) => [...current, stored]);
+      setClipboardNotice(`Added [Image #${imageAttachments.length + 1}] ${stored.name ?? basename3(stored.source.path)}`);
+    } catch (error) {
+      setClipboardNotice(safeUiError(error));
+    } finally {
+      clipboardBusy.current = false;
+    }
+  };
+  use_input_default((character, key, event) => {
+    const terminalAction = classifyTerminalInput(key);
+    if (terminalAction?.type === "scroll") {
+      const scroll = selectWheelScrollTarget(scrollRef.current, taskScrollRef.current, taskPanelHovered.current);
+      if (scroll !== null) {
+        if (terminalAction.rows < 0) scrollUp(scroll, -terminalAction.rows);
+        else scrollDown(scroll, terminalAction.rows);
+      }
+      return;
+    }
+    if (terminalAction?.type === "page") {
+      const scroll = scrollRef.current;
+      if (scroll !== null) jumpScroll(scroll, Math.floor(scroll.getViewportHeight() * terminalAction.fraction));
+      return;
+    }
+    const active = runtimeRef.current;
+    if (key.ctrl && character === "c") {
+      if (selection.hasSelection()) {
+        selection.copySelection();
+      } else {
+        interrupt();
+      }
+      return;
+    }
+    if (shouldReadClipboardImage(character, key, event.keypress.isPasted)) {
+      void pasteClipboardImage();
+      return;
+    }
+    if (active?.approvals.pending !== void 0) {
+      if (character.toLowerCase() === "y") active.approvals.resolve("once");
+      if (character.toLowerCase() === "n" || key.escape) active.approvals.resolve("deny");
+      if (character.toLowerCase() === "a") {
+        if (isDestructiveTool(active.approvals.pending.tool)) {
+          active.approvals.resolve("once");
+        } else {
+          active.approvals.resolve("always");
+        }
+      }
+      return;
+    }
+    const pendingMemory = active?.memoryReviews.pending[0];
+    if (pendingMemory !== void 0 && key.ctrl && (character.toLowerCase() === "y" || character.toLowerCase() === "n")) {
+      if (character.toLowerCase() === "y") {
+        void active.memoryReviews.accept(pendingMemory.id).catch((error) => {
+          dispatch({ type: "submit-error", message: safeUiError(error) });
+        });
+      } else active.memoryReviews.dismiss(pendingMemory.id);
+      return;
+    }
+    const qs = active?.services.questions.pending;
+    if (qs !== void 0 && qs.length > 0) {
+      const questionsService = active.services.questions;
+      const currentIndex = Math.min(questionIndex, qs.length - 1);
+      const question = qs[currentIndex];
+      const commitQuestionAnswer = (answer) => {
+        const next = { ...questionAnswers, [currentIndex]: answer };
+        setInput("");
+        setPromptCursor(0);
+        setCustomQuestionActive(false);
+        if (currentIndex === qs.length - 1) {
+          setQuestionAnswers({});
+          setQuestionIndex(0);
+          questionsService.answer(next);
+        } else {
+          setQuestionAnswers(next);
+          setQuestionIndex(currentIndex + 1);
+        }
+      };
+      if (key.escape) {
+        if (customQuestionActive) {
+          setCustomQuestionActive(false);
+          setInput("");
+          setPromptCursor(0);
+        } else questionsService.cancel();
+        return;
+      }
+      if (customQuestionActive) {
+        if (key.return) {
+          const answer = input.trim();
+          if (answer) commitQuestionAnswer(answer);
+          return;
+        }
+      } else {
+        const digit = parseInt(character, 10);
+        if (digit >= 1 && digit <= question.options.length) {
+          commitQuestionAnswer(question.options[digit - 1].label);
+          return;
+        }
+        if (digit === question.options.length + 1) {
+          setCustomQuestionActive(true);
+          setInput("");
+          setPromptCursor(0);
+          return;
+        }
+        if (!key.ctrl && !key.meta && character) setCustomQuestionActive(true);
+        else return;
+      }
+    }
+    if (key.escape && transcript.active !== void 0) {
+      const restored = pendingPromptRef.current.cancel();
+      if (restored !== void 0) {
+        setPendingPrompt(void 0);
+        setInput(restored);
+        setPastedBlocks([]);
+        setPromptCursor([...restored].length);
+        setSlashSelection(0);
+        setDismissedSlashInput(void 0);
+        setMentionSelection(0);
+        setDismissedMentionInput(void 0);
+        return;
+      }
+    }
+    const menuAction = slashKeyAction(key, slashCompletion);
+    if (menuAction?.type === "select" && slashCompletion !== null) {
+      setSlashSelection((value) => moveSlashSelection(value, menuAction.delta, slashCompletion.items.length));
+      return;
+    }
+    if (menuAction?.type === "complete" && slashCompletion !== null) {
+      const selected = slashCompletion.items[slashCompletion.selectedIndex];
+      if (selected !== void 0) {
+        const next = completeSlashSelection(input, promptCursor, selected.name);
+        setInput(next.text);
+        setPromptCursor(next.cursor);
+        setDismissedSlashInput(next.text);
+      }
+      return;
+    }
+    if (menuAction?.type === "dismiss") {
+      setDismissedSlashInput(input);
+      return;
+    }
+    const mentionAction = completionKeyAction(key, mentionCompletion !== null);
+    if (mentionAction?.type === "select" && mentionCompletion !== null) {
+      setMentionSelection((value) => moveMentionSelection(value, mentionAction.delta, mentionCompletion.items.length));
+      return;
+    }
+    if (mentionAction?.type === "complete" && mentionCompletion !== null) {
+      const selected = mentionCompletion.items[mentionCompletion.selectedIndex];
+      if (selected !== void 0) selectMention(selected);
+      return;
+    }
+    if (mentionAction?.type === "dismiss") {
+      setDismissedMentionInput(input);
+      return;
+    }
+    if (key.return) {
+      const images = [...imageAttachments];
+      const prepared = prepareCliSubmission(input, images, transcript.active !== void 0);
+      if (prepared.kind === "empty" || active === void 0) return;
+      if (prepared.kind === "error") {
+        setClipboardNotice(prepared.message);
+        return;
+      }
+      const submittedText = prepared.text;
+      const { delivery, prompt } = resolvePromptDelivery(transcript.active !== void 0, key, submittedText);
+      if (!prompt) return;
+      if (delivery === "followUp" && transcript.active !== void 0) {
+        if (!pendingPromptRef.current.queue(prompt)) return;
+        setPendingPrompt(prompt);
+      }
+      scrollRef.current?.scrollToBottom();
+      setHistory((current) => [...current, submittedText].slice(-HISTORY_CAP));
+      setHistoryCursor(history.length + 1);
+      setInput("");
+      setPastedBlocks([]);
+      setImageAttachments([]);
+      setClipboardNotice(void 0);
+      setPromptCursor(0);
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+      if (delivery === "prompt") {
+        void runTerminalSubmissionChain({
+          session: active.session,
+          initialPrompt: prompt,
+          ...prepared.content === void 0 ? {} : {
+            initialDisplayPrompt: prepared.displayText,
+            initialSubmit: (text) => active.session.submit({
+              text,
+              content: prepared.content
+            })
+          },
+          pending: pendingPromptRef.current,
+          onStart: (next) => dispatch({ type: "submit", prompt: next }),
+          onFinish: () => dispatch({ type: "finish" }),
+          onPendingConsumed: () => setPendingPrompt(void 0),
+          report: (error) => dispatch({ type: "submit-error", message: error }),
+          shouldContinue: () => !closing.current
+        });
+      } else if (delivery === "steer") {
+        try {
+          active.session.steer(prompt);
+        } catch (error) {
+          dispatch({ type: "submit-error", message: safeUiError(error) });
+        }
+      }
+      return;
+    }
+    if (key.backspace) {
+      const imageEdit = removeLastCliImageOnBackspace(input, promptCursor, imageAttachments);
+      if (imageEdit.handled) {
+        setImageAttachments(imageEdit.images);
+        setClipboardNotice(imageEdit.images.length === 0 ? "Removed image attachment." : `Removed image attachment; ${imageEdit.images.length} remaining.`);
+        return;
+      }
+      const next = editPromptWithPastedBlocks(
+        { text: input, cursor: promptCursor },
+        { type: "backspace" },
+        pastedBlocks
+      );
+      setInput(next.text);
+      setPromptCursor(next.cursor);
+      setPastedBlocks(next.pastedBlocks);
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+    } else if (key.delete) {
+      updatePrompt({ type: "delete" }, input, promptCursor, setInput, setPromptCursor);
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+    } else if (key.leftArrow) setPromptCursor((value) => Math.max(0, value - 1));
+    else if (key.rightArrow) setPromptCursor((value) => Math.min([...input].length, value + 1));
+    else if (terminalAction?.type === "history" && terminalAction.direction === "up" && history.length) {
+      const next = navigateHistory({ history, cursor: historyCursor }, "up");
+      setHistoryCursor(next.cursor);
+      setInput(next.input);
+      setPromptCursor(next.promptCursor);
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+    } else if (terminalAction?.type === "history" && terminalAction.direction === "down" && history.length) {
+      const next = navigateHistory({ history, cursor: historyCursor }, "down");
+      setHistoryCursor(next.cursor);
+      setInput(next.input);
+      setPromptCursor(next.promptCursor);
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+    } else if (!key.ctrl && !key.meta && character) {
+      updatePrompt({ type: "insert", value: character }, input, promptCursor, setInput, setPromptCursor);
+      if (/[\r\n]/u.test(character)) {
+        setPastedBlocks((current) => [...current, { id: current.length + 1, text: character }]);
+      }
+      setSlashSelection(0);
+      setDismissedSlashInput(void 0);
+      setMentionSelection(0);
+      setDismissedMentionInput(void 0);
+    }
+  });
+  void revision;
+  if (runtime === void 0) return /* @__PURE__ */ jsx5(
+    StartingLayout,
+    {
+      workspaceName: basename3(workspace),
+      completed: transcript.completed,
+      ...transcript.active === void 0 ? {} : { active: transcript.active },
+      columns,
+      rows
+    }
+  );
+  const llmServiceName = runtime.services.llmServiceName?.();
+  return /* @__PURE__ */ jsx5(
+    TerminalLayout,
+    {
+      model: runtime.services.mainModel(),
+      ...llmServiceName === void 0 ? {} : { serviceName: llmServiceName },
+      workspaceName: basename3(workspace),
+      completed: transcript.completed,
+      ...transcript.active === void 0 ? {} : { active: transcript.active },
+      input,
+      pastedBlocks,
+      imageAttachments,
+      ...clipboardNotice === void 0 ? {} : { clipboardNotice },
+      promptCursor,
+      onPromptCursorChange: setPromptCursor,
+      columns,
+      rows,
+      activeSession: transcript.active !== void 0,
+      ...ideContext === void 0 ? {} : { ideContext },
+      completedSlashTokenLength: completedTokenLength,
+      scrollRef,
+      taskScrollRef,
+      onTaskPanelHoverChange: (hovered) => {
+        taskPanelHovered.current = hovered;
+      },
+      ...slashCompletion === null ? {} : { completion: slashCompletion },
+      ...mentionCompletion === null ? {} : { mentionCompletion, onMentionSelect: selectMention },
+      ...approval === void 0 ? {} : { approval },
+      ...questions === void 0 ? {} : { questions },
+      memoryReviews,
+      memoryAutoDismissSeconds,
+      ...pendingPrompt === void 0 ? {} : { pendingPrompt },
+      questionIndex,
+      questionAnswers,
+      customQuestionActive
+    }
+  );
+}
+function StartingLayout({
+  workspaceName,
+  completed,
+  active,
+  columns,
+  rows
+}) {
+  return /* @__PURE__ */ jsx5(
+    TerminalLayout,
+    {
+      model: "starting",
+      workspaceName,
+      completed,
+      ...active === void 0 ? {} : { active },
+      input: "",
+      promptCursor: 0,
+      columns,
+      rows,
+      activeSession: false
+    }
+  );
+}
+function TerminalLayout({
+  model,
+  serviceName,
+  workspaceName,
+  completed,
+  active,
+  input,
+  pastedBlocks = [],
+  imageAttachments = [],
+  clipboardNotice,
+  promptCursor,
+  columns,
+  rows = 24,
+  activeSession,
+  pendingPrompt,
+  approval,
+  questions,
+  memoryReviews = [],
+  memoryAutoDismissSeconds = 0,
+  questionIndex = 0,
+  questionAnswers = {},
+  customQuestionActive = false,
+  completion,
+  mentionCompletion,
+  onMentionSelect,
+  completedSlashTokenLength: tokenLength = 0,
+  scrollRef,
+  taskScrollRef,
+  onTaskPanelHoverChange,
+  onPromptCursorChange,
+  ideContext
+}) {
+  const dividerWidth = Math.max(1, columns - 1);
+  const showWelcome = completed.length === 0 && active === void 0;
+  const activeCompletion = completion ?? mentionCompletion;
+  const menuRows = activeCompletion === void 0 ? 0 : Math.min(6, activeCompletion.items.length - activeCompletion.windowStart);
+  const activeTaskBlocks = active?.blocks.filter(
+    (block) => block.kind === "status" && block.task !== void 0
+  ) ?? [];
+  const activeWithoutTasks = active === void 0 ? void 0 : {
+    ...active,
+    blocks: active.blocks.filter(
+      (block) => !(block.kind === "status" && block.task !== void 0)
+    )
+  };
+  const questionRows = questions === void 0 ? 0 : 4 + (questions[questionIndex]?.options.length ?? 0) + questions.length * 2;
+  const memoryReviewRows = memoryReviews.length === 0 ? 0 : 5;
+  const fixedBottomRows = (approval === void 0 ? 0 : 3) + questionRows + memoryReviewRows + menuRows + (pendingPrompt === void 0 ? 0 : 1) + imageAttachments.length + (clipboardNotice === void 0 ? 0 : 1) + 2;
+  const taskPanelRows = taskPanelViewportRows(rows, fixedBottomRows, activeTaskBlocks.length > 0);
+  const availableBottomRows = Math.max(1, rows - taskPanelRows - 1);
+  const bottomMaxRows = Math.min(availableBottomRows, Math.max(Math.floor(rows / 2), fixedBottomRows + 1));
+  const promptMaxLines = Math.max(1, bottomMaxRows - fixedBottomRows);
+  return /* @__PURE__ */ jsxs4(Box_default, { height: rows, width: "100%", flexDirection: "column", overflow: "hidden", children: [
+    /* @__PURE__ */ jsxs4(ScrollBox_default, { ...scrollRef === void 0 ? {} : { ref: scrollRef }, flexGrow: 1, flexDirection: "column", stickyScroll: true, children: [
+      showWelcome ? /* @__PURE__ */ jsx5(WelcomeCard, { model, ...serviceName === void 0 ? {} : { serviceName }, workspaceName, columns }) : /* @__PURE__ */ jsxs4(Text, { dimColor: true, children: [
+        "flavor \xB7 ",
+        model,
+        " \xB7 ",
+        workspaceName
+      ] }),
+      /* @__PURE__ */ jsx5(Box_default, { height: 1 }),
+      completed.map((turn, index) => /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", children: [
+        index > 0 ? /* @__PURE__ */ jsx5(TurnSeparator, { width: columns }) : null,
+        /* @__PURE__ */ jsx5(TurnView, { turn, interactive: false })
+      ] }, turn.id)),
+      activeWithoutTasks === void 0 ? null : /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", children: [
+        completed.length > 0 ? /* @__PURE__ */ jsx5(TurnSeparator, { width: columns }) : null,
+        /* @__PURE__ */ jsx5(TurnView, { turn: activeWithoutTasks, interactive: activeSession })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(
+      TaskProgressPanel,
+      {
+        blocks: activeTaskBlocks,
+        interactive: activeSession,
+        maxHeight: taskPanelRows,
+        ...taskScrollRef === void 0 ? {} : { scrollRef: taskScrollRef },
+        ...onTaskPanelHoverChange === void 0 ? {} : { onHoverChange: onTaskPanelHoverChange }
+      }
+    ),
+    /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", flexShrink: 0, maxHeight: bottomMaxRows, width: "100%", overflowY: "hidden", children: [
+      approval === void 0 ? null : /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs4(Text, { color: "magenta", children: [
+          "\u250C\u2500 approval \xB7 ",
+          approval.tool
+        ] }),
+        /* @__PURE__ */ jsxs4(Text, { wrap: "truncate-end", color: "magentaBright", children: [
+          "\u2502 ",
+          approval.reason ?? "This action needs permission."
+        ] }),
+        isDestructiveTool(approval.tool) ? /* @__PURE__ */ jsxs4(Text, { bold: true, color: "magenta", children: [
+          "\u2514\u2500 Allow? ",
+          /* @__PURE__ */ jsx5(Text, { color: "green", children: "y" }),
+          "=once / ",
+          /* @__PURE__ */ jsx5(Text, { color: "red", children: "n" }),
+          "=deny"
+        ] }) : /* @__PURE__ */ jsxs4(Text, { bold: true, color: "magenta", children: [
+          "\u2514\u2500 Allow? ",
+          /* @__PURE__ */ jsx5(Text, { color: "green", children: "y" }),
+          "=once / ",
+          /* @__PURE__ */ jsx5(Text, { color: "yellow", children: "a" }),
+          "=same-type / ",
+          /* @__PURE__ */ jsx5(Text, { color: "red", children: "n" }),
+          "=deny"
+        ] })
+      ] }),
+      !questions || questions.length === 0 ? null : /* @__PURE__ */ jsx5(QuestionCards, { questions, activeIndex: questionIndex, answers: questionAnswers, customActive: customQuestionActive }),
+      memoryReviews.length === 0 ? null : /* @__PURE__ */ jsx5(MemoryReviewCards, { reviews: memoryReviews, autoDismissSeconds: memoryAutoDismissSeconds }),
+      completion === void 0 ? null : /* @__PURE__ */ jsx5(SlashMenu, { completion }),
+      mentionCompletion === void 0 ? null : /* @__PURE__ */ jsx5(MentionMenu, { completion: mentionCompletion, ...onMentionSelect === void 0 ? {} : { onSelect: onMentionSelect } }),
+      pendingPrompt === void 0 ? null : /* @__PURE__ */ jsxs4(Text, { color: "yellow", wrap: "truncate-end", children: [
+        "Pending \xB7 ",
+        pendingPrompt,
+        " \xB7 Esc edit"
+      ] }),
+      /* @__PURE__ */ jsx5(Text, { dimColor: true, children: "\u2500".repeat(dividerWidth) }),
+      imageAttachments.map((image, index) => /* @__PURE__ */ jsxs4(Text, { color: "cyan", wrap: "truncate-end", children: [
+        "[Image #",
+        index + 1,
+        "] ",
+        image.name ?? basename3(image.source.path)
+      ] }, `${image.sha256}:${index}`)),
+      clipboardNotice === void 0 ? null : /* @__PURE__ */ jsx5(Text, { color: "yellow", wrap: "truncate-end", children: clipboardNotice }),
+      /* @__PURE__ */ jsx5(
+        PromptLine,
+        {
+          input,
+          pastedBlocks,
+          cursor: promptCursor,
+          columns,
+          maxVisibleLines: promptMaxLines,
+          completedSlashTokenLength: tokenLength,
+          ...onPromptCursorChange === void 0 ? {} : { onCursorChange: onPromptCursorChange }
+        }
+      ),
+      /* @__PURE__ */ jsx5(
+        FooterStatus,
+        {
+          hint: activeSession ? "Ctrl+C cancel \xB7 Enter queue \xB7 Esc edit pending \xB7 /steer sends now" : completion !== void 0 ? "\u2191/\u2193 select \xB7 Tab complete \xB7 Esc close" : mentionCompletion !== void 0 ? "\u2191/\u2193 select \xB7 Tab complete \xB7 click choose \xB7 Esc close" : "Enter send \xB7 Ctrl/Cmd+V image \xB7 \u2191\u2193 history \xB7 Ctrl+C exit",
+          ...ideContext === void 0 ? {} : { ideContext }
+        }
+      )
+    ] })
+  ] });
+}
+function FooterStatus({
+  hint,
+  ideContext
+}) {
+  const ide = ideFooterPresentation(ideContext);
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "row", width: "100%", justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx5(Box_default, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx5(Text, { dimColor: true, wrap: "truncate-end", children: hint }) }),
+    ide === void 0 ? null : /* @__PURE__ */ jsx5(Box_default, { flexShrink: 0, marginLeft: 1, children: /* @__PURE__ */ jsxs4(Text, { color: "cyan", wrap: "truncate-end", children: [
+      "\u29C9 ",
+      ide
+    ] }) })
+  ] });
+}
+function ideFooterPresentation(context) {
+  if (context?.filePath === void 0) return void 0;
+  if (context.selection.isEmpty || !context.selectedText) return `In ${basename3(context.filePath)}`;
+  const endLine = context.selection.end.character === 0 && context.selection.end.line > context.selection.start.line ? context.selection.end.line - 1 : context.selection.end.line;
+  const count = Math.max(1, endLine - context.selection.start.line + 1);
+  return `${count} ${count === 1 ? "line" : "lines"} selected`;
+}
+function QuestionCards({ questions, activeIndex, answers, customActive }) {
+  return /* @__PURE__ */ jsx5(Box_default, { flexDirection: "column", marginBottom: 1, children: questions.map((q, qi) => /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", marginBottom: qi < questions.length - 1 ? 1 : 0, children: [
+    /* @__PURE__ */ jsxs4(Text, { bold: true, color: "cyan", children: [
+      "\u250C\u2500 ",
+      q.header
+    ] }),
+    /* @__PURE__ */ jsxs4(Text, { wrap: "truncate-end", color: "cyanBright", children: [
+      "\u2502 ",
+      q.question
+    ] }),
+    qi < activeIndex ? /* @__PURE__ */ jsxs4(Text, { color: "green", children: [
+      "\u2502  \u2713 ",
+      answers[qi]
+    ] }) : qi > activeIndex ? null : q.options.map((opt, oi) => /* @__PURE__ */ jsxs4(Text, { color: "cyan", children: [
+      "\u2502  ",
+      /* @__PURE__ */ jsx5(Text, { bold: true, color: "green", children: oi + 1 }),
+      ". ",
+      opt.label,
+      /* @__PURE__ */ jsxs4(Text, { dimColor: true, children: [
+        "  ",
+        opt.description
+      ] })
+    ] }, oi)),
+    qi === activeIndex ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+      /* @__PURE__ */ jsxs4(Text, { color: "cyan", children: [
+        "\u2502  ",
+        /* @__PURE__ */ jsx5(Text, { bold: true, color: "green", children: q.options.length + 1 }),
+        ". Custom input",
+        /* @__PURE__ */ jsx5(Text, { dimColor: true, children: "  Type your own answer" })
+      ] }),
+      /* @__PURE__ */ jsxs4(Text, { dimColor: true, color: "cyan", children: [
+        "\u2514\u2500 ",
+        customActive ? "Type below and press Enter; Esc returns to choices" : `Press 1-${q.options.length + 1} to choose; Esc dismisses`
+      ] })
+    ] }) : null
+  ] }, qi)) });
+}
+function MemoryReviewCards({ reviews, autoDismissSeconds }) {
+  const review = reviews[0];
+  const [remaining, setRemaining] = useState2(autoDismissSeconds);
+  useEffect3(() => {
+    if (autoDismissSeconds <= 0) return;
+    setRemaining(autoDismissSeconds);
+    const timer = setInterval(() => setRemaining((current) => Math.max(0, current - 1)), 1e3);
+    return () => clearInterval(timer);
+  }, [review.id, autoDismissSeconds]);
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs4(Text, { bold: true, color: "yellow", children: [
+      "\u250C\u2500 Long-term memory requires confirmation (",
+      reviews.length,
+      ")"
+    ] }),
+    /* @__PURE__ */ jsxs4(Text, { color: "yellowBright", wrap: "truncate-end", children: [
+      "\u2502 [",
+      review.type,
+      "] ",
+      review.content
+    ] }),
+    /* @__PURE__ */ jsx5(Text, { dimColor: true, children: "\u2502 Model-generated content is not stored until you approve it." }),
+    /* @__PURE__ */ jsxs4(Text, { color: "yellow", children: [
+      "\u2514\u2500 ",
+      /* @__PURE__ */ jsx5(Text, { bold: true, children: "Ctrl+Y" }),
+      " save / ",
+      /* @__PURE__ */ jsx5(Text, { bold: true, children: "Ctrl+N" }),
+      " ignore",
+      autoDismissSeconds > 0 ? /* @__PURE__ */ jsx5(Text, { bold: true, color: "cyanBright", children: ` (auto-dismiss in ${remaining}s)` }) : " (conversation remains available)"
+    ] })
+  ] });
+}
+function SlashMenu({ completion }) {
+  const visible = completion.items.slice(completion.windowStart, completion.windowStart + 6);
+  return /* @__PURE__ */ jsx5(Box_default, { flexDirection: "column", width: "100%", children: visible.map((candidate, visibleIndex) => {
+    const index = completion.windowStart + visibleIndex;
+    const presentation = slashCandidatePresentation(index === completion.selectedIndex);
+    return /* @__PURE__ */ jsxs4(Text, { ...presentation.rowStyle, wrap: "truncate-end", children: [
+      presentation.marker,
+      /* @__PURE__ */ jsx5(HighlightedName, { name: candidate.name, query: completion.query, matchStyle: presentation.matchStyle }),
+      candidate.description === void 0 ? null : /* @__PURE__ */ jsx5(Text, { dimColor: true, children: `  ${candidate.description}` })
+    ] }, `${candidate.kind}:${candidate.name}`);
+  }) });
+}
+function MentionMenu({
+  completion,
+  onSelect
+}) {
+  const visible = completion.items.slice(completion.windowStart, completion.windowStart + 6);
+  return /* @__PURE__ */ jsx5(Box_default, { flexDirection: "column", width: "100%", children: visible.map((path, visibleIndex) => {
+    const index = completion.windowStart + visibleIndex;
+    const presentation = mentionCandidatePresentation(index === completion.selectedIndex);
+    return /* @__PURE__ */ jsx5(
+      Box_default,
+      {
+        width: "100%",
+        onClick: (event) => {
+          if (!event.cellIsBlank) onSelect?.(path);
+        },
+        children: /* @__PURE__ */ jsxs4(Text, { ...presentation.textStyle, wrap: "truncate-end", children: [
+          presentation.marker,
+          presentation.highlightMatches ? /* @__PURE__ */ jsx5(HighlightedName, { name: path, query: completion.query, matchStyle: presentation.matchStyle }) : path
+        ] })
+      },
+      path
+    );
+  }) });
+}
+function HighlightedName({
+  name,
+  query,
+  matchStyle
+}) {
+  const ranges = matchRanges(name, query);
+  if (ranges.length === 0) return /* @__PURE__ */ jsx5(Text, { children: name });
+  const parts = [];
+  let cursor = 0;
+  for (const [start, end] of ranges) {
+    if (start > cursor) parts.push(name.slice(cursor, start));
+    parts.push(/* @__PURE__ */ jsx5(Text, { ...matchStyle, children: name.slice(start, end) }, `${start}:${end}`));
+    cursor = end;
+  }
+  if (cursor < name.length) parts.push(name.slice(cursor));
+  return /* @__PURE__ */ jsx5(Text, { children: parts });
+}
+function jumpScroll(scroll, delta) {
+  const maximum = Math.max(0, scroll.getScrollHeight() - scroll.getViewportHeight());
+  const target = scroll.getScrollTop() + scroll.getPendingDelta() + delta;
+  if (target >= maximum) {
+    scroll.scrollTo(maximum);
+    scroll.scrollToBottom();
+  } else {
+    scroll.scrollTo(Math.max(0, target));
+  }
+}
+function selectWheelScrollTarget(transcript, tasks, taskPanelHovered) {
+  return taskPanelHovered && tasks !== null ? tasks : transcript;
+}
+function taskPanelViewportRows(rows, reservedBottomRows, hasTasks) {
+  if (!hasTasks) return 0;
+  const terminalRows = Math.max(0, Math.floor(rows));
+  const reserved = Math.max(0, Math.floor(reservedBottomRows));
+  const available = Math.max(0, terminalRows - reserved - 1);
+  return Math.min(8, Math.max(1, Math.floor(terminalRows / 3)), available);
+}
+function scrollDown(scroll, amount) {
+  const maximum = Math.max(0, scroll.getScrollHeight() - scroll.getViewportHeight());
+  if (scroll.getScrollTop() + scroll.getPendingDelta() + amount >= maximum) scroll.scrollToBottom();
+  else scroll.scrollBy(amount);
+}
+function scrollUp(scroll, amount) {
+  if (scroll.getScrollTop() + scroll.getPendingDelta() - amount <= 0) scroll.scrollTo(0);
+  else scroll.scrollBy(-amount);
+}
+function TurnSeparator({ width }) {
+  return /* @__PURE__ */ jsx5(Text, { dimColor: true, children: "\u2500".repeat(Math.max(1, width - 1)) });
+}
+function TurnView({ turn, interactive }) {
+  if (turn.kind === "compaction") {
+    return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", marginBottom: 1, borderStyle: "round", borderColor: "ansi:yellowBright", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Text, { color: "ansi:yellowBright", bold: true, children: turn.prompt }),
+      turn.blocks.map((block, index) => block.kind === "status" ? /* @__PURE__ */ jsx5(StatusBlockView, { block, interactive }, block.id) : /* @__PURE__ */ jsx5(Box_default, { children: /* @__PURE__ */ jsx5(AssistantText, { text: block.text }) }, `${turn.id}-text-${index}`))
+    ] });
+  }
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "row", backgroundColor: "#3a3a3a", paddingX: 1, paddingY: 0, children: [
+      /* @__PURE__ */ jsx5(Text, { color: "ansi:whiteBright", bold: true, backgroundColor: "#3a3a3a", children: "\u276F" }),
+      /* @__PURE__ */ jsxs4(Text, { color: "ansi:whiteBright", bold: true, backgroundColor: "#3a3a3a", children: [
+        " ",
+        turn.prompt
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Box_default, { flexDirection: "column", paddingLeft: 2, marginTop: 1, children: turn.blocks.map((block, index) => block.kind === "status" ? /* @__PURE__ */ jsx5(StatusBlockView, { block, interactive }, block.id) : /* @__PURE__ */ jsx5(Box_default, { marginBottom: 1, children: /* @__PURE__ */ jsx5(AssistantText, { text: block.text }) }, `${turn.id}-text-${index}`)) })
+  ] });
+}
+var DIFF_CONTENT = fileDiffLineStyle("context").contentColor;
+var DIFF_REMOVED_MARKER = fileDiffLineStyle("removed").markerColor;
+var DIFF_ADDED_MARKER = fileDiffLineStyle("added").markerColor;
+function FileDiffView({ presentation }) {
+  const operation = presentation.operation === "create" ? "Create" : presentation.operation === "delete" ? "Delete" : "Update";
+  if (presentation.operation === "delete") {
+    return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx5(Text, { color: DIFF_REMOVED_MARKER, children: "\u25CF" }),
+      /* @__PURE__ */ jsxs4(Text, { color: DIFF_CONTENT, children: [
+        " ",
+        /* @__PURE__ */ jsx5(Text, { bold: true, children: operation }),
+        "(",
+        basename3(presentation.path),
+        ")"
+      ] })
+    ] });
+  }
+  const lineWidth = Math.max(1, ...presentation.lines.map((line) => Math.max(line.oldLine ?? 0, line.newLine ?? 0))).toString().length;
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", width: "100%", children: [
+    /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx5(Text, { color: DIFF_ADDED_MARKER, children: "\u25CF" }),
+      /* @__PURE__ */ jsxs4(Text, { color: DIFF_CONTENT, children: [
+        " ",
+        /* @__PURE__ */ jsx5(Text, { bold: true, children: operation }),
+        "(",
+        basename3(presentation.path),
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Text, { color: DIFF_CONTENT, children: [
+      "  \u2514 Added ",
+      lineCount(presentation.added),
+      ", removed ",
+      lineCount(presentation.removed)
+    ] }),
+    presentation.lines.map((line, index) => /* @__PURE__ */ jsx5(FileDiffRow, { line, lineWidth }, `${line.kind}:${line.oldLine ?? ""}:${line.newLine ?? ""}:${index}`))
+  ] });
+}
+function FileDiffRow({ line, lineWidth }) {
+  if (line.kind === "omitted") {
+    return /* @__PURE__ */ jsxs4(Text, { color: DIFF_CONTENT, dimColor: true, children: [
+      " ".repeat(lineWidth + 4),
+      line.text
+    ] });
+  }
+  const number = line.newLine ?? line.oldLine;
+  const marker = line.kind === "removed" ? "-" : line.kind === "added" ? "+" : " ";
+  const { backgroundColor, markerColor, contentColor } = fileDiffLineStyle(line.kind);
+  const prefix = `${String(number ?? "").padStart(lineWidth)} ${marker}| `;
+  return /* @__PURE__ */ jsxs4(
+    Box_default,
+    {
+      flexDirection: "row",
+      width: "100%",
+      ...backgroundColor === void 0 ? {} : { backgroundColor },
+      children: [
+        /* @__PURE__ */ jsx5(
+          Text,
+          {
+            color: markerColor,
+            ...line.kind === "context" ? { dimColor: true } : {},
+            ...backgroundColor === void 0 ? {} : { backgroundColor },
+            children: prefix
+          }
+        ),
+        /* @__PURE__ */ jsx5(
+          Text,
+          {
+            color: contentColor,
+            ...backgroundColor === void 0 ? {} : { backgroundColor },
+            children: line.text
+          }
+        )
+      ]
+    }
+  );
+}
+function lineCount(count) {
+  return `${count} ${count === 1 ? "line" : "lines"}`;
+}
+function StatusLine({ block, interactive }) {
+  if (block.progress !== void 0) return /* @__PURE__ */ jsx5(CompactProgressLine, { progress: block.progress });
+  const running = block.state === "running";
+  const [ref, time] = useAnimationFrame(running && interactive ? 120 : null);
+  const color = statusLineColor(block);
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  const spinner = running && interactive ? frames[Math.floor(Math.max(0, time) / 120) % frames.length] + " " : "";
+  return /* @__PURE__ */ jsxs4(Box_default, { ref, flexDirection: "row", children: [
+    /* @__PURE__ */ jsxs4(Text, { ...color === void 0 ? { dimColor: true } : { color }, children: [
+      spinner,
+      block.text
+    ] }),
+    block.hint === void 0 ? null : /* @__PURE__ */ jsxs4(Text, { dimColor: true, wrap: "truncate-end", children: [
+      " (",
+      block.hint,
+      ")"
+    ] })
+  ] });
+}
+function statusLineColor(block) {
+  if (block.tone === "retry" || block.tone === "warning") return "ansi:yellowBright";
+  if (block.state === "running") return "#d77757";
+  if (block.state === "completed") return "ansi:green";
+  if (block.state === "failed" || block.state === "cancelled") return "#e06c50";
+  return void 0;
+}
+function CompactProgressLine({ progress }) {
+  const presentation = compactProgressPresentation(progress);
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "row", children: [
+    /* @__PURE__ */ jsx5(Text, { children: "Compacting context " }),
+    presentation.cells.map((cell, index) => /* @__PURE__ */ jsxs4(Text, { color: cell.color, children: [
+      "\u25A0",
+      index === presentation.cells.length - 1 ? "" : " "
+    ] }, index)),
+    /* @__PURE__ */ jsxs4(Text, { dimColor: true, children: [
+      " ",
+      presentation.progress,
+      "%"
+    ] })
+  ] });
+}
+function PromptLine({
+  input,
+  pastedBlocks,
+  cursor,
+  columns,
+  maxVisibleLines,
+  completedSlashTokenLength: tokenLength = 0,
+  onCursorChange
+}) {
+  const innerColumns = Math.max(1, columns - PROMPT_HORIZONTAL_PADDING * 2);
+  const presentation = pastedDraftPresentation(input, cursor, pastedBlocks);
+  const wrap = wrapPromptInput(presentation.text, presentation.cursor, { columns: innerColumns, indent: 2 });
+  const visibleCount = Math.max(1, maxVisibleLines ?? wrap.lines.length);
+  const windowStart = Math.min(
+    Math.max(0, wrap.cursor.line - visibleCount + 1),
+    Math.max(0, wrap.lines.length - visibleCount)
+  );
+  const visibleLines = wrap.lines.slice(windowStart, windowStart + visibleCount);
+  const lineStarts = [];
+  let nextLineStart = 0;
+  for (const line of wrap.lines) {
+    lineStarts.push(nextLineStart);
+    nextLineStart += [...line].length;
+  }
+  return /* @__PURE__ */ jsx5(Box_default, { width: "100%", flexDirection: "column", paddingX: PROMPT_HORIZONTAL_PADDING, children: visibleLines.map((line, visibleIndex) => {
+    const lineIndex = windowStart + visibleIndex;
+    const isCursorLine = lineIndex === wrap.cursor.line;
+    const points = [...line];
+    const cursorCol = wrap.cursor.column;
+    const styledCount = Math.max(0, Math.min(points.length, tokenLength - (lineStarts[lineIndex] ?? 0)));
+    return /* @__PURE__ */ jsxs4(
+      Box_default,
+      {
+        ...onCursorChange === void 0 ? {} : {
+          onClick: (event) => {
+            onCursorChange(promptCursorFromClick(input, pastedBlocks, {
+              columns: innerColumns,
+              lineIndex,
+              localColumn: event.localCol
+            }));
+            event.stopImmediatePropagation();
+          }
+        },
+        children: [
+          /* @__PURE__ */ jsx5(Text, { color: "yellow", bold: true, children: lineIndex === 0 ? "\u276F " : "  " }),
+          /* @__PURE__ */ jsx5(PromptLineContent, { points, cursor: cursorCol, cursorVisible: isCursorLine, styledCount })
+        ]
+      },
+      lineIndex
+    );
+  }) });
+}
+function StatusBlockView({
+  block,
+  interactive
+}) {
+  const visibleBlock = cliToolTitle(block);
+  const outcome = cliToolOutcome(block);
+  const primary = visibleBlock.activity === "model" || visibleBlock.task !== void 0 ? /* @__PURE__ */ jsx5(TaskStatusLine, { block: visibleBlock, interactive }) : visibleBlock.state === "completed" && visibleBlock.presentation !== void 0 ? /* @__PURE__ */ jsx5(FileDiffView, { presentation: visibleBlock.presentation }) : /* @__PURE__ */ jsx5(StatusLine, { block: visibleBlock, interactive });
+  return /* @__PURE__ */ jsxs4(Box_default, { flexDirection: "column", children: [
+    primary,
+    outcome === void 0 ? null : /* @__PURE__ */ jsx5(Box_default, { paddingLeft: 2, children: /* @__PURE__ */ jsxs4(Text, { dimColor: true, children: [
+      "\u2514 ",
+      outcome
+    ] }) }),
+    block.details === void 0 ? null : /* @__PURE__ */ jsx5(Box_default, { paddingLeft: 2, children: /* @__PURE__ */ jsx5(AssistantText, { text: block.details }) })
+  ] });
+}
+function cliToolTitle(block) {
+  if (block.tool === void 0 || block.presentation !== void 0) return block;
+  const input = record(block.tool.input);
+  const path = typeof input?.path === "string" ? basename3(input.path) : void 0;
+  if (path === void 0 || block.text.includes(path)) return block;
+  return { ...block, text: `${block.text} ${path}` };
+}
+function cliToolOutcome(block) {
+  const result = block.tool?.result;
+  if (result === void 0 || block.presentation !== void 0) return void 0;
+  if (!result.ok) return truncateInline(result.error?.message ?? "Tool call failed");
+  const output = record(result.output);
+  if (output === void 0) return void 0;
+  if (typeof output.exitCode === "number" || output.exitCode === null) {
+    const exit = output.exitCode === null ? "no exit code" : `exit ${output.exitCode}`;
+    return output.truncated === true ? `${exit} \xB7 output truncated` : exit;
+  }
+  if (typeof output.replacements === "number") return `${output.replacements} replacement${output.replacements === 1 ? "" : "s"}`;
+  if (typeof output.bytes === "number") return `${formatBytes(output.bytes)} written`;
+  if (Array.isArray(output.matches)) return `${output.matches.length} match${output.matches.length === 1 ? "" : "es"}${output.truncated === true ? " \xB7 truncated" : ""}`;
+  if (Array.isArray(output.paths)) return `${output.paths.length} file${output.paths.length === 1 ? "" : "s"}${output.truncated === true ? " \xB7 truncated" : ""}`;
+  if (Array.isArray(output.files)) return `${output.files.length} file${output.files.length === 1 ? "" : "s"} changed`;
+  return void 0;
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function truncateInline(value, maxChars = 180) {
+  const text = value.replace(/\s+/gu, " ").trim();
+  return text.length <= maxChars ? text : `${text.slice(0, maxChars - 1)}\u2026`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1048576) return `${(bytes / 1024).toFixed(bytes < 10240 ? 1 : 0)} KB`;
+  return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+function pastedDraftModel(input, cursor, blocks) {
+  const sourceMatches = [];
+  for (const block of blocks) {
+    const extraLines = block.text.split(/\r\n|\r|\n/u).length - 1;
+    if (extraLines === 0 || block.text.length === 0) continue;
+    let start = input.indexOf(block.text);
+    while (start >= 0) {
+      const end = start + block.text.length;
+      const overlaps = sourceMatches.some((match) => start < match.end && end > match.start);
+      if (!overlaps) {
+        sourceMatches.push({
+          start,
+          end,
+          startPoint: [...input.slice(0, start)].length,
+          endPoint: [...input.slice(0, end)].length,
+          label: `[Pasted text #${block.id} +${extraLines} lines]`
+        });
+        break;
+      }
+      start = input.indexOf(block.text, start + 1);
+    }
+  }
+  if (sourceMatches.length === 0) return { text: input, cursor, matches: [] };
+  sourceMatches.sort((left, right) => left.start - right.start);
+  let text = "";
+  let sourceOffset = 0;
+  const matches = [];
+  for (const match of sourceMatches) {
+    text += input.slice(sourceOffset, match.start);
+    const displayStartPoint = [...text].length;
+    text += match.label;
+    const displayEndPoint = [...text].length;
+    matches.push({
+      sourceStartPoint: match.startPoint,
+      sourceEndPoint: match.endPoint,
+      displayStartPoint,
+      displayEndPoint,
+      label: match.label
+    });
+    sourceOffset = match.end;
+  }
+  text += input.slice(sourceOffset);
+  let pointDelta = 0;
+  let mappedCursor = cursor;
+  for (const match of matches) {
+    const labelLength = match.displayEndPoint - match.displayStartPoint;
+    if (cursor <= match.sourceStartPoint) break;
+    if (cursor < match.sourceEndPoint) {
+      mappedCursor = match.displayEndPoint;
+      break;
+    }
+    pointDelta += labelLength - (match.sourceEndPoint - match.sourceStartPoint);
+    mappedCursor = cursor + pointDelta;
+  }
+  return { text, cursor: mappedCursor, matches };
+}
+function pastedDraftPresentation(input, cursor, blocks) {
+  const model = pastedDraftModel(input, cursor, blocks);
+  return { text: model.text, cursor: model.cursor };
+}
+function codePointIndexAtVisualColumn(line, targetColumn) {
+  const points = [...line];
+  const target = Math.max(0, targetColumn);
+  let visualColumn = 0;
+  for (let index = 0; index < points.length; index += 1) {
+    const width = charWidth(points[index].codePointAt(0) ?? 0);
+    if (target <= visualColumn) return index;
+    if (target < visualColumn + width) {
+      return target - visualColumn < width / 2 ? index : index + 1;
+    }
+    visualColumn += width;
+  }
+  return points.length;
+}
+function sourceCursorFromDisplayed(model, displayedCursor) {
+  let sourceOffset = 0;
+  let displayOffset = 0;
+  for (const match of model.matches) {
+    if (displayedCursor < match.displayStartPoint) {
+      return sourceOffset + displayedCursor - displayOffset;
+    }
+    if (displayedCursor <= match.displayEndPoint) return match.sourceEndPoint;
+    sourceOffset = match.sourceEndPoint;
+    displayOffset = match.displayEndPoint;
+  }
+  return sourceOffset + displayedCursor - displayOffset;
+}
+function promptCursorFromClick(input, blocks, position) {
+  const model = pastedDraftModel(input, 0, blocks);
+  const wrap = wrapPromptInput(model.text, 0, { columns: position.columns, indent: 2 });
+  const lineIndex = Math.max(0, Math.min(wrap.lines.length - 1, position.lineIndex));
+  const beforeLine = wrap.lines.slice(0, lineIndex).reduce((total, line) => total + [...line].length, 0);
+  const withinLine = codePointIndexAtVisualColumn(
+    wrap.lines[lineIndex] ?? "",
+    position.localColumn - 2
+  );
+  const sourceCursor = sourceCursorFromDisplayed(model, beforeLine + withinLine);
+  return Math.max(0, Math.min([...input].length, sourceCursor));
+}
+function PromptLineContent({
+  points,
+  cursor,
+  cursorVisible,
+  styledCount
+}) {
+  const tokenStyle = completedSlashTokenPresentation();
+  return /* @__PURE__ */ jsxs4(Text, { children: [
+    points.map((point, index) => {
+      const styled = index < styledCount;
+      const caret = cursorVisible && index === cursor;
+      return /* @__PURE__ */ jsx5(
+        Text,
+        {
+          ...styled ? tokenStyle : {},
+          ...caret ? { inverse: true } : {},
+          children: point
+        },
+        index
+      );
+    }),
+    cursorVisible && cursor >= points.length ? /* @__PURE__ */ jsx5(Text, { inverse: true, children: " " }) : null
+  ] });
+}
+function editPrompt(state, edit) {
+  const points = [...state.text];
+  const cursor = Math.max(0, Math.min(points.length, state.cursor));
+  if (edit.type === "insert") {
+    const inserted = [...edit.value];
+    points.splice(cursor, 0, ...inserted);
+    return { text: points.join(""), cursor: cursor + inserted.length };
+  }
+  if (edit.type === "left") return { text: state.text, cursor: Math.max(0, cursor - 1) };
+  if (edit.type === "right") return { text: state.text, cursor: Math.min(points.length, cursor + 1) };
+  if (edit.type === "backspace") {
+    if (cursor === 0) return { text: state.text, cursor };
+    points.splice(cursor - 1, 1);
+    return { text: points.join(""), cursor: cursor - 1 };
+  }
+  if (edit.type === "delete") {
+    points.splice(cursor, 1);
+    return { text: points.join(""), cursor };
+  }
+  return { text: state.text, cursor };
+}
+function editPromptWithPastedBlocks(state, edit, pastedBlocks) {
+  const points = [...state.text];
+  const cursor = Math.max(0, Math.min(points.length, state.cursor));
+  const latest = pastedBlocks.at(-1);
+  if (edit.type === "backspace" && latest !== void 0) {
+    const pastedPoints = [...latest.text];
+    const start = cursor - pastedPoints.length;
+    if (start >= 0 && points.slice(start, cursor).join("") === latest.text) {
+      points.splice(start, pastedPoints.length);
+      return {
+        text: points.join(""),
+        cursor: start,
+        pastedBlocks: pastedBlocks.slice(0, -1)
+      };
+    }
+  }
+  return { ...editPrompt({ text: state.text, cursor }, edit), pastedBlocks: [...pastedBlocks] };
+}
+function navigateHistory(state, direction) {
+  const cursor = direction === "up" ? Math.max(0, state.cursor - 1) : Math.min(state.history.length, state.cursor + 1);
+  const input = state.history[cursor] ?? "";
+  return { cursor, input, promptCursor: [...input].length };
+}
+function updatePrompt(edit, text, cursor, setText, setCursor) {
+  const next = editPrompt({ text, cursor }, edit);
+  setText(next.text);
+  setCursor(next.cursor);
+}
+async function submitSafely(session, prompt, report) {
+  try {
+    await session.submit(prompt);
+  } catch (error) {
+    safeReport(report, safeUiError(error));
+  }
+}
+async function shutdownRuntime(runtime, exit, report) {
+  try {
+    await closeAndDisposeRuntime(runtime, report);
+  } finally {
+    exit();
+  }
+}
+async function closeAndDisposeRuntime(runtime, report) {
+  if (runtime === void 0) return;
+  try {
+    await runtime.session.close();
+  } catch (error) {
+    safeReport(report, safeUiError(error));
+  } finally {
+    try {
+      await runtime.dispose();
+    } catch (error) {
+      safeReport(report, safeUiError(error));
+    }
+  }
+}
+function safeUiError(error) {
+  return redactErrorText(message(error)).slice(0, 2e3);
+}
+function safeReport(report, value) {
+  try {
+    report(value);
+  } catch {
+  }
+}
+export {
+  App,
+  FooterStatus,
+  HISTORY_CAP,
+  MentionMenu,
+  PromptLine,
+  SinglePendingPrompt,
+  TerminalLayout,
+  classifyTerminalInput,
+  closeAndDisposeRuntime,
+  completionKeyAction,
+  editPrompt,
+  editPromptWithPastedBlocks,
+  ideFooterPresentation,
+  navigateHistory,
+  pastedDraftPresentation,
+  prepareCliSubmission,
+  promptCursorFromClick,
+  promptDelivery,
+  removeLastCliImageOnBackspace,
+  resolvePromptDelivery,
+  runTerminalSubmissionChain,
+  selectWheelScrollTarget,
+  shutdownRuntime,
+  slashKeyAction,
+  statusLineColor,
+  submitSafely,
+  taskPanelViewportRows
+};
+//# sourceMappingURL=app-WC2XXGLM.js.map