indusagi 0.12.32 → 0.12.34

package/dist/react-ink.js

@@ -0,0 +1,3821 @@
+// src/react-ink/theme-adapter.ts
+import chalk from "chalk";
+import stripAnsi from "strip-ansi";
+var DEFAULT_ROLE_KEYS = {
+  codeInline: "codeInline",
+  heading: "heading",
+  blockquoteBar: "blockquoteBar",
+  diffAddedBg: "diffAddedBg",
+  diffRemovedBg: "diffRemovedBg",
+  diffAddedText: "diffAddedText",
+  diffRemovedText: "diffRemovedText",
+  synKeyword: "synKeyword",
+  synString: "synString",
+  synNumber: "synNumber",
+  synComment: "synComment",
+  synType: "synType"
+};
+var ROLE_FALLBACK_KEYS = {
+  codeInline: "accent",
+  heading: "accent",
+  blockquoteBar: "muted",
+  diffAddedBg: "success",
+  diffRemovedBg: "error",
+  diffAddedText: "success",
+  diffRemovedText: "error",
+  synKeyword: "accent",
+  synString: "success",
+  synNumber: "warning",
+  synComment: "muted",
+  synType: "info"
+};
+function applyForeground(color, text) {
+  if (!color) return text;
+  try {
+    return chalk.hex(color)(text);
+  } catch {
+    return text;
+  }
+}
+function resolveColorToken(value, fallback) {
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value;
+  }
+  return fallback;
+}
+function applyBackground(background, foreground, text) {
+  if (!background) return applyForeground(foreground, text);
+  try {
+    let styled = chalk.bgHex(background);
+    if (foreground) {
+      styled = styled.hex(foreground);
+    }
+    return styled(text);
+  } catch {
+    return applyForeground(foreground, text);
+  }
+}
+function createThemeAdapter(themeName, colors, roleOverrides) {
+  const fallback = colors.text ?? "#e5e5e7";
+  const roles = { ...DEFAULT_ROLE_KEYS, ...roleOverrides };
+  const resolveRoleColor = (role) => resolveColorToken(
+    colors[roles[role]],
+    resolveColorToken(colors[ROLE_FALLBACK_KEYS[role]], fallback)
+  );
+  return {
+    name: themeName,
+    colors,
+    roles,
+    color: (key, text) => applyForeground(resolveColorToken(colors[key], fallback), text),
+    background: (key, text, textKey = "text") => applyBackground(resolveColorToken(colors[key]), resolveColorToken(colors[textKey], fallback), ` ${stripAnsi(text)} `),
+    dim: (text) => applyForeground(resolveColorToken(colors.dim, "#666666"), text),
+    muted: (text) => applyForeground(resolveColorToken(colors.muted, "#808080"), text),
+    role: (role, text) => applyForeground(resolveRoleColor(role), text),
+    roleBackground: (role, text, foregroundRole) => applyBackground(
+      resolveRoleColor(role),
+      foregroundRole ? resolveRoleColor(foregroundRole) : void 0,
+      text
+    )
+  };
+}
+
+// src/react-host/loader.ts
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+function findPackageRoot(start) {
+  let current = path.resolve(start);
+  while (true) {
+    const packageJson = path.join(current, "package.json");
+    if (fs.existsSync(packageJson)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function createPackageRequire(packageRoot) {
+  return createRequire(path.join(packageRoot, "package.json"));
+}
+function candidatePackageRoots() {
+  const roots = /* @__PURE__ */ new Set();
+  const addCandidate = (candidate) => {
+    if (!candidate) {
+      return;
+    }
+    const root = findPackageRoot(candidate);
+    if (root) {
+      roots.add(root);
+    }
+  };
+  const argv1 = process.argv[1];
+  let argv1Real;
+  if (argv1) {
+    try {
+      argv1Real = fs.realpathSync(argv1);
+    } catch {
+      argv1Real = argv1;
+    }
+  }
+  const packageRoot = fileURLToPath(new URL("../../..", import.meta.url));
+  addCandidate(process.env.INDUSAGI_REACT_HOST_ROOT);
+  addCandidate(argv1Real ? path.dirname(argv1Real) : void 0);
+  addCandidate(argv1 ? path.dirname(argv1) : void 0);
+  addCandidate(process.env.INIT_CWD);
+  addCandidate(process.cwd());
+  addCandidate(packageRoot);
+  return [...roots];
+}
+function resolveHostModule(specifier) {
+  const failures = [];
+  for (const packageRoot of candidatePackageRoots()) {
+    try {
+      return createPackageRequire(packageRoot).resolve(specifier);
+    } catch (error) {
+      failures.push(`${packageRoot}: ${String(error.message ?? error)}`);
+    }
+  }
+  throw new Error(
+    `Unable to resolve host module "${specifier}" from any detected package root.
+${failures.join("\n")}`
+  );
+}
+function normalizeModuleNamespace(moduleNamespace) {
+  const defaultExport = moduleNamespace.default;
+  if (defaultExport && typeof defaultExport === "object") {
+    return { ...defaultExport, ...moduleNamespace };
+  }
+  return moduleNamespace;
+}
+async function importHostModule(specifier) {
+  const resolved = resolveHostModule(specifier);
+  const moduleNamespace = await import(pathToFileURL(resolved).href);
+  return normalizeModuleNamespace(moduleNamespace);
+}
+var reactInstance = null;
+var jsxRuntimeInstance = null;
+var inkInstance = null;
+function loadHostReact() {
+  if (!reactInstance) {
+    reactInstance = importHostModule("react");
+  }
+  return reactInstance;
+}
+function loadHostJsxRuntime() {
+  if (!jsxRuntimeInstance) {
+    jsxRuntimeInstance = importHostModule("react/jsx-runtime");
+  }
+  return jsxRuntimeInstance;
+}
+function loadHostInk() {
+  if (!inkInstance) {
+    inkInstance = importHostModule("ink");
+  }
+  return inkInstance;
+}
+
+// src/react-host/ink.ts
+var ink = await loadHostInk();
+var Box = ink.Box;
+var Text = ink.Text;
+var render = ink.render;
+var useInput = ink.useInput;
+
+// src/react-host/jsx-runtime.ts
+var jsxRuntime = await loadHostJsxRuntime();
+var Fragment = jsxRuntime.Fragment;
+var jsx = jsxRuntime.jsx;
+var jsxs = jsxRuntime.jsxs;
+
+// src/react-ink/components/ChangelogBlock.tsx
+function renderInline(text, theme, keyPrefix) {
+  const nodes = [];
+  const tokenPattern = /(\*\*[^*]+\*\*|`[^`]+`)/g;
+  let cursor = 0;
+  let tokenIndex = 0;
+  for (const match of text.matchAll(tokenPattern)) {
+    const matchedText = match[0];
+    const start = match.index ?? cursor;
+    if (start > cursor) {
+      nodes.push(text.slice(cursor, start));
+    }
+    if (matchedText.startsWith("**")) {
+      nodes.push(
+        /* @__PURE__ */ jsx(Text, { children: theme.color("accent", matchedText.slice(2, -2)) }, `${keyPrefix}-bold-${tokenIndex}`)
+      );
+    } else {
+      nodes.push(
+        /* @__PURE__ */ jsx(Text, { children: theme.color("accent", matchedText.slice(1, -1)) }, `${keyPrefix}-code-${tokenIndex}`)
+      );
+    }
+    cursor = start + matchedText.length;
+    tokenIndex += 1;
+  }
+  if (cursor < text.length) {
+    nodes.push(text.slice(cursor));
+  }
+  return nodes.length > 0 ? nodes : [text];
+}
+function renderMarkdownLine(line, theme, key) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { children: " " }, key);
+  }
+  if (/^-{3,}$/.test(trimmed)) {
+    const width = Math.max(20, (process.stdout.columns ?? 80) - 4);
+    return /* @__PURE__ */ jsx(Text, { children: theme.color("borderMuted", "\u2500".repeat(width)) }, key);
+  }
+  if (trimmed.startsWith("## ")) {
+    return /* @__PURE__ */ jsx(Text, { children: theme.color("accent", trimmed.slice(3)) }, key);
+  }
+  if (trimmed.startsWith("### ")) {
+    return /* @__PURE__ */ jsx(Text, { children: theme.color("warning", trimmed.slice(4)) }, key);
+  }
+  const bulletMatch = line.match(/^(\s*)-\s+(.*)$/);
+  if (bulletMatch) {
+    const indent = " ".repeat(bulletMatch[1]?.length ?? 0);
+    const content = bulletMatch[2] ?? "";
+    const bulletColor = indent.length > 0 ? "muted" : "accent";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      indent,
+      theme.color(bulletColor, "\u2022"),
+      " ",
+      renderInline(content, theme, key)
+    ] }, key);
+  }
+  return /* @__PURE__ */ jsx(Text, { children: renderInline(line, theme, key) }, key);
+}
+function ChangelogBlock({ markdown, theme, title }) {
+  const dividerWidth = Math.max(20, (process.stdout.columns ?? 80) - 2);
+  const divider = "\u2500".repeat(dividerWidth);
+  const lines = markdown.trim().length > 0 ? markdown.trim().split("\n") : ["No changelog entries found."];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("borderMuted", divider) }),
+    /* @__PURE__ */ jsx(Text, { children: theme.color("accent", title) }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    lines.map((line, index) => renderMarkdownLine(line, theme, `${title}-${index}`)),
+    /* @__PURE__ */ jsx(Text, { children: theme.color("borderMuted", divider) })
+  ] });
+}
+
+// src/react-ink/components/DisplayBlockView.tsx
+function DisplayBlockView({ block, theme }) {
+  switch (block.kind) {
+    case "changelog":
+      return /* @__PURE__ */ jsx(ChangelogBlock, { markdown: block.markdown, theme, title: block.title });
+    default:
+      return null;
+  }
+}
+
+// src/react-ink/components/Footer.tsx
+import stripAnsi2 from "strip-ansi";
+function toDisplayText(value) {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => toDisplayText(entry)).join("");
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  if ("props" in value) {
+    return toDisplayText(value.props?.children);
+  }
+  return "";
+}
+function sanitizeStatusText(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function formatTokens(count) {
+  if (count < 1e3) return count.toString();
+  if (count < 1e4) return `${(count / 1e3).toFixed(1)}k`;
+  if (count < 1e6) return `${Math.round(count / 1e3)}k`;
+  if (count < 1e7) return `${(count / 1e6).toFixed(1)}M`;
+  return `${Math.round(count / 1e6)}M`;
+}
+function shortenPath(path2) {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (home && path2.startsWith(home)) {
+    return `~${path2.slice(home.length)}`;
+  }
+  return path2;
+}
+function chunkLines(values, width) {
+  const lines = [];
+  let current = "";
+  for (const value of values) {
+    const next = current ? `${current}  ${value}` : value;
+    if (stripAnsi2(next).length > width && current) {
+      lines.push(current);
+      current = value;
+    } else {
+      current = next;
+    }
+  }
+  if (current) {
+    lines.push(current);
+  }
+  return lines;
+}
+function Footer({ availableProviderCount, branch, extensionStatuses, snapshot, theme }) {
+  const cwdLineParts = [shortenPath(snapshot.cwd)];
+  if (branch) {
+    cwdLineParts.push(`(${toDisplayText(branch)})`);
+  }
+  if (snapshot.sessionName) {
+    cwdLineParts.push(`\u2022 ${snapshot.sessionName}`);
+  }
+  const statsParts = [];
+  if (snapshot.stats.tokens.input > 0) statsParts.push(`\u2191${formatTokens(snapshot.stats.tokens.input)}`);
+  if (snapshot.stats.tokens.output > 0) statsParts.push(`\u2193${formatTokens(snapshot.stats.tokens.output)}`);
+  if (snapshot.stats.tokens.cacheRead > 0) statsParts.push(`R${formatTokens(snapshot.stats.tokens.cacheRead)}`);
+  if (snapshot.stats.tokens.cacheWrite > 0) statsParts.push(`W${formatTokens(snapshot.stats.tokens.cacheWrite)}`);
+  if (snapshot.stats.cost > 0) statsParts.push(`$${snapshot.stats.cost.toFixed(3)}`);
+  let contextPart = snapshot.contextUsage ? `ctx:${snapshot.contextUsage.percent.toFixed(1)}%/${formatTokens(snapshot.contextUsage.contextWindow)}` : void 0;
+  if (contextPart && snapshot.autoCompactEnabled) {
+    contextPart += " (auto)";
+  }
+  if (contextPart) {
+    if ((snapshot.contextUsage?.percent ?? 0) > 90) {
+      statsParts.push(toDisplayText(theme.color("error", contextPart)));
+    } else if ((snapshot.contextUsage?.percent ?? 0) > 70) {
+      statsParts.push(toDisplayText(theme.color("warning", contextPart)));
+    } else {
+      statsParts.push(contextPart);
+    }
+  }
+  const modelParts = [
+    snapshot.model ? `${toDisplayText(snapshot.model.provider)}/${toDisplayText(snapshot.model.id)}` : "no-model",
+    `thinking:${toDisplayText(snapshot.thinkingLevel)}`,
+    snapshot.pendingMessageCount > 0 ? `pending:${snapshot.pendingMessageCount}` : void 0,
+    snapshot.pendingToolCallCount > 0 ? `tools:${snapshot.pendingToolCallCount}` : void 0,
+    availableProviderCount > 1 ? `providers:${availableProviderCount}` : void 0
+  ];
+  const statusValues = Array.from(extensionStatuses?.entries() ?? []).sort(([left], [right]) => left.localeCompare(right)).map(([key, text]) => sanitizeStatusText(`${key}: ${text}`)).filter(Boolean);
+  const width = Math.max(40, (process.stdout.columns ?? 80) - 2);
+  const cwdLine = cwdLineParts.join(" ");
+  const statsLine = statsParts.join(" ");
+  const modelLine = modelParts.filter(Boolean).join("  |  ");
+  const statusLines = chunkLines(statusValues, width);
+  const mutedColor = typeof theme.colors.muted === "string" && theme.colors.muted.trim().length > 0 ? theme.colors.muted : "gray";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: mutedColor, children: cwdLine }),
+    /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsx(Text, { color: mutedColor, children: statsLine }),
+      /* @__PURE__ */ jsx(Text, { color: mutedColor, children: modelLine })
+    ] }),
+    statusLines.map((line, index) => /* @__PURE__ */ jsx(Text, { color: mutedColor, children: line }, `footer-status:${index}`))
+  ] });
+}
+
+// src/react-ink/utils/message-groups.ts
+function parseSkillBlock(text) {
+  const match = text.match(/^<skill name="([^"]+)" location="([^"]+)">\n([\s\S]*?)\n<\/skill>(?:\n\n([\s\S]+))?$/);
+  if (!match) return null;
+  return {
+    name: match[1] ?? "",
+    location: match[2] ?? "",
+    content: match[3] ?? "",
+    userMessage: match[4]?.trim() || void 0
+  };
+}
+function isTextContent(value) {
+  return typeof value === "object" && value !== null && value.type === "text";
+}
+function isImageContent(value) {
+  return typeof value === "object" && value !== null && value.type === "image";
+}
+function isThinkingContent(value) {
+  return typeof value === "object" && value !== null && value.type === "thinking";
+}
+function isToolCall(value) {
+  return typeof value === "object" && value !== null && value.type === "toolCall";
+}
+function previewText(value, maxLength = 88) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, maxLength - 1)}...`;
+}
+function safeStringify(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    return typeof serialized === "string" ? serialized : "";
+  } catch {
+    return String(value);
+  }
+}
+function parseJsonString(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+function extractStructuredText(value, showImages, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value == null) {
+    return [];
+  }
+  if (typeof value === "string") {
+    const parsed = parseJsonString(value);
+    if (parsed !== void 0) {
+      const extracted = extractStructuredText(parsed, showImages, seen);
+      if (extracted.length > 0) {
+        return extracted;
+      }
+    }
+    return value.trim() ? [value] : [];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => extractStructuredText(item, showImages, seen));
+  }
+  if (typeof value !== "object") {
+    return [];
+  }
+  const record = value;
+  if (seen.has(record)) {
+    return [];
+  }
+  seen.add(record);
+  if (isTextContent(record)) {
+    return extractStructuredText(record.text, showImages, seen);
+  }
+  if (isImageContent(record)) {
+    return showImages ? [`[image: ${record.mimeType}]`] : [];
+  }
+  if ("content" in record) {
+    const extracted = extractStructuredText(record.content, showImages, seen);
+    if (extracted.length > 0) {
+      return extracted;
+    }
+  }
+  if ("details" in record) {
+    const extracted = extractStructuredText(record.details, showImages, seen);
+    if (extracted.length > 0) {
+      return extracted;
+    }
+  }
+  for (const key of ["text", "output", "stdout", "stderr", "message", "summary"]) {
+    if (!(key in record)) {
+      continue;
+    }
+    const extracted = extractStructuredText(record[key], showImages, seen);
+    if (extracted.length > 0) {
+      return extracted;
+    }
+  }
+  return [];
+}
+function extractToolText(value, showImages) {
+  if (value == null) {
+    return "";
+  }
+  const extracted = extractStructuredText(value, showImages).map((part) => part.trimEnd()).filter((part) => part.length > 0);
+  if (extracted.length > 0) {
+    return extracted.join("\n").trim();
+  }
+  const fallback = safeStringify(value).trim();
+  return fallback === "{}" ? "" : fallback;
+}
+function previewMultiline(value, options = {}) {
+  const { maxChars = 800, maxLines = 6 } = options;
+  const normalized = value.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return "";
+  }
+  const lines = normalized.split("\n");
+  const clippedLines = lines.slice(0, maxLines);
+  let preview = clippedLines.join("\n");
+  let truncated = lines.length > maxLines;
+  if (preview.length > maxChars) {
+    preview = `${preview.slice(0, Math.max(0, maxChars - 1)).trimEnd()}\u2026`;
+    truncated = true;
+  }
+  if (truncated) {
+    return `${preview}
+...`;
+  }
+  return preview;
+}
+function formatUserContent(content, showImages) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const lines = [];
+  for (const part of content) {
+    if (isTextContent(part)) lines.push(part.text);
+    if (showImages && isImageContent(part)) lines.push(`[image: ${part.mimeType}]`);
+  }
+  return lines.join("\n").trim();
+}
+function splitAssistantMessage(message, showThinking) {
+  const textParts = [];
+  const thinkingParts = [];
+  const toolCalls = [];
+  for (const part of message.content) {
+    if (isTextContent(part)) {
+      textParts.push(part.text);
+      continue;
+    }
+    if (showThinking && isThinkingContent(part)) {
+      thinkingParts.push(part.thinking);
+      continue;
+    }
+    if (isToolCall(part)) {
+      toolCalls.push(part);
+    }
+  }
+  return {
+    text: textParts.join(""),
+    thinking: thinkingParts,
+    toolCalls
+  };
+}
+function formatToolCall(toolCall) {
+  const args = Object.keys(toolCall.arguments ?? {}).length > 0 ? safeStringify(toolCall.arguments) : "{}";
+  return `${toolCall.name}
+${previewMultiline(args, { maxLines: 8, maxChars: 1600 })}`;
+}
+function formatToolResult(message, showImages) {
+  const contentText = extractToolText(message.content, showImages);
+  if (contentText) {
+    return contentText;
+  }
+  if (message.details !== void 0) {
+    return extractToolText(message.details, showImages);
+  }
+  return "";
+}
+function formatCustomContent(content, showImages) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (isTextContent(part)) return part.text;
+    if (showImages && isImageContent(part)) return `[image: ${part.mimeType}]`;
+    return "";
+  }).filter(Boolean).join("\n");
+}
+function formatMessageTimestamp(timestamp) {
+  return new Date(timestamp).toLocaleTimeString([], {
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function extractMessagePreview(message) {
+  switch (message.role) {
+    case "user":
+      return previewText(formatUserContent(message.content, true));
+    case "assistant":
+      return previewText(splitAssistantMessage(message, false).text);
+    case "toolResult":
+      return previewText(formatToolResult(message, true));
+    case "bashExecution":
+      return previewText(`${message.command} ${message.output}`.trim());
+    case "branchSummary":
+    case "compactionSummary":
+      return previewText(message.summary);
+    case "custom":
+      return previewText(formatCustomContent(message.content, true));
+    default:
+      return previewText(safeStringify(message));
+  }
+}
+function parseSkillInvocation(content) {
+  const parsed = parseSkillBlock(content);
+  if (!parsed) return null;
+  return {
+    name: parsed.name,
+    location: parsed.location,
+    userMessage: parsed.userMessage
+  };
+}
+
+// src/react-host/index.ts
+var React = await loadHostReact();
+var Fragment2 = React.Fragment;
+var createElement = React.createElement;
+var useEffect = React.useEffect;
+var useMemo = React.useMemo;
+var useState = React.useState;
+
+// src/react-ink/markdown/format-token.ts
+import chalk2 from "chalk";
+import { marked } from "marked";
+import stripAnsi3 from "strip-ansi";
+
+// src/ui/utils.ts
+import { eastAsianWidth } from "get-east-asian-width";
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var TextWidthCalculator = class {
+  getWidth(text) {
+    return visibleWidth(text);
+  }
+  clearCache() {
+    widthCache.clear();
+  }
+};
+var textWidthCalculator = new TextWidthCalculator();
+function looksLikeEmojiCandidate(segment) {
+  const cp = segment.codePointAt(0);
+  return cp >= 126976 && cp <= 130047 || // pictographs and emoji proper
+  cp >= 8960 && cp <= 9215 || // miscellaneous technical glyphs
+  cp >= 9728 && cp <= 10175 || // assorted symbols and dingbats
+  cp >= 11088 && cp <= 11093 || // a few star/circle characters
+  segment.includes("\uFE0F") || // carries VS16, the emoji-presentation selector
+  segment.length > 2;
+}
+function createUnicodeRegex(vPattern, uFallback) {
+  try {
+    return new RegExp(vPattern, "v");
+  } catch {
+    return new RegExp(uFallback, "u");
+  }
+}
+var zeroWidthRegex = createUnicodeRegex(
+  "^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$",
+  "^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$"
+);
+var leadingNonPrintingRegex = createUnicodeRegex(
+  "^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+",
+  "^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+"
+);
+var rgiEmojiRegex = createUnicodeRegex("^\\p{RGI_Emoji}$", "^\\p{Extended_Pictographic}$");
+var AnsiStripper = {
+  strip(text) {
+    if (!text.includes("\x1B")) {
+      return text;
+    }
+    let cleaned = text;
+    cleaned = cleaned.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "");
+    cleaned = cleaned.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
+    cleaned = cleaned.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+    return cleaned;
+  }
+};
+var WIDTH_CACHE_SIZE = 512;
+var widthCache = /* @__PURE__ */ new Map();
+function measureClusterWidth(segment) {
+  if (zeroWidthRegex.test(segment)) {
+    return 0;
+  }
+  if (looksLikeEmojiCandidate(segment) && rgiEmojiRegex.test(segment)) {
+    return 2;
+  }
+  const base = segment.replace(leadingNonPrintingRegex, "");
+  const cp = base.codePointAt(0);
+  if (cp === void 0) {
+    return 0;
+  }
+  let width = eastAsianWidth(cp);
+  if (segment.length > 1) {
+    for (const char of segment.slice(1)) {
+      const c = char.codePointAt(0);
+      if (c >= 65280 && c <= 65519) {
+        width += eastAsianWidth(c);
+      }
+    }
+  }
+  return width;
+}
+function visibleWidth(str) {
+  if (str.length === 0) {
+    return 0;
+  }
+  let isPureAscii = true;
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i);
+    if (code < 32 || code > 126) {
+      isPureAscii = false;
+      break;
+    }
+  }
+  if (isPureAscii) {
+    return str.length;
+  }
+  const cached = widthCache.get(str);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let clean = str;
+  if (str.includes("	")) {
+    clean = clean.replace(/\t/g, "   ");
+  }
+  clean = AnsiStripper.strip(clean);
+  let width = 0;
+  for (const { segment } of segmenter.segment(clean)) {
+    width += measureClusterWidth(segment);
+  }
+  if (widthCache.size >= WIDTH_CACHE_SIZE) {
+    const firstKey = widthCache.keys().next().value;
+    if (firstKey !== void 0) {
+      widthCache.delete(firstKey);
+    }
+  }
+  widthCache.set(str, width);
+  return width;
+}
+function extractAnsiCode(str, pos) {
+  if (pos >= str.length || str[pos] !== "\x1B") return null;
+  const next = str[pos + 1];
+  if (next === "[") {
+    let j = pos + 2;
+    while (j < str.length && !/[mGKHJ]/.test(str[j])) j++;
+    if (j < str.length) return { code: str.substring(pos, j + 1), length: j + 1 - pos };
+    return null;
+  }
+  if (next === "]") {
+    let j = pos + 2;
+    while (j < str.length) {
+      if (str[j] === "\x07") return { code: str.substring(pos, j + 1), length: j + 1 - pos };
+      if (str[j] === "\x1B" && str[j + 1] === "\\") return { code: str.substring(pos, j + 2), length: j + 2 - pos };
+      j++;
+    }
+    return null;
+  }
+  if (next === "_") {
+    let j = pos + 2;
+    while (j < str.length) {
+      if (str[j] === "\x07") return { code: str.substring(pos, j + 1), length: j + 1 - pos };
+      if (str[j] === "\x1B" && str[j + 1] === "\\") return { code: str.substring(pos, j + 2), length: j + 2 - pos };
+      j++;
+    }
+    return null;
+  }
+  return null;
+}
+var AnsiStateTracker = class {
+  // Each attribute is kept on its own flag, which lets us clear them one at a time.
+  _bold = false;
+  _dim = false;
+  italic = false;
+  underline = false;
+  blink = false;
+  inverse = false;
+  hidden = false;
+  strikethrough = false;
+  _colors = { fg: null, bg: null };
+  process(ansiCode) {
+    if (!ansiCode.endsWith("m")) {
+      return;
+    }
+    const match = ansiCode.match(/\x1b\[([\d;]*)m/);
+    if (!match) return;
+    const params = match[1];
+    if (params === "" || params === "0") {
+      this.reset();
+      return;
+    }
+    const parts = params.split(";");
+    let i = 0;
+    while (i < parts.length) {
+      const code = Number.parseInt(parts[i] ?? "", 10);
+      if (Number.isNaN(code)) {
+        i++;
+        continue;
+      }
+      const consumed = this.tryConsumeColorCode(parts, i, code);
+      if (consumed > 0) {
+        i += consumed;
+        continue;
+      }
+      this.applyStandardCode(code);
+      i++;
+    }
+  }
+  tryConsumeColorCode(parts, index, code) {
+    if (code !== 38 && code !== 48) {
+      return 0;
+    }
+    if (parts[index + 1] === "5" && parts[index + 2] !== void 0) {
+      const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]}`;
+      if (code === 38) {
+        this._colors.fg = colorCode;
+      } else {
+        this._colors.bg = colorCode;
+      }
+      return 3;
+    }
+    if (parts[index + 1] === "2" && parts[index + 4] !== void 0) {
+      const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]};${parts[index + 3]};${parts[index + 4]}`;
+      if (code === 38) {
+        this._colors.fg = colorCode;
+      } else {
+        this._colors.bg = colorCode;
+      }
+      return 5;
+    }
+    return 0;
+  }
+  applyStandardCode(code) {
+    switch (code) {
+      case 0:
+        this.reset();
+        return;
+      case 1:
+        this._bold = true;
+        return;
+      case 2:
+        this._dim = true;
+        return;
+      case 3:
+        this.italic = true;
+        return;
+      case 4:
+        this.underline = true;
+        return;
+      case 5:
+        this.blink = true;
+        return;
+      case 7:
+        this.inverse = true;
+        return;
+      case 8:
+        this.hidden = true;
+        return;
+      case 9:
+        this.strikethrough = true;
+        return;
+      case 21:
+        this._bold = false;
+        return;
+      case 22:
+        this._bold = false;
+        this._dim = false;
+        return;
+      case 23:
+        this.italic = false;
+        return;
+      case 24:
+        this.underline = false;
+        return;
+      case 25:
+        this.blink = false;
+        return;
+      case 27:
+        this.inverse = false;
+        return;
+      case 28:
+        this.hidden = false;
+        return;
+      case 29:
+        this.strikethrough = false;
+        return;
+      case 39:
+        this._colors.fg = null;
+        return;
+      case 49:
+        this._colors.bg = null;
+        return;
+      default:
+        if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+          this._colors.fg = String(code);
+          return;
+        }
+        if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+          this._colors.bg = String(code);
+        }
+    }
+  }
+  reset() {
+    this._bold = false;
+    this._dim = false;
+    this.italic = false;
+    this.underline = false;
+    this.blink = false;
+    this.inverse = false;
+    this.hidden = false;
+    this.strikethrough = false;
+    this._colors.fg = null;
+    this._colors.bg = null;
+  }
+  /** Wipe all tracked state so the instance can be reused. */
+  clear() {
+    this.reset();
+  }
+  getActiveCodes() {
+    const codes = [];
+    if (this._bold) codes.push("1");
+    if (this._dim) codes.push("2");
+    if (this.italic) codes.push("3");
+    if (this.underline) codes.push("4");
+    if (this.blink) codes.push("5");
+    if (this.inverse) codes.push("7");
+    if (this.hidden) codes.push("8");
+    if (this.strikethrough) codes.push("9");
+    if (this._colors.fg) codes.push(this._colors.fg);
+    if (this._colors.bg) codes.push(this._colors.bg);
+    if (codes.length === 0) return "";
+    return `\x1B[${codes.join(";")}m`;
+  }
+  hasActiveCodes() {
+    return this._bold || this._dim || this.italic || this.underline || this.blink || this.inverse || this.hidden || this.strikethrough || this._colors.fg !== null || this._colors.bg !== null;
+  }
+  /**
+   * Produce the escape code needed to switch off any attribute that would
+   * otherwise smear into the padding at the end of a line. In practice that
+   * is just underline. Yields an empty string when nothing needs disabling.
+   */
+  getLineEndReset() {
+    if (this.underline) {
+      return "\x1B[24m";
+    }
+    return "";
+  }
+};
+function mergeTextIntoTracker(text, tracker) {
+  let i = 0;
+  while (i < text.length) {
+    const ansiResult = extractAnsiCode(text, i);
+    if (ansiResult) {
+      tracker.process(ansiResult.code);
+      i += ansiResult.length;
+    } else {
+      i++;
+    }
+  }
+}
+function tokenizeTextWithAnsi(text) {
+  const tokens = [];
+  let current = "";
+  let pendingAnsi = "";
+  let inWhitespace = false;
+  let i = 0;
+  while (i < text.length) {
+    const ansiResult = extractAnsiCode(text, i);
+    if (ansiResult) {
+      pendingAnsi += ansiResult.code;
+      i += ansiResult.length;
+      continue;
+    }
+    const char = text[i];
+    const charIsSpace = char === " ";
+    if (charIsSpace !== inWhitespace && current) {
+      tokens.push(current);
+      current = "";
+    }
+    if (pendingAnsi) {
+      current += pendingAnsi;
+      pendingAnsi = "";
+    }
+    inWhitespace = charIsSpace;
+    current += char;
+    i++;
+  }
+  if (pendingAnsi) {
+    current += pendingAnsi;
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+var TextWrapper = class {
+  wrap(text, width) {
+    return wrapTextWithAnsi(text, width);
+  }
+};
+var textWrapper = new TextWrapper();
+var TokenWrapEngine = {
+  wrap(tokens, width, tracker) {
+    const wrapped = [];
+    let currentLine = "";
+    let currentVisibleLength = 0;
+    for (const token of tokens) {
+      const tokenVisibleLength = visibleWidth(token);
+      const isWhitespace = token.trim() === "";
+      if (tokenVisibleLength > width && !isWhitespace) {
+        if (currentLine) {
+          const lineEndReset = tracker.getLineEndReset();
+          if (lineEndReset) {
+            currentLine += lineEndReset;
+          }
+          wrapped.push(currentLine);
+          currentLine = "";
+          currentVisibleLength = 0;
+        }
+        const broken = splitLongToken(token, width, tracker);
+        wrapped.push(...broken.slice(0, -1));
+        currentLine = broken[broken.length - 1];
+        currentVisibleLength = visibleWidth(currentLine);
+        continue;
+      }
+      const totalNeeded = currentVisibleLength + tokenVisibleLength;
+      if (totalNeeded > width && currentVisibleLength > 0) {
+        let lineToWrap = currentLine.trimEnd();
+        const lineEndReset = tracker.getLineEndReset();
+        if (lineEndReset) {
+          lineToWrap += lineEndReset;
+        }
+        wrapped.push(lineToWrap);
+        if (isWhitespace) {
+          currentLine = tracker.getActiveCodes();
+          currentVisibleLength = 0;
+        } else {
+          currentLine = tracker.getActiveCodes() + token;
+          currentVisibleLength = tokenVisibleLength;
+        }
+      } else {
+        currentLine += token;
+        currentVisibleLength += tokenVisibleLength;
+      }
+      mergeTextIntoTracker(token, tracker);
+    }
+    return { wrapped, currentLine, currentVisibleLength };
+  }
+};
+function wrapTextWithAnsi(text, width) {
+  if (!text) {
+    return [""];
+  }
+  const inputLines = text.split("\n");
+  const result = [];
+  const tracker = new AnsiStateTracker();
+  for (const inputLine of inputLines) {
+    const prefix = result.length > 0 ? tracker.getActiveCodes() : "";
+    result.push(...wrapLinePreservingAnsi(prefix + inputLine, width));
+    mergeTextIntoTracker(inputLine, tracker);
+  }
+  return result.length > 0 ? result : [""];
+}
+function wrapLinePreservingAnsi(line, width) {
+  if (!line) {
+    return [""];
+  }
+  const visibleLength = visibleWidth(line);
+  if (visibleLength <= width) {
+    return [line];
+  }
+  const tracker = new AnsiStateTracker();
+  const tokens = tokenizeTextWithAnsi(line);
+  const { wrapped, currentLine } = TokenWrapEngine.wrap(tokens, width, tracker);
+  if (currentLine) {
+    wrapped.push(currentLine);
+  }
+  return wrapped.length > 0 ? wrapped.map((segmentLine) => segmentLine.trimEnd()) : [""];
+}
+function splitLongToken(word, width, tracker) {
+  const lines = [];
+  let currentLine = tracker.getActiveCodes();
+  let currentWidth = 0;
+  let i = 0;
+  const segments = [];
+  while (i < word.length) {
+    const ansiResult = extractAnsiCode(word, i);
+    if (ansiResult) {
+      segments.push({ type: "ansi", value: ansiResult.code });
+      i += ansiResult.length;
+    } else {
+      let end = i;
+      while (end < word.length) {
+        const nextAnsi = extractAnsiCode(word, end);
+        if (nextAnsi) break;
+        end++;
+      }
+      const textPortion = word.slice(i, end);
+      for (const seg of segmenter.segment(textPortion)) {
+        segments.push({ type: "grapheme", value: seg.segment });
+      }
+      i = end;
+    }
+  }
+  for (const seg of segments) {
+    if (seg.type === "ansi") {
+      currentLine += seg.value;
+      tracker.process(seg.value);
+      continue;
+    }
+    const grapheme = seg.value;
+    if (!grapheme) continue;
+    const clusterWidth = visibleWidth(grapheme);
+    if (currentWidth + clusterWidth > width) {
+      const lineEndReset = tracker.getLineEndReset();
+      if (lineEndReset) {
+        currentLine += lineEndReset;
+      }
+      lines.push(currentLine);
+      currentLine = tracker.getActiveCodes();
+      currentWidth = 0;
+    }
+    currentLine += grapheme;
+    currentWidth += clusterWidth;
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+var pooledStyleTracker = new AnsiStateTracker();
+
+// src/react-ink/markdown/format-token.ts
+var EOL = "\n";
+var BLOCKQUOTE_BAR = "\u2502";
+var markedConfigured = false;
+function configureMarked() {
+  if (markedConfigured) {
+    return;
+  }
+  markedConfigured = true;
+  marked.use({
+    tokenizer: {
+      del() {
+        return void 0;
+      }
+    }
+  });
+}
+var TOKEN_CACHE_MAX = 500;
+var tokenCache = /* @__PURE__ */ new Map();
+var MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|^\d+\. |\n\d+\. /;
+function hasMarkdownSyntax(text) {
+  return MD_SYNTAX_RE.test(text.length > 500 ? text.slice(0, 500) : text);
+}
+function hashContent(content) {
+  let hash = 2166136261;
+  for (let i = 0; i < content.length; i++) {
+    hash ^= content.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36) + ":" + content.length.toString(36);
+}
+function cachedLexer(content) {
+  configureMarked();
+  if (!hasMarkdownSyntax(content)) {
+    return [
+      {
+        type: "paragraph",
+        raw: content,
+        text: content,
+        tokens: [{ type: "text", raw: content, text: content }]
+      }
+    ];
+  }
+  const key = hashContent(content);
+  const hit = tokenCache.get(key);
+  if (hit) {
+    tokenCache.delete(key);
+    tokenCache.set(key, hit);
+    return hit;
+  }
+  const tokens = marked.lexer(content);
+  if (tokenCache.size >= TOKEN_CACHE_MAX) {
+    const first = tokenCache.keys().next().value;
+    if (first !== void 0) {
+      tokenCache.delete(first);
+    }
+  }
+  tokenCache.set(key, tokens);
+  return tokens;
+}
+function formatToken(token, theme, highlight = null, listDepth = 0, orderedListNumber = null, parent = null) {
+  switch (token.type) {
+    case "blockquote": {
+      const inner = (token.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+      const bar = theme.dim(BLOCKQUOTE_BAR);
+      return inner.split(EOL).map((line) => stripAnsi3(line).trim() ? `${bar} ${chalk2.italic(line)}` : line).join(EOL);
+    }
+    case "code": {
+      const codeToken = token;
+      if (!highlight) {
+        return codeToken.text + EOL;
+      }
+      let language = "plaintext";
+      if (codeToken.lang && highlight.supportsLanguage(codeToken.lang)) {
+        language = codeToken.lang;
+      }
+      return highlight.highlight(codeToken.text, { language }) + EOL;
+    }
+    case "codespan":
+      return theme.role("codeInline", token.text);
+    case "em":
+      return chalk2.italic(
+        (token.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, parent)).join("")
+      );
+    case "strong":
+      return chalk2.bold(
+        (token.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, parent)).join("")
+      );
+    case "heading": {
+      const headingToken = token;
+      const inner = (headingToken.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+      const colored = theme.role("heading", inner);
+      if (headingToken.depth === 1) {
+        return chalk2.bold.italic.underline(colored) + EOL + EOL;
+      }
+      return chalk2.bold(colored) + EOL + EOL;
+    }
+    case "hr":
+      return "---";
+    case "image":
+      return token.href;
+    case "link": {
+      const linkToken = token;
+      if (linkToken.href.startsWith("mailto:")) {
+        return linkToken.href.replace(/^mailto:/, "");
+      }
+      const linkText = (linkToken.tokens ?? []).map((child) => formatToken(child, theme, highlight, 0, null, linkToken)).join("");
+      const plainLinkText = stripAnsi3(linkText);
+      const display = plainLinkText && plainLinkText !== linkToken.href ? linkText : linkToken.href;
+      return `\x1B]8;;${linkToken.href}\x07${display}\x1B]8;;\x07`;
+    }
+    case "list": {
+      const listToken = token;
+      const start = typeof listToken.start === "number" ? listToken.start : Number(listToken.start) || 1;
+      return listToken.items.map(
+        (item, index) => formatToken(
+          item,
+          theme,
+          highlight,
+          listDepth,
+          listToken.ordered ? start + index : null,
+          listToken
+        )
+      ).join("");
+    }
+    case "list_item":
+      return (token.tokens ?? []).map(
+        (child) => `${"  ".repeat(listDepth)}${formatToken(child, theme, highlight, listDepth + 1, orderedListNumber, token)}`
+      ).join("");
+    case "paragraph":
+      return (token.tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("") + EOL;
+    case "space":
+    case "br":
+      return EOL;
+    case "text": {
+      const textToken = token;
+      if (parent?.type === "link") {
+        return textToken.text;
+      }
+      if (parent?.type === "list_item") {
+        const marker = orderedListNumber === null ? "-" : `${getListNumber(listDepth, orderedListNumber)}.`;
+        const body = textToken.tokens ? textToken.tokens.map((child) => formatToken(child, theme, highlight, listDepth, orderedListNumber, token)).join("") : textToken.text;
+        return `${marker} ${body}${EOL}`;
+      }
+      return textToken.text;
+    }
+    case "escape":
+      return token.text;
+    case "table":
+    case "def":
+    case "del":
+    case "html":
+      return "";
+    default:
+      return "";
+  }
+}
+function numberToLetter(n) {
+  let result = "";
+  while (n > 0) {
+    n--;
+    result = String.fromCharCode(97 + n % 26) + result;
+    n = Math.floor(n / 26);
+  }
+  return result;
+}
+var ROMAN_VALUES = [
+  [1e3, "m"],
+  [900, "cm"],
+  [500, "d"],
+  [400, "cd"],
+  [100, "c"],
+  [90, "xc"],
+  [50, "l"],
+  [40, "xl"],
+  [10, "x"],
+  [9, "ix"],
+  [5, "v"],
+  [4, "iv"],
+  [1, "i"]
+];
+function numberToRoman(n) {
+  let result = "";
+  for (const [value, numeral] of ROMAN_VALUES) {
+    while (n >= value) {
+      result += numeral;
+      n -= value;
+    }
+  }
+  return result;
+}
+function getListNumber(listDepth, orderedListNumber) {
+  switch (listDepth) {
+    case 0:
+    case 1:
+      return orderedListNumber.toString();
+    case 2:
+      return numberToLetter(orderedListNumber);
+    case 3:
+      return numberToRoman(orderedListNumber);
+    default:
+      return orderedListNumber.toString();
+  }
+}
+function padAligned(content, displayWidth, targetWidth, align) {
+  const padding = Math.max(0, targetWidth - displayWidth);
+  if (align === "center") {
+    const leftPad = Math.floor(padding / 2);
+    return " ".repeat(leftPad) + content + " ".repeat(padding - leftPad);
+  }
+  if (align === "right") {
+    return " ".repeat(padding) + content;
+  }
+  return content + " ".repeat(padding);
+}
+function stringWidth(text) {
+  return visibleWidth(text);
+}
+
+// src/react-ink/markdown/highlight.ts
+import { extname } from "node:path";
+import hljs from "highlight.js";
+function scopeToRole(scope) {
+  const head = scope.split(".")[0] ?? scope;
+  switch (head) {
+    case "keyword":
+    case "built_in":
+    case "literal":
+    case "operator":
+      return "synKeyword";
+    case "string":
+    case "regexp":
+    case "symbol":
+    case "char":
+    case "meta":
+      return "synString";
+    case "number":
+      return "synNumber";
+    case "comment":
+    case "quote":
+      return "synComment";
+    case "type":
+    case "class":
+    case "title":
+    case "tag":
+    case "name":
+    case "attr":
+    case "attribute":
+    case "selector":
+      return "synType";
+    default:
+      return null;
+  }
+}
+var HTML_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#x27;": "'",
+  "&#39;": "'"
+};
+function decodeEntities(text) {
+  return text.replace(/&(?:amp|lt|gt|quot|#x27|#39);/g, (match) => HTML_ENTITIES[match] ?? match);
+}
+function parseHljsHtml(html) {
+  const nodes = [];
+  const scopeStack = [];
+  const tagRe = /<span class="hljs-([^"]+)">|<\/span>/g;
+  let lastIndex = 0;
+  let match;
+  const pushText = (raw) => {
+    if (!raw) return;
+    const currentScope = scopeStack.length > 0 ? scopeStack[scopeStack.length - 1] : null;
+    const scope = currentScope ? currentScope.split(/\s+/)[0].replace(/_$/, "") : null;
+    nodes.push({ text: decodeEntities(raw), scope });
+  };
+  while ((match = tagRe.exec(html)) !== null) {
+    pushText(html.slice(lastIndex, match.index));
+    lastIndex = tagRe.lastIndex;
+    if (match[0] === "</span>") {
+      scopeStack.pop();
+    } else if (match[1]) {
+      scopeStack.push(match[1]);
+    }
+  }
+  pushText(html.slice(lastIndex));
+  return nodes;
+}
+function createHighlighter(theme) {
+  return {
+    supportsLanguage: (language) => {
+      if (!language || language === "plaintext" || language === "text") {
+        return false;
+      }
+      try {
+        return hljs.getLanguage(language) !== void 0;
+      } catch {
+        return false;
+      }
+    },
+    highlight: (code, options) => {
+      const language = options.language;
+      if (!language || language === "plaintext" || language === "text") {
+        return code;
+      }
+      try {
+        if (hljs.getLanguage(language) === void 0) {
+          return code;
+        }
+        const { value } = hljs.highlight(code, { language, ignoreIllegals: true });
+        return parseHljsHtml(value).map((node) => {
+          const role = node.scope ? scopeToRole(node.scope) : null;
+          return role ? theme.role(role, node.text) : node.text;
+        }).join("");
+      } catch {
+        return code;
+      }
+    }
+  };
+}
+function highlightByPath(code, filePath, theme) {
+  const language = languageFromPath(filePath);
+  if (!language) {
+    return code;
+  }
+  const highlighter = createHighlighter(theme);
+  if (!highlighter.supportsLanguage(language)) {
+    return code;
+  }
+  return highlighter.highlight(code, { language });
+}
+var EXTENSION_LANGUAGES = {
+  ts: "typescript",
+  tsx: "typescript",
+  mts: "typescript",
+  cts: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  py: "python",
+  rb: "ruby",
+  rs: "rust",
+  go: "go",
+  java: "java",
+  kt: "kotlin",
+  c: "c",
+  h: "c",
+  cc: "cpp",
+  cpp: "cpp",
+  hpp: "cpp",
+  cs: "csharp",
+  sh: "bash",
+  bash: "bash",
+  zsh: "bash",
+  yml: "yaml",
+  yaml: "yaml",
+  json: "json",
+  md: "markdown",
+  html: "xml",
+  xml: "xml",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  toml: "ini",
+  ini: "ini",
+  php: "php",
+  swift: "swift"
+};
+function languageFromPath(filePath) {
+  const ext = extname(filePath).slice(1).toLowerCase();
+  if (!ext) {
+    return null;
+  }
+  const mapped = EXTENSION_LANGUAGES[ext];
+  if (mapped) {
+    return mapped;
+  }
+  try {
+    return hljs.getLanguage(ext) !== void 0 ? ext : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/react-ink/markdown/MarkdownTable.tsx
+import chalk3 from "chalk";
+import stripAnsi4 from "strip-ansi";
+var MIN_COLUMN_WIDTH = 3;
+var COLUMN_GAP = 2;
+function MarkdownTable({ token, theme, highlight = null }) {
+  const formatCell = (tokens) => (tokens ?? []).map((child) => formatToken(child, theme, highlight)).join("");
+  const displayWidth = (tokens) => stringWidth(stripAnsi4(formatCell(tokens)));
+  const columnCount = token.header.length;
+  const columnWidths = token.header.map((header, index) => {
+    let max = displayWidth(header.tokens);
+    for (const row of token.rows) {
+      max = Math.max(max, displayWidth(row[index]?.tokens));
+    }
+    return Math.max(max, MIN_COLUMN_WIDTH);
+  });
+  const renderRow = (cells, key, bold) => /* @__PURE__ */ jsx(Box, { flexDirection: "row", children: columnWidths.map((width, index) => {
+    const cell = cells[index];
+    const content = formatCell(cell?.tokens);
+    const visible = stringWidth(stripAnsi4(content));
+    const align = token.align?.[index];
+    const padded = padAligned(content, visible, width, align ?? "left");
+    const styled = bold ? chalk3.bold(padded) : padded;
+    const gap = index < columnCount - 1 ? " ".repeat(COLUMN_GAP) : "";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      styled,
+      gap
+    ] }, index);
+  }) }, key);
+  const separator = /* @__PURE__ */ jsx(Box, { flexDirection: "row", children: columnWidths.map((width, index) => {
+    const gap = index < columnCount - 1 ? " ".repeat(COLUMN_GAP) : "";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      theme.dim("-".repeat(width)),
+      gap
+    ] }, index);
+  }) });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    renderRow(token.header, "header", true),
+    separator,
+    token.rows.map((row, rowIndex) => renderRow(row, `row-${rowIndex}`, false))
+  ] });
+}
+
+// src/react-ink/markdown/Markdown.tsx
+function stripPromptXMLTags(text) {
+  return text.replace(/<\/?(?:system-reminder|prompt|context)[^>]*>/g, "");
+}
+function Markdown({ children, theme, highlightCode = true, dim = false }) {
+  const highlight = useMemo(
+    () => highlightCode ? createHighlighter(theme) : null,
+    [highlightCode, theme]
+  );
+  const elements = useMemo(() => {
+    configureMarked();
+    const tokens = cachedLexer(stripPromptXMLTags(children));
+    const out = [];
+    let buffer = "";
+    const flush = () => {
+      if (buffer) {
+        const text = buffer.replace(/\n+$/, "");
+        if (text) {
+          out.push(
+            /* @__PURE__ */ jsx(Text, { children: dim ? theme.dim(text) : text }, out.length)
+          );
+        }
+        buffer = "";
+      }
+    };
+    for (const token of tokens) {
+      if (token.type === "table") {
+        flush();
+        out.push(
+          /* @__PURE__ */ jsx(
+            MarkdownTable,
+            {
+              token,
+              theme,
+              highlight
+            },
+            out.length
+          )
+        );
+      } else {
+        buffer += formatToken(token, theme, highlight);
+      }
+    }
+    flush();
+    return out;
+  }, [children, dim, highlight, theme]);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: elements });
+}
+
+// src/react-ink/utils/tool-display.ts
+import { homedir } from "node:os";
+
+// src/react-ink/diff/structured.ts
+import { structuredPatch } from "diff";
+
+// src/react-ink/diff/word-diff.ts
+import { diffWordsWithSpace } from "diff";
+var CHANGE_THRESHOLD = 0.4;
+function wordDiffLine(oldLine, newLine, side) {
+  const lineText = side === "removed" ? oldLine : newLine;
+  if (oldLine.length === 0 || newLine.length === 0) {
+    return [{ text: lineText, changed: true }];
+  }
+  let changes;
+  try {
+    changes = diffWordsWithSpace(oldLine, newLine);
+  } catch {
+    return [{ text: lineText, changed: true }];
+  }
+  let changedChars = 0;
+  let totalChars = 0;
+  for (const change of changes) {
+    totalChars += change.value.length;
+    if (change.added || change.removed) {
+      changedChars += change.value.length;
+    }
+  }
+  const fraction = totalChars === 0 ? 0 : changedChars / totalChars;
+  if (fraction > CHANGE_THRESHOLD) {
+    return [{ text: lineText, changed: true }];
+  }
+  const spans = [];
+  for (const change of changes) {
+    const belongs = side === "removed" ? !change.added : !change.removed;
+    if (!belongs) {
+      continue;
+    }
+    spans.push({ text: change.value, changed: Boolean(change.added || change.removed) });
+  }
+  return spans.length > 0 ? spans : [{ text: lineText, changed: false }];
+}
+
+// src/react-ink/diff/structured.ts
+var CONTEXT_LINES = 3;
+function buildStructuredDiff(oldStr, newStr, filePath = "") {
+  if (oldStr === newStr) {
+    return null;
+  }
+  let patch;
+  try {
+    patch = structuredPatch(filePath, filePath, oldStr, newStr, "", "", { context: CONTEXT_LINES });
+  } catch {
+    return null;
+  }
+  const hunks = [];
+  let addedCount = 0;
+  let removedCount = 0;
+  for (const hunk of patch.hunks) {
+    const lines = classifyHunkLines(hunk);
+    for (const line of lines) {
+      if (line.kind === "added") addedCount += 1;
+      else if (line.kind === "removed") removedCount += 1;
+    }
+    if (lines.length > 0) {
+      hunks.push({ oldStart: hunk.oldStart, newStart: hunk.newStart, lines });
+    }
+  }
+  if (hunks.length === 0) {
+    return null;
+  }
+  return { hunks, addedCount, removedCount };
+}
+function classifyHunkLines(hunk) {
+  const out = [];
+  let oldNum = hunk.oldStart;
+  let newNum = hunk.newStart;
+  const rawLines = hunk.lines.filter((line) => !line.startsWith("\\"));
+  let removedRun = [];
+  let removedRunStart = -1;
+  const flushPairing = (addedRun2) => {
+    const pairs = Math.min(removedRun.length, addedRun2.length);
+    for (let i = 0; i < pairs; i += 1) {
+      const removed = removedRun[i];
+      const added = addedRun2[i];
+      removed.spans = wordDiffLine(removed.text, added.text, "removed");
+      added.spans = wordDiffLine(removed.text, added.text, "added");
+    }
+    removedRun = [];
+    removedRunStart = -1;
+  };
+  let addedRun = [];
+  for (const raw of rawLines) {
+    const marker = raw[0];
+    const text = raw.slice(1);
+    if (marker === "-") {
+      if (addedRun.length > 0) {
+        addedRun = [];
+      }
+      const line = { kind: "removed", oldLine: oldNum, text };
+      out.push(line);
+      if (removedRunStart === -1) removedRunStart = out.length - 1;
+      removedRun.push(line);
+      oldNum += 1;
+    } else if (marker === "+") {
+      const line = { kind: "added", newLine: newNum, text };
+      out.push(line);
+      addedRun.push(line);
+      newNum += 1;
+    } else {
+      if (removedRun.length > 0 && addedRun.length > 0) {
+        flushPairing(addedRun);
+      }
+      removedRun = [];
+      removedRunStart = -1;
+      addedRun = [];
+      out.push({ kind: "context", oldLine: oldNum, newLine: newNum, text });
+      oldNum += 1;
+      newNum += 1;
+    }
+  }
+  if (removedRun.length > 0 && addedRun.length > 0) {
+    flushPairing(addedRun);
+  }
+  return out;
+}
+
+// src/react-ink/utils/tool-display.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function hasOutput(value) {
+  return value !== void 0;
+}
+function shortenPath2(path2) {
+  const home = homedir();
+  return path2.startsWith(home) ? `~${path2.slice(home.length)}` : path2;
+}
+function titleCase(value) {
+  return value.split(/[\s_-]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function friendlyToolName(toolName) {
+  switch (toolName) {
+    case "ls":
+      return "LS";
+    case "read":
+      return "Read";
+    case "write":
+      return "Write";
+    case "edit":
+      return "Edit";
+    case "find":
+      return "Find";
+    case "grep":
+      return "Grep";
+    case "bash":
+      return "Bash";
+    case "task":
+      return "Task";
+    case "todoread":
+      return "Todo Read";
+    case "todowrite":
+      return "Todo Write";
+    default:
+      return titleCase(toolName.replace(/^composio__/, "composio "));
+  }
+}
+function summarizeCommand(command) {
+  return command ? previewText(command.replace(/\s+/g, " "), 88) : void 0;
+}
+function toolText(value, showImages = false) {
+  return extractToolText(value, showImages).trim();
+}
+function containsImage(value) {
+  if (Array.isArray(value)) {
+    return value.some((item) => containsImage(item));
+  }
+  const record = asRecord(value);
+  if (!record) {
+    return false;
+  }
+  if (record.type === "image") {
+    return true;
+  }
+  return Object.values(record).some((item) => containsImage(item));
+}
+function countMeaningfulLines(value) {
+  if (!value?.trim()) {
+    return 0;
+  }
+  return value.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+}
+function firstMeaningfulLine(value) {
+  if (!value?.trim()) {
+    return void 0;
+  }
+  return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+}
+function clipBody(value, maxLines = 8, maxChars = 1400) {
+  if (!value?.trim()) {
+    return void 0;
+  }
+  return previewMultiline(value, { maxLines, maxChars });
+}
+function highlightedBody(body, filePath, theme) {
+  if (!body || !theme || !filePath || languageFromPath(filePath) === null) {
+    return { body };
+  }
+  return { body: highlightByPath(body, filePath, theme), preformatted: true };
+}
+function extractDetails(value) {
+  return asRecord(asRecord(value)?.details);
+}
+function normalizeTodoStatus(value) {
+  switch (value) {
+    case "completed":
+    case "in_progress":
+    case "cancelled":
+    case "pending":
+      return value;
+    default:
+      return "pending";
+  }
+}
+function normalizeTodoPriority(value) {
+  switch (value) {
+    case "high":
+    case "medium":
+    case "low":
+      return value;
+    default:
+      return "medium";
+  }
+}
+function extractTodos(args, output) {
+  const detailTodos = extractDetails(output)?.todos;
+  const argTodos = asRecord(args)?.todos;
+  const source = Array.isArray(detailTodos) ? detailTodos : Array.isArray(argTodos) ? argTodos : [];
+  return source.map((todo) => {
+    const record = asRecord(todo);
+    const content = asString(record?.content)?.trim();
+    if (!content) return void 0;
+    return {
+      content,
+      priority: normalizeTodoPriority(record?.priority),
+      status: normalizeTodoStatus(record?.status)
+    };
+  }).filter((todo) => Boolean(todo));
+}
+function formatTodos(todos) {
+  if (todos.length === 0) return void 0;
+  const lines = todos.slice(0, 6).map((todo) => {
+    const statusLabel = todo.status === "completed" ? "[done]" : todo.status === "in_progress" ? "[doing]" : todo.status === "cancelled" ? "[skip]" : "[todo]";
+    return `${statusLabel} ${todo.priority} ${todo.content}`;
+  });
+  if (todos.length > lines.length) {
+    lines.push(`... ${todos.length - lines.length} more item(s)`);
+  }
+  return lines.join("\n");
+}
+function fallbackSummary(args, fallbackArgsText) {
+  if (fallbackArgsText?.trim()) {
+    return previewText(fallbackArgsText, 88);
+  }
+  const record = asRecord(args);
+  if (!record) return void 0;
+  return previewText(safeStringify(record), 88);
+}
+function fallbackBody(output, fallbackOutputText, showImages = false) {
+  const extracted = toolText(output, showImages);
+  if (extracted) {
+    return clipBody(extracted);
+  }
+  return clipBody(fallbackOutputText);
+}
+function describeToolSource(source) {
+  const { args, fallbackArgsText, fallbackOutputText, output, showImages = false, theme, toolName } = source;
+  const argsRecord = asRecord(args);
+  const details = extractDetails(output);
+  const outputText = toolText(output, showImages);
+  const hasResult = hasOutput(output);
+  const title = friendlyToolName(toolName);
+  switch (toolName) {
+    case "read": {
+      const rawPath = asString(argsRecord?.file_path) ?? asString(argsRecord?.path) ?? "";
+      const offset = asNumber(argsRecord?.offset);
+      const limit = asNumber(argsRecord?.limit);
+      let summary = rawPath ? shortenPath2(rawPath) : void 0;
+      if (summary && (offset !== void 0 || limit !== void 0)) {
+        const start = offset ?? 1;
+        const end = limit !== void 0 ? start + limit - 1 : void 0;
+        summary += `:${start}${end ? `-${end}` : ""}`;
+      }
+      const responseSummary = containsImage(output) ? firstMeaningfulLine(outputText) ?? "Read image" : /unchanged/i.test(outputText) ? "Unchanged since last read" : countMeaningfulLines(outputText) > 0 ? `Read ${countMeaningfulLines(outputText)} ${countMeaningfulLines(outputText) === 1 ? "line" : "lines"}` : "Read file";
+      const readBody = hasResult && !containsImage(output) ? highlightedBody(clipBody(outputText, 10, 1800), rawPath, theme) : { body: hasResult ? clipBody(outputText, 10, 1800) : void 0 };
+      return {
+        title,
+        summary: hasResult ? responseSummary : summary,
+        body: readBody.body,
+        preformatted: readBody.preformatted,
+        emptyText: "Reading file..."
+      };
+    }
+    case "write": {
+      const rawPath = asString(argsRecord?.file_path) ?? asString(argsRecord?.path) ?? "";
+      const content = asString(argsRecord?.content);
+      const responseSummary = firstMeaningfulLine(outputText) ?? "Wrote file";
+      const writeDiff = !hasResult && content !== void 0 && content.length > 0 ? buildStructuredDiff("", content, rawPath) ?? void 0 : void 0;
+      const writeBody = hasResult ? { body: clipBody(outputText, 8, 1500) } : highlightedBody(clipBody(content, 8, 1500), rawPath, theme);
+      return {
+        title,
+        summary: hasResult ? responseSummary : rawPath ? shortenPath2(rawPath) : void 0,
+        body: writeDiff ? void 0 : writeBody.body,
+        preformatted: writeDiff ? void 0 : writeBody.preformatted,
+        diff: writeDiff,
+        emptyText: "Preparing file write..."
+      };
+    }
+    case "edit": {
+      const rawPath = asString(argsRecord?.file_path) ?? asString(argsRecord?.path) ?? "";
+      const oldText = asString(argsRecord?.oldText);
+      const newText = asString(argsRecord?.newText);
+      const replacementPreview = oldText || newText ? clipBody(
+        [
+          oldText ? `- ${previewText(oldText, 90)}` : void 0,
+          newText ? `+ ${previewText(newText, 90)}` : void 0
+        ].filter(Boolean).join("\n"),
+        4,
+        400
+      ) : void 0;
+      const responseSummary = firstMeaningfulLine(outputText) ?? "Applied edit";
+      const editDiff = oldText !== void 0 && newText !== void 0 ? buildStructuredDiff(oldText, newText, rawPath) ?? void 0 : void 0;
+      const editBody = hasResult ? highlightedBody(clipBody(outputText, 8, 1500), rawPath, theme) : { body: replacementPreview };
+      const editChangeSummary = editDiff ? `+${editDiff.addedCount} -${editDiff.removedCount}` : void 0;
+      return {
+        title,
+        summary: hasResult ? editChangeSummary ?? responseSummary : editChangeSummary ?? (rawPath ? shortenPath2(rawPath) : void 0),
+        body: editDiff ? void 0 : editBody.body,
+        preformatted: editDiff ? void 0 : editBody.preformatted,
+        diff: editDiff,
+        emptyText: "Applying edit..."
+      };
+    }
+    case "ls": {
+      const rawPath = asString(argsRecord?.path) ?? ".";
+      const entryCount = countMeaningfulLines(outputText);
+      return {
+        title,
+        summary: hasResult ? `Listed ${entryCount} ${entryCount === 1 ? "entry" : "entries"}` : shortenPath2(rawPath),
+        body: hasResult ? clipBody(outputText, 10, 1400) : void 0,
+        emptyText: "Listing files..."
+      };
+    }
+    case "find": {
+      const pattern = asString(argsRecord?.pattern);
+      const rawPath = asString(argsRecord?.path) ?? ".";
+      const matchCount = countMeaningfulLines(outputText);
+      return {
+        title,
+        summary: hasResult ? `Found ${matchCount} ${matchCount === 1 ? "path" : "paths"}` : pattern ? `${pattern} in ${shortenPath2(rawPath)}` : shortenPath2(rawPath),
+        body: hasResult ? clipBody(outputText, 10, 1400) : void 0,
+        emptyText: "Searching files..."
+      };
+    }
+    case "grep": {
+      const pattern = asString(argsRecord?.pattern);
+      const rawPath = asString(argsRecord?.path) ?? ".";
+      const responseSummary = /no matches found/i.test(outputText) ? "Found 0 matches" : firstMeaningfulLine(outputText) ? "Search results" : "Search complete";
+      return {
+        title,
+        summary: hasResult ? responseSummary : pattern ? `/${pattern}/ in ${shortenPath2(rawPath)}` : shortenPath2(rawPath),
+        body: hasResult ? clipBody(outputText, 10, 1400) : void 0,
+        emptyText: "Searching text..."
+      };
+    }
+    case "bash": {
+      const command = summarizeCommand(asString(argsRecord?.command));
+      const firstLine = firstMeaningfulLine(outputText);
+      const responseSummary = firstLine ? previewText(firstLine, 88) : "Command finished";
+      return {
+        title,
+        summary: hasResult ? responseSummary : command,
+        body: clipBody(outputText, 8, 1800),
+        emptyText: "Running shell command..."
+      };
+    }
+    case "task": {
+      const subagentType = asString(details?.subagentType) ?? asString(argsRecord?.subagent_type) ?? "subagent";
+      const description = asString(details?.description) ?? asString(argsRecord?.description);
+      const responseSummary = firstMeaningfulLine(outputText || asString(details?.result)) ?? "Task finished";
+      return {
+        title,
+        summary: hasResult ? responseSummary : [subagentType, description].filter(Boolean).join(" - "),
+        body: hasResult ? clipBody(outputText || asString(details?.result), 8, 1400) : void 0,
+        emptyText: "Delegating to subagent..."
+      };
+    }
+    case "todoread":
+    case "todowrite": {
+      const todos = extractTodos(args, output);
+      const incompleteCount = asNumber(details?.incompleteCount) ?? todos.filter((todo) => todo.status !== "completed").length;
+      const summary = todos.length > 0 ? `${todos.length} item(s) | ${incompleteCount} open` : fallbackSummary(args, fallbackArgsText);
+      return {
+        title,
+        summary: summary ?? (toolName === "todoread" ? "Read todo list" : "Updated todo list"),
+        body: hasResult ? formatTodos(todos) ?? fallbackBody(output, fallbackOutputText, showImages) : void 0,
+        emptyText: toolName === "todoread" ? "Reading todo list..." : "Updating todo list..."
+      };
+    }
+    default:
+      return {
+        title,
+        summary: hasResult ? firstMeaningfulLine(outputText) ?? "Completed" : fallbackSummary(args, fallbackArgsText),
+        body: fallbackBody(output, fallbackOutputText, showImages),
+        emptyText: "Working..."
+      };
+  }
+}
+function describeToolExecution(tool) {
+  const callDescriptor = describeToolSource({
+    toolName: tool.toolName,
+    args: tool.args,
+    fallbackArgsText: tool.argsText
+  });
+  return {
+    ...callDescriptor,
+    body: clipBody(tool.outputText, 8, 1800),
+    emptyText: tool.status === "running" ? callDescriptor.emptyText : tool.status === "error" ? "Tool failed." : "Tool finished."
+  };
+}
+function describeToolCall(toolCall) {
+  return describeToolSource({
+    toolName: toolCall.name,
+    args: toolCall.arguments
+  });
+}
+function describeToolResult(message, showImages, args, theme) {
+  return describeToolSource({
+    args,
+    toolName: message.toolName,
+    output: {
+      content: message.content,
+      details: message.details
+    },
+    showImages,
+    theme
+  });
+}
+
+// src/react-ink/components/ToolEventBlock.tsx
+import stripAnsi5 from "strip-ansi";
+function statusMarker(status) {
+  switch (status) {
+    case "error":
+      return "!";
+    case "success":
+      return "=";
+    default:
+      return ">";
+  }
+}
+function plainToolText(text) {
+  return stripAnsi5(text);
+}
+function splitVisibleLines(text) {
+  return (text ?? "").split(/\r?\n/).map((line) => line.trimEnd()).filter((line, index, lines) => {
+    if (stripAnsi5(line).length > 0) {
+      return true;
+    }
+    return index !== 0 && index !== lines.length - 1;
+  });
+}
+function clampContentLines(lines, maxContentLines) {
+  if (maxContentLines <= 0) {
+    return {
+      visibleLines: [],
+      hiddenLineCount: lines.length
+    };
+  }
+  if (lines.length <= maxContentLines) {
+    return {
+      visibleLines: lines,
+      hiddenLineCount: 0
+    };
+  }
+  const visibleLimit = Math.max(0, maxContentLines - 1);
+  return {
+    visibleLines: lines.slice(0, visibleLimit),
+    hiddenLineCount: lines.length - visibleLimit
+  };
+}
+function ToolEventBlock({
+  detail,
+  emptyText,
+  indent = 0,
+  marginBottom = 1,
+  maxContentLines = 10,
+  preformatted = false,
+  showSummaryInline = false,
+  showTitle = true,
+  status,
+  summary,
+  theme: _theme,
+  title
+}) {
+  const normalizedSummary = summary?.trim();
+  const normalizedDetail = detail?.trim();
+  const responseText = showSummaryInline ? void 0 : normalizedSummary ?? emptyText?.trim();
+  const detailText = showSummaryInline ? normalizedDetail ?? emptyText?.trim() : normalizedDetail;
+  const responseLines = splitVisibleLines(responseText);
+  const detailLines = splitVisibleLines(detailText).filter((line) => !responseLines.includes(line));
+  const combinedLines = [
+    ...responseLines.map((text) => ({ kind: "response", text })),
+    ...detailLines.map((text) => ({ kind: "detail", text }))
+  ];
+  const { visibleLines, hiddenLineCount } = clampContentLines(combinedLines, maxContentLines);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom, marginLeft: indent, children: [
+    showTitle ? /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(`${statusMarker(status)} `) }),
+      /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(title) }),
+      showSummaryInline && normalizedSummary ? /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(` (${normalizedSummary})`) }) : null
+    ] }) : null,
+    visibleLines.map((line, index) => /* @__PURE__ */ jsx(
+      Box,
+      {
+        marginLeft: line.kind === "response" ? showTitle ? 2 : 0 : showTitle ? 4 : 2,
+        children: preformatted ? /* @__PURE__ */ jsx(Text, { children: line.text }) : /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(line.text) })
+      },
+      `${line.kind}:${index}:${stripAnsi5(line.text)}`
+    )),
+    hiddenLineCount > 0 ? /* @__PURE__ */ jsx(Box, { marginLeft: showTitle ? 4 : 2, children: /* @__PURE__ */ jsx(Text, { color: "white", children: plainToolText(`... ${hiddenLineCount} more line(s)`) }) }) : null
+  ] });
+}
+
+// src/react-ink/components/messages/ToolCallMessage.tsx
+function ToolCallMessage({ theme, toolCall }) {
+  const descriptor = describeToolCall(toolCall);
+  return /* @__PURE__ */ jsx(
+    ToolEventBlock,
+    {
+      detail: void 0,
+      emptyText: void 0,
+      indent: 2,
+      marginBottom: 0,
+      showSummaryInline: true,
+      status: "running",
+      summary: descriptor.summary,
+      theme,
+      title: descriptor.title
+    }
+  );
+}
+
+// src/react-ink/diff/Diff.tsx
+import chalk4 from "chalk";
+function lineMarker(kind) {
+  switch (kind) {
+    case "added":
+      return "+";
+    case "removed":
+      return "-";
+    default:
+      return " ";
+  }
+}
+function gutterWidth(diff) {
+  let max = 1;
+  for (const hunk of diff.hunks) {
+    for (const line of hunk.lines) {
+      const num = line.kind === "removed" ? line.oldLine : line.newLine;
+      if (num !== void 0) {
+        max = Math.max(max, stringWidth(String(num)));
+      }
+    }
+  }
+  return max;
+}
+function renderLineText(line, theme, bgRole, fgRole) {
+  const paintSpan = (text, changed) => {
+    const fg = theme.role(fgRole, text);
+    return changed ? chalk4.bold(fg) : fg;
+  };
+  let body;
+  if (line.spans && line.spans.length > 0) {
+    body = line.spans.map((span) => paintSpan(span.text, span.changed)).join("");
+  } else {
+    body = theme.role(fgRole, line.text);
+  }
+  return bgRole ? theme.roleBackground(bgRole, body) : body;
+}
+function Diff({ diff, theme, indent = 0, marginBottom = 0 }) {
+  const gutter = gutterWidth(diff);
+  const renderLine = (line, key) => {
+    const num = line.kind === "removed" ? line.oldLine : line.newLine;
+    const gutterText = (num !== void 0 ? String(num) : "").padStart(gutter);
+    const marker = lineMarker(line.kind);
+    const bgRole = line.kind === "added" ? "diffAddedBg" : line.kind === "removed" ? "diffRemovedBg" : null;
+    const fgRole = line.kind === "added" ? "diffAddedText" : line.kind === "removed" ? "diffRemovedText" : "blockquoteBar";
+    const gutterStyled = theme.dim(`${gutterText} `);
+    const markerStyled = line.kind === "context" ? theme.dim(`${marker} `) : theme.role(fgRole, `${marker} `);
+    const text = renderLineText(line, theme, bgRole, fgRole);
+    return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { children: [
+      gutterStyled,
+      markerStyled,
+      text
+    ] }) }, key);
+  };
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginLeft: indent, marginBottom, children: diff.hunks.map((hunk, hunkIndex) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    hunkIndex > 0 ? /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { children: theme.dim("...") }) }) : null,
+    hunk.lines.map((line, lineIndex) => renderLine(line, `${hunkIndex}-${lineIndex}`))
+  ] }, `hunk-${hunkIndex}`)) });
+}
+
+// src/react-ink/components/messages/ToolResultBlock.tsx
+function ToolResultBlock({ expanded = false, message, nested = false, showImages, theme, toolCall }) {
+  const descriptor = describeToolResult(message, showImages, toolCall?.arguments, theme);
+  const indent = nested ? 4 : 2;
+  if (descriptor.diff) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [
+      /* @__PURE__ */ jsx(
+        ToolEventBlock,
+        {
+          detail: void 0,
+          emptyText: descriptor.emptyText,
+          indent,
+          marginBottom: 0,
+          maxContentLines: 0,
+          showSummaryInline: false,
+          showTitle: !nested,
+          status: message.isError ? "error" : "success",
+          summary: descriptor.summary,
+          theme,
+          title: descriptor.title
+        }
+      ),
+      /* @__PURE__ */ jsx(Diff, { diff: descriptor.diff, theme, indent: indent + 2 })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(
+    ToolEventBlock,
+    {
+      detail: descriptor.body,
+      emptyText: descriptor.emptyText,
+      indent,
+      marginBottom: 0,
+      maxContentLines: expanded ? Number.MAX_SAFE_INTEGER : 10,
+      preformatted: descriptor.preformatted,
+      showSummaryInline: false,
+      showTitle: !nested,
+      status: message.isError ? "error" : "success",
+      summary: descriptor.summary,
+      theme,
+      title: descriptor.title
+    }
+  );
+}
+
+// src/react-ink/components/messages/AssistantMessage.tsx
+function AssistantMessageView({
+  expandToolOutputs = false,
+  message,
+  showImages,
+  showThinking,
+  theme,
+  toolResults = []
+}) {
+  const parts = splitAssistantMessage(message, showThinking);
+  const toolResultsByCallId = new Map(toolResults.map((toolResult) => [toolResult.toolCallId, toolResult]));
+  const matchedToolResultIds = /* @__PURE__ */ new Set();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("accent", `Assistant  ${message.provider}/${message.model}  ${formatMessageTimestamp(message.timestamp)}`) }),
+    parts.text ? /* @__PURE__ */ jsx(Markdown, { theme, children: parts.text }) : null,
+    parts.thinking.map((thinking, index) => /* @__PURE__ */ jsx(Text, { children: theme.muted(`[thinking] ${thinking}`) }, index)),
+    parts.toolCalls.map((toolCall) => {
+      const toolResult = toolResultsByCallId.get(toolCall.id);
+      if (toolResult) {
+        matchedToolResultIds.add(toolResult.toolCallId);
+      }
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx(ToolCallMessage, { toolCall, theme }),
+        toolResult ? /* @__PURE__ */ jsx(
+          ToolResultBlock,
+          {
+            expanded: expandToolOutputs,
+            message: toolResult,
+            nested: true,
+            showImages,
+            theme,
+            toolCall
+          }
+        ) : null
+      ] }, toolCall.id);
+    }),
+    toolResults.filter((toolResult) => !matchedToolResultIds.has(toolResult.toolCallId)).map((toolResult) => /* @__PURE__ */ jsx(
+      ToolResultBlock,
+      {
+        expanded: expandToolOutputs,
+        message: toolResult,
+        nested: true,
+        showImages,
+        theme
+      },
+      toolResult.toolCallId
+    )),
+    message.stopReason === "error" && message.errorMessage ? /* @__PURE__ */ jsx(Text, { children: theme.color("error", message.errorMessage) }) : null
+  ] });
+}
+
+// src/react-ink/components/messages/BashMessage.tsx
+function BashMessageView({ message, theme }) {
+  const status = message.cancelled ? "cancelled" : message.exitCode === void 0 ? "running" : `exit ${message.exitCode}`;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("bashBorder", `Bash  ${status}  ${message.command}`) }),
+    message.output ? /* @__PURE__ */ jsx(Text, { children: message.output }) : /* @__PURE__ */ jsx(Text, { children: theme.muted("(no output)") })
+  ] });
+}
+
+// src/react-ink/components/messages/BranchSummaryMessage.tsx
+function BranchSummaryMessageView({ message, theme }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("warning", "Branch Summary") }),
+    /* @__PURE__ */ jsx(Text, { children: message.summary })
+  ] });
+}
+
+// src/react-ink/components/messages/CompactionMessage.tsx
+function CompactionMessageView({ message, theme }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("success", `Compaction Summary  ${message.tokensBefore} tokens before`) }),
+    /* @__PURE__ */ jsx(Text, { children: message.summary })
+  ] });
+}
+
+// src/react-ink/components/messages/CustomMessage.tsx
+function CustomMessageView({ message, showImages, theme }) {
+  if (!message.display) return null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.background("customMessage", ` ${message.customType} `, "customMessageText") }),
+    /* @__PURE__ */ jsx(Text, { children: formatCustomContent(message.content, showImages) })
+  ] });
+}
+
+// src/react-ink/components/messages/SkillInvocationMessage.tsx
+function SkillInvocationMessage({ content, theme }) {
+  const parsed = parseSkillInvocation(content);
+  if (!parsed) return null;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("accent", `Skill  ${parsed.name}`) }),
+    /* @__PURE__ */ jsx(Text, { children: parsed.location }),
+    parsed.userMessage ? /* @__PURE__ */ jsx(Text, { children: parsed.userMessage }) : null
+  ] });
+}
+
+// src/react-ink/components/messages/UserMessage.tsx
+function UserMessageView({ message, showImages, theme }) {
+  const content = formatUserContent(message.content, showImages);
+  const lines = content.length > 0 ? content.split("\n") : [""];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.background("userMessage", `You  ${formatMessageTimestamp(message.timestamp)}`, "userMessageText") }),
+    lines.map((line, index) => /* @__PURE__ */ jsx(Text, { children: theme.background("userMessage", line.length > 0 ? line : " ", "userMessageText") }, `user-message:${message.timestamp}:${index}`))
+  ] });
+}
+
+// src/react-ink/components/MessageRow.tsx
+function MessageRow({
+  message,
+  expandToolOutputs = false,
+  showImages,
+  showThinking,
+  theme,
+  toolResults = []
+}) {
+  switch (message.role) {
+    case "user": {
+      const content = typeof message.content === "string" ? message.content : formatUserContent(message.content, showImages);
+      const skill = typeof content === "string" ? parseSkillInvocation(content) : null;
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        skill ? /* @__PURE__ */ jsx(SkillInvocationMessage, { content, theme }) : null,
+        /* @__PURE__ */ jsx(UserMessageView, { message, showImages, theme })
+      ] });
+    }
+    case "assistant":
+      return /* @__PURE__ */ jsx(
+        AssistantMessageView,
+        {
+          expandToolOutputs,
+          message,
+          showImages,
+          showThinking,
+          theme,
+          toolResults
+        }
+      );
+    case "toolResult":
+      return /* @__PURE__ */ jsx(ToolResultBlock, { expanded: expandToolOutputs, message, showImages, theme });
+    case "bashExecution":
+      return /* @__PURE__ */ jsx(BashMessageView, { message, theme });
+    case "branchSummary":
+      return /* @__PURE__ */ jsx(BranchSummaryMessageView, { message, theme });
+    case "compactionSummary":
+      return /* @__PURE__ */ jsx(CompactionMessageView, { message, theme });
+    case "custom":
+      return /* @__PURE__ */ jsx(CustomMessageView, { message, showImages, theme });
+    default:
+      return /* @__PURE__ */ jsx(Text, { children: String(message.role ?? "message") });
+  }
+}
+
+// src/react-ink/components/MessageList.tsx
+function hasToolCalls(message) {
+  return message.role === "assistant" && message.content.some((part) => part.type === "toolCall");
+}
+function groupMessages(messages) {
+  const entries = [];
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (hasToolCalls(message)) {
+      const toolResults = [];
+      let nextIndex = index + 1;
+      while (nextIndex < messages.length && messages[nextIndex]?.role === "toolResult") {
+        toolResults.push(messages[nextIndex]);
+        nextIndex += 1;
+      }
+      entries.push({ type: "message", message, toolResults });
+      index = nextIndex - 1;
+      continue;
+    }
+    if (message.role === "toolResult") {
+      entries.push({ type: "message", message, toolResults: [message] });
+      continue;
+    }
+    entries.push({ type: "message", message, toolResults: [] });
+  }
+  return entries;
+}
+function getEntryTimestamp(entry) {
+  return entry.type === "message" ? entry.message.timestamp : entry.block.timestamp;
+}
+function MessageList({
+  displayBlocks = [],
+  expandToolOutputs = false,
+  maxItems,
+  messages,
+  showImages,
+  showThinking,
+  theme
+}) {
+  const visible = [
+    ...groupMessages(messages),
+    ...displayBlocks.map((block) => ({ type: "displayBlock", block }))
+  ].sort((left, right) => getEntryTimestamp(left) - getEntryTimestamp(right)).slice(-maxItems);
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: visible.map((entry, index) => entry.type === "message" ? /* @__PURE__ */ jsx(
+    MessageRow,
+    {
+      message: entry.message,
+      expandToolOutputs,
+      showImages,
+      showThinking,
+      theme,
+      toolResults: entry.toolResults
+    },
+    `${entry.message.role}:${entry.message.timestamp}:${index}`
+  ) : /* @__PURE__ */ jsx(
+    DisplayBlockView,
+    {
+      block: entry.block,
+      theme
+    },
+    `${entry.block.kind}:${entry.block.timestamp}:${entry.block.id}`
+  )) });
+}
+
+// src/react-ink/components/StatusLine.tsx
+function StatusLine({ snapshot, status, theme }) {
+  let text = status?.text;
+  let tone = status?.kind ?? "info";
+  if (!text) {
+    if (snapshot.isCompacting) {
+      text = "Compacting conversation context...";
+      tone = "busy";
+    } else if (snapshot.isBashRunning) {
+      text = "Running bash command...";
+      tone = "busy";
+    } else if (snapshot.pendingToolCallCount > 0 || snapshot.pendingMessageCount > 0) {
+      text = "Agent working...";
+      tone = "busy";
+    } else if (snapshot.isStreaming) {
+      text = "Agent working...";
+      tone = "busy";
+    } else if (snapshot.error) {
+      text = snapshot.error;
+      tone = "error";
+    }
+  }
+  if (!text) return null;
+  const styled = tone === "error" ? theme.color("error", text) : tone === "warning" ? theme.color("warning", text) : tone === "success" ? theme.color("success", text) : theme.muted(text);
+  return /* @__PURE__ */ jsx(Text, { children: styled });
+}
+
+// src/react-ink/components/TaskPanel.tsx
+function TaskPanel({ expandToolOutputs = false, pendingMessages = [], snapshot, theme, toolExecutions }) {
+  const recent = Object.values(toolExecutions).sort((left, right) => {
+    if (left.status === "running" && right.status !== "running") return -1;
+    if (left.status !== "running" && right.status === "running") return 1;
+    return right.updatedAt - left.updatedAt;
+  }).slice(0, 6);
+  if (recent.length === 0 && pendingMessages.length === 0 && snapshot.pendingMessageCount === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { children: theme.color("accent", `Tool Activity${recent.length > 0 ? `  ${recent.length}` : ""}`) }),
+    recent.map((tool) => {
+      const descriptor = describeToolExecution(tool);
+      return /* @__PURE__ */ jsx(
+        ToolEventBlock,
+        {
+          detail: descriptor.body,
+          emptyText: descriptor.emptyText,
+          indent: 1,
+          marginBottom: 0,
+          maxContentLines: expandToolOutputs ? Number.MAX_SAFE_INTEGER : 10,
+          showSummaryInline: true,
+          status: tool.status,
+          summary: descriptor.summary,
+          theme,
+          title: descriptor.title
+        },
+        tool.toolCallId
+      );
+    }),
+    pendingMessages.length > 0 ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: recent.length > 0 ? 1 : 0, children: [
+      /* @__PURE__ */ jsx(Text, { children: theme.color("accent", `Queued Messages  ${pendingMessages.length}`) }),
+      pendingMessages.slice(0, 6).map((message) => /* @__PURE__ */ jsxs(Text, { children: [
+        theme.muted(`  ${message.mode === "steer" ? "Steering" : "Follow-up"}: `),
+        message.text.length > 90 ? `${message.text.slice(0, 87)}...` : message.text
+      ] }, message.id)),
+      /* @__PURE__ */ jsx(Text, { children: theme.muted("  Alt+Up restores queued messages to the prompt") })
+    ] }) : snapshot.pendingMessageCount > 0 ? /* @__PURE__ */ jsx(Text, { children: theme.muted(`${snapshot.pendingMessageCount} queued message(s) waiting for the next turn`) }) : null
+  ] });
+}
+
+// src/react-ink/components/dialogs/DialogFrame.tsx
+function DialogFrame({ children, footer, subtitle, title }) {
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", flexDirection: "column", marginTop: 1, paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsx(Text, { children: title }),
+    subtitle ? /* @__PURE__ */ jsx(Text, { children: subtitle }) : null,
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children }),
+    footer ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: footer }) : null
+  ] });
+}
+
+// src/react-ink/utils/selection-dialog.ts
+function matchesSearchQuery(value, query) {
+  if (!query.trim()) {
+    return true;
+  }
+  const haystack = value.toLowerCase();
+  return query.toLowerCase().split(/\s+/).filter(Boolean).every((term) => haystack.includes(term));
+}
+function wrapSelectionIndex(current, direction, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return (current + direction + length) % length;
+}
+
+// src/react-ink/components/dialogs/SelectableDialog.tsx
+function SelectableDialog({
+  title,
+  subtitle,
+  items,
+  isActive = true,
+  searchEnabled = true,
+  emptyText,
+  noSearchResultsText = "No options matched the current search.",
+  onClose,
+  onSelect,
+  onHighlight,
+  getSearchText,
+  renderItem
+}) {
+  const [query, setQuery] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const filteredItems = useMemo(() => {
+    if (!searchEnabled) {
+      return items;
+    }
+    return items.filter((item) => matchesSearchQuery(getSearchText ? getSearchText(item) : String(item), query));
+  }, [getSearchText, items, query, searchEnabled]);
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useEffect(() => {
+    if (selectedIndex >= filteredItems.length) {
+      setSelectedIndex(0);
+    }
+  }, [filteredItems.length, selectedIndex]);
+  const highlighted = filteredItems[selectedIndex];
+  useEffect(() => {
+    if (isActive && onHighlight && highlighted !== void 0) {
+      onHighlight(highlighted, selectedIndex);
+    }
+  }, [highlighted, isActive]);
+  const maxVisible = useMemo(() => Math.max(8, (process.stdout.rows ?? 24) - 16), []);
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(maxVisible / 2), Math.max(0, filteredItems.length - maxVisible))
+  );
+  const visibleItems = filteredItems.slice(windowStart, windowStart + maxVisible);
+  const showSearch = searchEnabled && items.length > 0;
+  useInput(
+    (input, key) => {
+      if (key.escape) {
+        onClose();
+        return;
+      }
+      if (key.upArrow) {
+        setSelectedIndex((current) => wrapSelectionIndex(current, -1, filteredItems.length));
+        return;
+      }
+      if (key.downArrow) {
+        setSelectedIndex((current) => wrapSelectionIndex(current, 1, filteredItems.length));
+        return;
+      }
+      if (searchEnabled && (key.backspace || key.delete)) {
+        setQuery((current) => current.slice(0, -1));
+        return;
+      }
+      if (searchEnabled && key.ctrl && input === "u") {
+        setQuery("");
+        return;
+      }
+      if (key.return) {
+        const item = filteredItems[selectedIndex];
+        if (item) {
+          void onSelect(item);
+        }
+        return;
+      }
+      if (searchEnabled && !key.ctrl && !key.meta && input) {
+        setQuery((current) => current + input);
+      }
+    },
+    { isActive }
+  );
+  return /* @__PURE__ */ jsxs(
+    DialogFrame,
+    {
+      title,
+      subtitle,
+      footer: /* @__PURE__ */ jsx(Text, { children: searchEnabled ? "Type to filter, Up/Down wraps, Enter selects, Ctrl+U clears, Esc closes" : "Up/Down wraps, Enter selects, Esc closes" }),
+      children: [
+        showSearch ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            "Search: ",
+            query || " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            filteredItems.length,
+            " match",
+            filteredItems.length === 1 ? "" : "es"
+          ] })
+        ] }) : null,
+        items.length === 0 ? /* @__PURE__ */ jsx(Box, { marginTop: showSearch ? 1 : 0, children: /* @__PURE__ */ jsx(Text, { children: emptyText }) }) : filteredItems.length === 0 ? /* @__PURE__ */ jsx(Box, { marginTop: showSearch ? 1 : 0, children: /* @__PURE__ */ jsx(Text, { children: noSearchResultsText }) }) : /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: showSearch ? 1 : 0, children: visibleItems.map((item, index) => {
+          const actualIndex = windowStart + index;
+          return /* @__PURE__ */ jsx(Box, { children: renderItem(item, actualIndex === selectedIndex, actualIndex) }, actualIndex);
+        }) })
+      ]
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/LoginDialog.tsx
+function LoginDialog(props) {
+  if (props.mode === "logout") {
+    return /* @__PURE__ */ jsx(
+      SelectableDialog,
+      {
+        title: "Saved Credentials",
+        items: props.accounts,
+        emptyText: "No saved credentials were found.",
+        onClose: props.onClose,
+        onSelect: props.onSelect,
+        getSearchText: (account) => account.label,
+        renderItem: (account, selected) => /* @__PURE__ */ jsxs(Text, { children: [
+          selected ? "> " : "  ",
+          account.label
+        ] })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    SelectableDialog,
+    {
+      title: "Login Providers",
+      items: props.providers,
+      emptyText: "No authenticated providers are configured.",
+      onClose: props.onClose,
+      onSelect: props.onSelect,
+      getSearchText: (provider) => `${provider.label} ${provider.authKind}`,
+      renderItem: (provider, selected) => /* @__PURE__ */ jsxs(Text, { children: [
+        selected ? "> " : "  ",
+        provider.label,
+        " (",
+        provider.authKind,
+        ")"
+      ] })
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/ModelDialog.tsx
+function matchesModel(model, search) {
+  return matchesSearchQuery(`${model.provider} ${model.id} ${model.name ?? ""}`, search);
+}
+function ModelDialog({ models, onClose, onSelect, search }) {
+  const [query, setQuery] = useState(search ?? "");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  useEffect(() => {
+    setQuery(search ?? "");
+  }, [search]);
+  const filtered = useMemo(
+    () => models.filter((model) => matchesModel(model, query)),
+    [models, query]
+  );
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useEffect(() => {
+    if (selectedIndex >= filtered.length) {
+      setSelectedIndex(0);
+    }
+  }, [filtered.length, selectedIndex]);
+  const maxVisible = Math.max(8, (process.stdout.rows ?? 24) - 16);
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(maxVisible / 2), Math.max(0, filtered.length - maxVisible))
+  );
+  const visibleModels = filtered.slice(windowStart, windowStart + maxVisible);
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, -1, filtered.length));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, 1, filtered.length));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((current) => current.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setQuery("");
+      return;
+    }
+    if (key.return) {
+      const selected = filtered[selectedIndex];
+      if (selected) {
+        void onSelect(selected);
+      }
+      return;
+    }
+    if (!key.ctrl && !key.meta && input) {
+      setQuery((current) => current + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(
+    DialogFrame,
+    {
+      title: "Models",
+      subtitle: "Type to search models by provider, id, or name",
+      footer: /* @__PURE__ */ jsx(Text, { children: "Type to filter, Up/Down to move, Enter to select, Ctrl+U clears, Esc closes" }),
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            "Search: ",
+            query || " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            filtered.length,
+            " match",
+            filtered.length === 1 ? "" : "es"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: filtered.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No models matched the current search." }) : visibleModels.map((model, index) => {
+          const actualIndex = windowStart + index;
+          return /* @__PURE__ */ jsxs(Text, { children: [
+            actualIndex === selectedIndex ? "> " : "  ",
+            model.provider,
+            "/",
+            model.id,
+            model.name ? `  (${model.name})` : ""
+          ] }, `${model.provider}/${model.id}`);
+        }) })
+      ]
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/OAuthDialog.tsx
+function OAuthDialog({ onChange, onClose, onSubmit, state }) {
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      void onSubmit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      onChange({ inputValue: state.inputValue.slice(0, -1) });
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      onChange({ inputValue: state.inputValue + input });
+    }
+  });
+  return /* @__PURE__ */ jsxs(
+    DialogFrame,
+    {
+      title: `${state.mode === "oauth" ? "OAuth Login" : "API Key Login"}: ${state.providerName}`,
+      footer: /* @__PURE__ */ jsx(Text, { children: "Type to edit, Enter to submit, Esc to cancel" }),
+      children: [
+        state.progress ? /* @__PURE__ */ jsx(Text, { children: state.progress }) : null,
+        state.authInfo ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx(Text, { children: state.authInfo.instructions ?? "Open this URL in your browser to continue:" }),
+          /* @__PURE__ */ jsx(Text, { children: state.authInfo.url })
+        ] }) : null,
+        state.prompt ? /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: state.prompt.message }) }) : null,
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx(Text, { children: state.inputLabel }),
+          /* @__PURE__ */ jsx(Text, { children: state.inputValue || " " })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/ScopedModelsDialog.tsx
+function modelKey(model) {
+  return `${model.provider}/${model.id}`;
+}
+function ScopedModelsDialog({ models, onClose, onSave, selectedIds }) {
+  const [query, setQuery] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [enabledIds, setEnabledIds] = useState(() => new Set(selectedIds));
+  useEffect(() => {
+    setSelectedIndex(0);
+    setQuery("");
+    setEnabledIds(new Set(selectedIds));
+  }, [selectedIds]);
+  const filteredModels = useMemo(
+    () => models.filter((model) => matchesSearchQuery(`${model.provider} ${model.id} ${model.name ?? ""}`, query)),
+    [models, query]
+  );
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useEffect(() => {
+    if (selectedIndex >= filteredModels.length) {
+      setSelectedIndex(0);
+    }
+  }, [filteredModels.length, selectedIndex]);
+  const maxVisible = useMemo(() => Math.max(8, (process.stdout.rows ?? 24) - 18), []);
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(maxVisible / 2), Math.max(0, filteredModels.length - maxVisible))
+  );
+  const visibleModels = filteredModels.slice(windowStart, windowStart + maxVisible);
+  const toggleSelectedModel = () => {
+    const model = filteredModels[selectedIndex];
+    if (!model) {
+      return;
+    }
+    const id = modelKey(model);
+    setEnabledIds((current) => {
+      const next = new Set(current);
+      if (next.has(id)) {
+        next.delete(id);
+      } else {
+        next.add(id);
+      }
+      return next;
+    });
+  };
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, -1, filteredModels.length));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, 1, filteredModels.length));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((current) => current.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setQuery("");
+      return;
+    }
+    if (key.ctrl && input === "a") {
+      setEnabledIds(new Set(models.map(modelKey)));
+      return;
+    }
+    if (key.ctrl && input === "k") {
+      setEnabledIds(/* @__PURE__ */ new Set());
+      return;
+    }
+    if (input === " ") {
+      toggleSelectedModel();
+      return;
+    }
+    if (key.return) {
+      void onSave([...enabledIds].sort());
+      return;
+    }
+    if (!key.ctrl && !key.meta && input && input !== " ") {
+      setQuery((current) => current + input);
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    DialogFrame,
+    {
+      title: "Scoped Models",
+      subtitle: "Choose which models Ctrl+P cycles through",
+      footer: /* @__PURE__ */ jsxs(Text, { children: [
+        "Type to filter, Up/Down wraps, Space toggles, Ctrl+A selects all, Ctrl+K clears,",
+        " ",
+        "Ctrl+U clears search, Enter saves, Esc closes"
+      ] }),
+      children: models.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No authenticated models are currently available." }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Search: ",
+          query || " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          filteredModels.length,
+          " match",
+          filteredModels.length === 1 ? "" : "es"
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Selected: ",
+          enabledIds.size === 0 ? "all available models" : `${enabledIds.size} model(s)`
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: filteredModels.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No models matched the current search." }) : visibleModels.map((model, index) => {
+          const actualIndex = windowStart + index;
+          const id = modelKey(model);
+          const checked = enabledIds.has(id);
+          return /* @__PURE__ */ jsxs(Text, { children: [
+            actualIndex === selectedIndex ? "> " : "  ",
+            "[",
+            checked ? "x" : " ",
+            "] ",
+            id
+          ] }, id);
+        }) })
+      ] })
+    }
+  );
+}
+
+// src/react-ink/utils/session-browser.ts
+function wrapSelectionIndex2(current, direction, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return (current + direction + length) % length;
+}
+function normalizeQueryText(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function fuzzyScore(needle, haystack) {
+  const query = needle.toLowerCase().trim();
+  const text = haystack.toLowerCase();
+  if (!query) {
+    return { matches: true, score: 0 };
+  }
+  let score = 0;
+  let searchIndex = 0;
+  let firstMatch = -1;
+  for (const char of query) {
+    const index = text.indexOf(char, searchIndex);
+    if (index < 0) {
+      return { matches: false, score: 0 };
+    }
+    if (firstMatch < 0) {
+      firstMatch = index;
+    }
+    score += index - searchIndex;
+    searchIndex = index + 1;
+  }
+  return { matches: true, score: score + Math.max(firstMatch, 0) * 0.1 };
+}
+function buildSearchText(session) {
+  return [
+    session.id,
+    session.name ?? "",
+    session.firstMessage ?? "",
+    session.allMessagesText ?? "",
+    session.cwd ?? "",
+    session.path,
+    new Date(session.lastModified).toLocaleString()
+  ].join(" ").trim();
+}
+function tokenizeQuotedQuery(query) {
+  const tokens = [];
+  let buffer = "";
+  let inQuote = false;
+  const pushBuffer = (kind) => {
+    const value = buffer.trim();
+    buffer = "";
+    if (value) {
+      tokens.push({ kind, value });
+    }
+  };
+  for (const char of query) {
+    if (char === '"') {
+      pushBuffer(inQuote ? "phrase" : "fuzzy");
+      inQuote = !inQuote;
+      continue;
+    }
+    if (!inQuote && /\s/.test(char)) {
+      pushBuffer("fuzzy");
+      continue;
+    }
+    buffer += char;
+  }
+  if (!inQuote) {
+    pushBuffer("fuzzy");
+  }
+  return { tokens, hadUnclosedQuote: inQuote };
+}
+function fallbackWhitespaceTokens(query) {
+  return query.split(/\s+/).map((token) => token.trim()).filter(Boolean).map((value) => ({ kind: "fuzzy", value }));
+}
+function createRegexQuery(query) {
+  const pattern = query.slice(3).trim();
+  if (!pattern) {
+    return { mode: "regex", tokens: [], regex: null, error: "Empty regex" };
+  }
+  try {
+    return { mode: "regex", tokens: [], regex: new RegExp(pattern, "i") };
+  } catch (error) {
+    return {
+      mode: "regex",
+      tokens: [],
+      regex: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function parseSessionSearchQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return { mode: "tokens", tokens: [], regex: null };
+  }
+  if (trimmed.startsWith("re:")) {
+    return createRegexQuery(trimmed);
+  }
+  const tokenized = tokenizeQuotedQuery(trimmed);
+  return {
+    mode: "tokens",
+    tokens: tokenized.hadUnclosedQuote ? fallbackWhitespaceTokens(trimmed) : tokenized.tokens,
+    regex: null
+  };
+}
+function scoreRegexMatch(text, regex) {
+  if (!regex) {
+    return { matches: false, score: 0 };
+  }
+  const index = text.search(regex);
+  return index < 0 ? { matches: false, score: 0 } : { matches: true, score: index * 0.1 };
+}
+function scoreTokenMatch(text, parsed) {
+  if (parsed.tokens.length === 0) {
+    return { matches: true, score: 0 };
+  }
+  let totalScore = 0;
+  let normalizedText;
+  for (const token of parsed.tokens) {
+    if (token.kind === "phrase") {
+      normalizedText ??= normalizeQueryText(text);
+      const phraseIndex = normalizedText.indexOf(normalizeQueryText(token.value));
+      if (phraseIndex < 0) {
+        return { matches: false, score: 0 };
+      }
+      totalScore += phraseIndex * 0.1;
+      continue;
+    }
+    const fuzzy = fuzzyScore(token.value, text);
+    if (!fuzzy.matches) {
+      return { matches: false, score: 0 };
+    }
+    totalScore += fuzzy.score;
+  }
+  return { matches: true, score: totalScore };
+}
+function filterAndSortSessions(sessions, query, sortMode) {
+  const parsed = parseSessionSearchQuery(query);
+  if (parsed.error) {
+    return { items: [], error: parsed.error };
+  }
+  if (!query.trim()) {
+    const items = [...sessions].sort((left, right) => right.lastModified - left.lastModified);
+    return { items };
+  }
+  const scored = sessions.map((session) => {
+    const text = buildSearchText(session);
+    const match = parsed.mode === "regex" ? scoreRegexMatch(text, parsed.regex) : scoreTokenMatch(text, parsed);
+    return { session, match };
+  }).filter((entry) => entry.match.matches);
+  scored.sort((left, right) => {
+    if (sortMode === "relevance" && left.match.score !== right.match.score) {
+      return left.match.score - right.match.score;
+    }
+    return right.session.lastModified - left.session.lastModified;
+  });
+  return { items: scored.map((entry) => entry.session) };
+}
+function formatSessionAge(lastModified) {
+  const ageMs = Date.now() - lastModified;
+  const seconds = ageMs / 1e3;
+  const minutes = seconds / 60;
+  const hours = minutes / 60;
+  const days = hours / 24;
+  if (days >= 1) return `${Math.floor(days)}d ago`;
+  if (hours >= 1) return `${Math.floor(hours)}h ago`;
+  if (minutes >= 1) return `${Math.floor(minutes)}m ago`;
+  return `${Math.max(0, Math.floor(seconds))}s ago`;
+}
+function formatSessionSize(bytes) {
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+function shrinkSessionId(id) {
+  return id.length > 16 ? `${id.slice(0, 8)}...${id.slice(-4)}` : id;
+}
+
+// src/react-ink/components/dialogs/SessionDialog.tsx
+var VISIBLE_SESSION_COUNT = 5;
+function buildMetadata(session, showPath) {
+  const parts = [
+    formatSessionAge(session.lastModified),
+    typeof session.messageCount === "number" ? `${session.messageCount} msg` : void 0,
+    typeof session.size === "number" ? formatSessionSize(session.size) : void 0,
+    session.cwd || void 0
+  ];
+  if (showPath) {
+    parts.push(session.path);
+  }
+  return parts.filter(Boolean).join("  |  ");
+}
+function SessionDialog({
+  currentSessionPath,
+  currentSessions,
+  onClose,
+  onDeleteSession,
+  onLoadAllSessions,
+  onRenameSession,
+  onSelect
+}) {
+  const [scope, setScope] = useState("current");
+  const [sortMode, setSortMode] = useState("relevance");
+  const [showPath, setShowPath] = useState(false);
+  const [query, setQuery] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [allSessions, setAllSessions] = useState(null);
+  const [loadingAll, setLoadingAll] = useState(false);
+  const [progress, setProgress] = useState(null);
+  const [loadError, setLoadError] = useState();
+  const [confirmDeletePath, setConfirmDeletePath] = useState(null);
+  const [renamePath, setRenamePath] = useState(null);
+  const [renameValue, setRenameValue] = useState("");
+  useEffect(() => {
+    if (scope !== "all" || allSessions || loadingAll) {
+      return;
+    }
+    let cancelled = false;
+    setLoadingAll(true);
+    setLoadError(void 0);
+    setProgress(null);
+    void onLoadAllSessions((next) => {
+      if (!cancelled) {
+        setProgress(next);
+      }
+    }).then((sessions) => {
+      if (!cancelled) {
+        setAllSessions(sessions);
+      }
+    }).catch((error) => {
+      if (!cancelled) {
+        setLoadError(error instanceof Error ? error.message : String(error));
+      }
+    }).finally(() => {
+      if (!cancelled) {
+        setLoadingAll(false);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [allSessions, loadingAll, onLoadAllSessions, scope]);
+  const sourceSessions = scope === "all" ? allSessions ?? [] : currentSessions;
+  const filtered = useMemo(() => filterAndSortSessions(sourceSessions, query, sortMode), [query, sortMode, sourceSessions]);
+  useEffect(() => {
+    setSelectedIndex(0);
+    setConfirmDeletePath(null);
+  }, [query, scope, sortMode]);
+  useEffect(() => {
+    if (selectedIndex >= filtered.items.length) {
+      setSelectedIndex(0);
+    }
+  }, [filtered.items.length, selectedIndex]);
+  const selectedSession = filtered.items[selectedIndex];
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(VISIBLE_SESSION_COUNT / 2), Math.max(0, filtered.items.length - VISIBLE_SESSION_COUNT))
+  );
+  const visibleSessions = filtered.items.slice(windowStart, windowStart + VISIBLE_SESSION_COUNT);
+  const statusLine = scope === "all" && loadingAll ? progress ? `Loading all sessions ${progress.loaded}/${progress.total}` : "Loading all sessions..." : loadError ? loadError : filtered.error ? `Search error: ${filtered.error}` : filtered.items.length === 0 ? "0 matches" : `Showing ${windowStart + 1}-${windowStart + visibleSessions.length} of ${filtered.items.length} matches`;
+  const beginRename = () => {
+    if (!selectedSession || !onRenameSession) {
+      return;
+    }
+    setRenamePath(selectedSession.path);
+    setRenameValue(selectedSession.name ?? "");
+  };
+  const confirmRename = async () => {
+    if (!selectedSession || !onRenameSession || renamePath !== selectedSession.path) {
+      setRenamePath(null);
+      return;
+    }
+    await onRenameSession(selectedSession, renameValue.trim());
+    setRenamePath(null);
+  };
+  useInput((input, key) => {
+    if (renamePath) {
+      if (key.escape || key.ctrl && input === "c") {
+        setRenamePath(null);
+        return;
+      }
+      if (key.return) {
+        void confirmRename();
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setRenameValue((current) => current.slice(0, -1));
+        return;
+      }
+      if (!key.ctrl && !key.meta && input) {
+        setRenameValue((current) => current + input);
+      }
+      return;
+    }
+    if (confirmDeletePath) {
+      if (key.escape || key.ctrl && input === "c") {
+        setConfirmDeletePath(null);
+        return;
+      }
+      if (key.return && selectedSession && onDeleteSession && confirmDeletePath === selectedSession.path) {
+        void onDeleteSession(selectedSession);
+        setConfirmDeletePath(null);
+      }
+      return;
+    }
+    if (key.escape || key.ctrl && input === "c") {
+      onClose();
+      return;
+    }
+    if (key.tab) {
+      setScope((current) => current === "current" ? "all" : "current");
+      return;
+    }
+    if (key.ctrl && input === "s") {
+      setSortMode((current) => current === "recent" ? "relevance" : "recent");
+      return;
+    }
+    if (key.ctrl && input === "p") {
+      setShowPath((current) => !current);
+      return;
+    }
+    if (key.ctrl && input === "r") {
+      beginRename();
+      return;
+    }
+    if (key.ctrl && input === "d") {
+      if (selectedSession && selectedSession.path !== currentSessionPath && onDeleteSession) {
+        setConfirmDeletePath(selectedSession.path);
+      }
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex2(current, -1, filtered.items.length));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex2(current, 1, filtered.items.length));
+      return;
+    }
+    if (key.pageUp) {
+      setSelectedIndex((current) => Math.max(0, current - VISIBLE_SESSION_COUNT));
+      return;
+    }
+    if (key.pageDown) {
+      setSelectedIndex((current) => Math.min(filtered.items.length - 1, current + VISIBLE_SESSION_COUNT));
+      return;
+    }
+    if (key.return) {
+      if (selectedSession) {
+        void onSelect(selectedSession);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((current) => current.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setQuery("");
+      return;
+    }
+    if (!key.ctrl && !key.meta && input) {
+      setQuery((current) => current + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(
+    DialogFrame,
+    {
+      title: scope === "current" ? "Resume Session (Current Folder)" : "Resume Session (All)",
+      subtitle: statusLine,
+      footer: /* @__PURE__ */ jsx(Text, { children: 'Tab scope, Ctrl+S sort, Ctrl+P path, Ctrl+R rename, Ctrl+D delete, re:pattern regex, "phrase" exact' }),
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            "Search: ",
+            renamePath ? "(rename active)" : query || " "
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "Scope: ",
+            scope,
+            "  |  Sort: ",
+            sortMode,
+            "  |  Path: ",
+            showPath ? "on" : "off"
+          ] })
+        ] }),
+        renamePath ? /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          /* @__PURE__ */ jsx(Text, { children: "Rename session" }),
+          /* @__PURE__ */ jsx(Text, { children: renameValue || " " }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Enter saves, Esc cancels" })
+        ] }) : confirmDeletePath ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: "Delete this session? Enter confirms, Esc cancels." }) }) : filtered.items.length === 0 ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: scope === "current" ? "No sessions matched in the current folder." : "No sessions matched." }) }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          windowStart > 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  ..." }) : null,
+          visibleSessions.map((session, index) => {
+            const actualIndex = windowStart + index;
+            const selected = actualIndex === selectedIndex;
+            const locked = session.path === currentSessionPath;
+            return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs(Text, { color: selected ? "cyan" : "white", children: [
+                selected ? "> " : "  ",
+                session.name ? `${session.name}  ` : "",
+                shrinkSessionId(session.id),
+                locked ? "  (current)" : ""
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                selected ? "  " : "    ",
+                buildMetadata(session, showPath)
+              ] })
+            ] }, session.path);
+          }),
+          windowStart + visibleSessions.length < filtered.items.length ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  ..." }) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/SettingsDialog.tsx
+function getNextValue(values, currentValue, direction) {
+  if (values.length === 0) {
+    return void 0;
+  }
+  const currentIndex = Math.max(0, values.indexOf(currentValue));
+  const nextIndex = (currentIndex + direction + values.length) % values.length;
+  return values[nextIndex];
+}
+function SettingsDialog({ items, onClose }) {
+  const [query, setQuery] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const filteredItems = useMemo(
+    () => items.filter(
+      (item) => matchesSearchQuery(`${item.label} ${item.description} ${item.value} ${item.values.join(" ")}`, query)
+    ),
+    [items, query]
+  );
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useEffect(() => {
+    if (selectedIndex >= filteredItems.length) {
+      setSelectedIndex(0);
+    }
+  }, [filteredItems.length, selectedIndex]);
+  const maxVisible = useMemo(() => Math.max(8, (process.stdout.rows ?? 24) - 18), []);
+  const selectedItem = filteredItems[selectedIndex];
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(maxVisible / 2), Math.max(0, filteredItems.length - maxVisible))
+  );
+  const visibleItems = filteredItems.slice(windowStart, windowStart + maxVisible);
+  const cycleValue = (direction) => {
+    const item = filteredItems[selectedIndex];
+    if (!item) {
+      return;
+    }
+    const nextValue = getNextValue(item.values, item.value, direction);
+    if (!nextValue || nextValue === item.value) {
+      return;
+    }
+    void item.onChange(nextValue);
+  };
+  useInput((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, -1, filteredItems.length));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex(current, 1, filteredItems.length));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((current) => current.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setQuery("");
+      return;
+    }
+    if (key.leftArrow) {
+      cycleValue(-1);
+      return;
+    }
+    if (key.rightArrow || key.return) {
+      cycleValue(1);
+      return;
+    }
+    if (!key.ctrl && !key.meta && input) {
+      setQuery((current) => current + input);
+    }
+  });
+  return /* @__PURE__ */ jsx(
+    DialogFrame,
+    {
+      title: "Settings",
+      footer: /* @__PURE__ */ jsx(Text, { children: "Type to filter, Up/Down wraps, Left/Right or Enter changes, Ctrl+U clears, Esc closes" }),
+      children: items.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No settings are available." }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          "Search: ",
+          query || " "
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          filteredItems.length,
+          " match",
+          filteredItems.length === 1 ? "" : "es"
+        ] }),
+        /* @__PURE__ */ jsx(Box, { marginTop: 1, flexDirection: "column", children: filteredItems.length === 0 ? /* @__PURE__ */ jsx(Text, { children: "No settings matched the current search." }) : visibleItems.map((item, index) => {
+          const actualIndex = windowStart + index;
+          return /* @__PURE__ */ jsxs(Text, { children: [
+            actualIndex === selectedIndex ? "> " : "  ",
+            item.label,
+            ": ",
+            item.value
+          ] }, item.id);
+        }) }),
+        selectedItem ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx(Text, { children: selectedItem.description }),
+          /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "Choices: ",
+            selectedItem.values.join(" \xB7 ")
+          ] })
+        ] }) : null
+      ] })
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/StartupSessionPicker.tsx
+var VISIBLE_SESSION_COUNT2 = 5;
+function metadata(session, showPath) {
+  const parts = [
+    formatSessionAge(session.lastModified),
+    typeof session.messageCount === "number" ? `${session.messageCount} msg` : void 0,
+    typeof session.size === "number" ? formatSessionSize(session.size) : void 0,
+    session.cwd || void 0
+  ];
+  if (showPath) {
+    parts.push(session.path);
+  }
+  return parts.filter(Boolean).join("  |  ");
+}
+function StartupSessionPicker({ onClose, onSelect, sessions, totalCount }) {
+  const [query, setQuery] = useState("");
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [sortMode, setSortMode] = useState("relevance");
+  const [showPath, setShowPath] = useState(false);
+  const filtered = useMemo(() => filterAndSortSessions(sessions, query, sortMode), [query, sessions, sortMode]);
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query, sortMode]);
+  useEffect(() => {
+    if (selectedIndex >= filtered.items.length) {
+      setSelectedIndex(0);
+    }
+  }, [filtered.items.length, selectedIndex]);
+  const windowStart = Math.max(
+    0,
+    Math.min(selectedIndex - Math.floor(VISIBLE_SESSION_COUNT2 / 2), Math.max(0, filtered.items.length - VISIBLE_SESSION_COUNT2))
+  );
+  const visibleSessions = filtered.items.slice(windowStart, windowStart + VISIBLE_SESSION_COUNT2);
+  const visibleRangeStart = filtered.items.length === 0 ? 0 : windowStart + 1;
+  const visibleRangeEnd = filtered.items.length === 0 ? 0 : windowStart + visibleSessions.length;
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      onClose();
+      return;
+    }
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.ctrl && input === "s") {
+      setSortMode((current) => current === "recent" ? "relevance" : "recent");
+      return;
+    }
+    if (key.ctrl && input === "p") {
+      setShowPath((current) => !current);
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex2(current, -1, filtered.items.length));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((current) => wrapSelectionIndex2(current, 1, filtered.items.length));
+      return;
+    }
+    if (key.pageUp) {
+      setSelectedIndex((current) => Math.max(0, current - VISIBLE_SESSION_COUNT2));
+      return;
+    }
+    if (key.pageDown) {
+      setSelectedIndex((current) => Math.min(filtered.items.length - 1, current + VISIBLE_SESSION_COUNT2));
+      return;
+    }
+    if (key.return) {
+      const session = filtered.items[selectedIndex];
+      if (session) {
+        void onSelect(session);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((current) => current.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      setQuery("");
+      return;
+    }
+    if (!key.ctrl && !key.meta && input) {
+      setQuery((current) => current + input);
+    }
+  });
+  const subtitle = totalCount > 0 ? `${totalCount} session${totalCount === 1 ? "" : "s"} available` : void 0;
+  return /* @__PURE__ */ jsxs(
+    DialogFrame,
+    {
+      title: "Resume Session",
+      subtitle,
+      footer: /* @__PURE__ */ jsx(Text, { children: "Type to filter, Ctrl+S sort, Ctrl+P path, Up/Down wraps, Enter selects, Ctrl+U clears, Esc closes" }),
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            "Search: ",
+            query || " "
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: filtered.error ? `Search error: ${filtered.error}` : filtered.items.length === 0 ? "0 matches" : `Showing ${visibleRangeStart}-${visibleRangeEnd} of ${filtered.items.length} matches  |  sort:${sortMode}  path:${showPath ? "on" : "off"}` })
+        ] }),
+        filtered.items.length === 0 ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { children: sessions.length === 0 ? "No saved sessions were found." : "No sessions matched the current search." }) }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+          windowStart > 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  ..." }) : null,
+          visibleSessions.map((session, index) => {
+            const actualIndex = windowStart + index;
+            const selected = actualIndex === selectedIndex;
+            return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsxs(Text, { color: selected ? "cyan" : "white", children: [
+                selected ? "> " : "  ",
+                session.name ? `${session.name}  ` : "",
+                shrinkSessionId(session.id)
+              ] }),
+              /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                selected ? "  " : "    ",
+                metadata(session, showPath)
+              ] })
+            ] }, session.path);
+          }),
+          windowStart + visibleSessions.length < filtered.items.length ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  ..." }) : null
+        ] })
+      ]
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/ThemeDialog.tsx
+function toItem(entry) {
+  return typeof entry === "string" ? { id: entry, label: entry } : entry;
+}
+function ThemeDialog({ themes, onClose, onSelect, onHighlight }) {
+  const items = themes.map(toItem);
+  return /* @__PURE__ */ jsx(
+    SelectableDialog,
+    {
+      title: "Themes",
+      items,
+      emptyText: "No themes are available.",
+      onClose,
+      onSelect: (item) => onSelect(item.id),
+      onHighlight: onHighlight ? (item) => onHighlight(item.id) : void 0,
+      getSearchText: (item) => `${item.label} ${item.description ?? ""}`,
+      renderItem: (item, selected) => /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          selected ? "> " : "  ",
+          item.label
+        ] }),
+        item.description ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+          " ",
+          item.description
+        ] }) : null
+      ] })
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/TreeDialog.tsx
+function TreeDialog({ items, onClose, onSelect }) {
+  return /* @__PURE__ */ jsx(
+    SelectableDialog,
+    {
+      title: "Session Tree",
+      items,
+      emptyText: "This session does not have any navigable entries yet.",
+      onClose,
+      onSelect,
+      getSearchText: (item) => item.label,
+      renderItem: (item, selected) => /* @__PURE__ */ jsxs(Text, { children: [
+        selected ? "> " : "  ",
+        item.isCurrent ? "* " : "",
+        item.label
+      ] })
+    }
+  );
+}
+
+// src/react-ink/components/dialogs/UserMessageDialog.tsx
+function UserMessageDialog({ items, onClose, onSelect }) {
+  return /* @__PURE__ */ jsx(
+    SelectableDialog,
+    {
+      title: "Fork From Message",
+      items,
+      emptyText: "No user messages are available for forking.",
+      onClose,
+      onSelect,
+      getSearchText: (item) => item.preview,
+      renderItem: (item, selected) => /* @__PURE__ */ jsxs(Text, { children: [
+        selected ? "> " : "  ",
+        item.preview
+      ] })
+    }
+  );
+}
+
+// src/react-ink/markdown/StreamingMarkdown.tsx
+function lastStableBoundary(content) {
+  let boundary = 0;
+  let inFence = false;
+  let lineStart = 0;
+  let sawBlankRun = false;
+  for (let i = 0; i <= content.length; i++) {
+    const atEnd = i === content.length;
+    const ch = atEnd ? "\n" : content[i];
+    if (ch !== "\n" && !atEnd) {
+      continue;
+    }
+    const line = content.slice(lineStart, i);
+    if (line.trimStart().startsWith("```")) {
+      inFence = !inFence;
+      sawBlankRun = false;
+    } else if (line.trim() === "") {
+      if (!inFence) {
+        sawBlankRun = true;
+      }
+    } else {
+      if (sawBlankRun && !inFence) {
+        boundary = lineStart;
+      }
+      sawBlankRun = false;
+    }
+    lineStart = i + 1;
+    if (atEnd) {
+      break;
+    }
+  }
+  return boundary;
+}
+function StreamingMarkdown({
+  children,
+  theme,
+  highlightCode = true,
+  dim = false
+}) {
+  const boundary = useMemo(() => lastStableBoundary(children), [children]);
+  const stablePrefix = useMemo(
+    () => children.slice(0, boundary).replace(/\n+$/, ""),
+    [children, boundary]
+  );
+  const unstableSuffix = useMemo(() => children.slice(boundary), [children, boundary]);
+  const stableNode = useMemo(
+    () => stablePrefix ? /* @__PURE__ */ jsx(Markdown, { theme, highlightCode, dim, children: stablePrefix }) : null,
+    [stablePrefix, theme, highlightCode, dim]
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    stableNode,
+    unstableSuffix ? /* @__PURE__ */ jsx(Markdown, { theme, highlightCode, dim, children: unstableSuffix }) : null
+  ] });
+}
+export {
+  AssistantMessageView,
+  BashMessageView,
+  BranchSummaryMessageView,
+  CHANGE_THRESHOLD,
+  CONTEXT_LINES,
+  ChangelogBlock,
+  CompactionMessageView,
+  CustomMessageView,
+  DialogFrame,
+  Diff,
+  DisplayBlockView,
+  Footer,
+  LoginDialog,
+  Markdown,
+  MarkdownTable,
+  MessageList,
+  MessageRow,
+  ModelDialog,
+  OAuthDialog,
+  ScopedModelsDialog,
+  SelectableDialog,
+  SessionDialog,
+  SettingsDialog,
+  SkillInvocationMessage,
+  StartupSessionPicker,
+  StatusLine,
+  StreamingMarkdown,
+  TaskPanel,
+  ThemeDialog,
+  ToolCallMessage,
+  ToolEventBlock,
+  ToolResultBlock,
+  TreeDialog,
+  UserMessageDialog,
+  UserMessageView,
+  buildStructuredDiff,
+  cachedLexer,
+  configureMarked,
+  createHighlighter,
+  createThemeAdapter,
+  describeToolCall,
+  describeToolExecution,
+  describeToolResult,
+  describeToolSource,
+  extractMessagePreview,
+  extractToolText,
+  formatCustomContent,
+  formatMessageTimestamp,
+  formatToken,
+  formatToolCall,
+  formatToolResult,
+  formatUserContent,
+  getListNumber,
+  hasMarkdownSyntax,
+  highlightByPath,
+  languageFromPath,
+  matchesSearchQuery,
+  padAligned,
+  parseSkillInvocation,
+  previewMultiline,
+  previewText,
+  safeStringify,
+  splitAssistantMessage,
+  stringWidth,
+  wordDiffLine,
+  wrapSelectionIndex
+};