@tabbio-technologies/cli 1.2.8

package/dist/chunks/entry-WENOOT6W.js

@@ -0,0 +1,3492 @@
+import { createRequire as __tabbioCreateRequire } from 'node:module';
+const require = __tabbioCreateRequire(import.meta.url);
+import {
+  Page,
+  Spinner,
+  Working,
+  clipLines,
+  displayWidth,
+  estimateHeight,
+  formatElapsed,
+  fromTerminal,
+  oneLine,
+  padEnd,
+  padStart,
+  pageMargin,
+  safeJson,
+  sentenceCase,
+  shortId,
+  stripAnsi,
+  summarizeArgs,
+  truncate,
+  truncateStart,
+  useClockTick,
+  useTerminalSize,
+  wrapWords
+} from "./chunk-NAWA6NCZ.js";
+import {
+  CAPABILITY_CHOICES,
+  CAPABILITY_CHOICE_HELP,
+  DEFAULT_CAPABILITIES,
+  autoFilledProperties,
+  capabilityRequestFields,
+  chatReducer,
+  confirmApproval,
+  describeSchema,
+  draftSummary,
+  exampleInvocation,
+  findListWrapper,
+  getArtifact,
+  getPath,
+  getThreadMessages,
+  humanCell,
+  hyperlink,
+  initialChatState,
+  isDestructiveTool,
+  listModels,
+  listThreads,
+  loadCapabilityPrefs,
+  messageText,
+  parseCapabilityMode,
+  parseToolInput,
+  pickColumns,
+  previewUrl,
+  previewVariantFor,
+  rejectApproval,
+  renderScreen,
+  saveCapabilityPrefs,
+  schemaToFlags,
+  streamChat,
+  supportsHyperlinks,
+  unavailableNotices,
+  waitForArtifact
+} from "./chunk-QVR5KIEQ.js";
+import {
+  CLI_VERSION,
+  getMcpAccessState,
+  interruptedError,
+  isCliError,
+  readCachedCatalog,
+  relativeTime,
+  toCliError
+} from "./chunk-7LNC3FIV.js";
+import "./chunk-NK5RPNSV.js";
+import {
+  theme
+} from "./chunk-VHHZFMIF.js";
+
+// src/ui/entry.tsx
+import { Box as Box25, Static as Static2, Text as Text25 } from "ink";
+import { useEffect as useEffect9 } from "react";
+
+// src/ui/components/ApprovalCard.tsx
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { useEffect, useState } from "react";
+
+// src/ui/components/KeyHints.tsx
+import { Text } from "ink";
+import { memo } from "react";
+import { jsx } from "react/jsx-runtime";
+function formatHints(hints) {
+  const sep = theme.dim(` ${theme.symbols.middot} `);
+  return hints.map((h) => `${theme.accent(h.key)} ${theme.dim(h.label)}`).join(sep);
+}
+function fitHints(hints, width) {
+  const out = [...hints];
+  while (out.length > 1 && displayWidth(formatHints(out)) > width) out.pop();
+  return out;
+}
+var KeyHints = memo(function KeyHints2({ hints, width }) {
+  return /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", children: formatHints(fitHints(hints, width)) });
+});
+
+// src/ui/components/KeyValue.tsx
+import { Box, Text as Text2 } from "ink";
+import { memo as memo2 } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var KeyValue = memo2(function KeyValue2({ rows, width, wrap = false, maxLabelWidth = 24 }) {
+  const labelWidth = Math.min(maxLabelWidth, Math.max(0, ...rows.map((r) => displayWidth(r.label))));
+  const valueWidth = Math.max(8, width - labelWidth - 2);
+  return /* @__PURE__ */ jsx2(Box, { flexDirection: "column", width, children: rows.map((row, i) => {
+    const note = row.note ? `  ${row.note}` : "";
+    const value = wrap ? row.value : truncate(row.value.replace(/\n/g, " "), Math.max(4, valueWidth - displayWidth(note)));
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsxs(Text2, { children: [
+        theme.dim(padEnd(truncate(row.label, labelWidth), labelWidth)),
+        "  "
+      ] }),
+      /* @__PURE__ */ jsx2(Box, { width: valueWidth, children: /* @__PURE__ */ jsxs(Text2, { wrap: wrap ? "wrap" : "truncate-end", children: [
+        value,
+        note ? theme.dim(note) : ""
+      ] }) })
+    ] }, `${row.label}-${i}`);
+  }) });
+});
+
+// src/ui/components/Rail.tsx
+import { Box as Box2 } from "ink";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function railColor(tone) {
+  switch (tone) {
+    case "accent":
+      return theme.accentInk;
+    case "attention":
+      return "yellow";
+    case "danger":
+      return "red";
+    case "success":
+      return "green";
+    default:
+      return void 0;
+  }
+}
+function Rail({ tone = "accent", children, width }) {
+  return /* @__PURE__ */ jsx3(
+    Box2,
+    {
+      flexDirection: "column",
+      borderStyle: theme.railStyle,
+      borderTop: false,
+      borderRight: false,
+      borderBottom: false,
+      borderLeftColor: railColor(tone),
+      borderLeftDimColor: tone === "muted",
+      paddingLeft: 1,
+      width,
+      children
+    }
+  );
+}
+
+// src/ui/components/approval-model.ts
+var APPROVAL_OPTIONS = [
+  { decision: "approve", label: "Approve", hotkey: "y" },
+  { decision: "reject", label: "Reject", hotkey: "n" },
+  { decision: "leave", label: "Leave pending (decide later in the app)", hotkey: "l" }
+];
+var initialApprovalState = { selected: 0, expanded: false };
+function approvalKeyReducer(state, input, key) {
+  if (state.decision) return state;
+  const count = APPROVAL_OPTIONS.length;
+  if (key.escape) return { ...state, decision: "leave" };
+  if (key.ctrl && input === "o") return { ...state, expanded: !state.expanded };
+  if (key.upArrow || !key.ctrl && input === "k") return { ...state, selected: (state.selected - 1 + count) % count };
+  if (key.downArrow || !key.ctrl && input === "j") return { ...state, selected: (state.selected + 1) % count };
+  if (key.return) return { ...state, decision: APPROVAL_OPTIONS[state.selected].decision };
+  const byNumber = /^[1-9]$/.test(input) ? APPROVAL_OPTIONS[Number(input) - 1] : void 0;
+  const byHotkey = APPROVAL_OPTIONS.find((o) => o.hotkey === input.toLowerCase());
+  const chosen = byNumber ?? (key.ctrl || key.meta ? void 0 : byHotkey);
+  return chosen ? { ...state, selected: APPROVAL_OPTIONS.indexOf(chosen), decision: chosen.decision } : state;
+}
+function approvalOutcomeText(decision, title, approvalId, durationMs) {
+  const time = durationMs !== void 0 ? theme.dim(` ${theme.symbols.middot} ${formatElapsed(durationMs)}`) : "";
+  if (decision === "approve") return `${theme.success(theme.symbols.success)} Approved ${title}${time}`;
+  if (decision === "reject") return `${theme.error(theme.symbols.error)} Rejected ${title}${time}`;
+  return `${theme.attention(theme.symbols.attention)} Left pending ${title} ${theme.dim(shortId(approvalId))}`;
+}
+
+// src/ui/components/ApprovalCard.tsx
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX_ARGS = 8;
+function argRows(args, expanded) {
+  const rows = Object.entries(args).filter(([key]) => key !== "userId").map(([key, value]) => ({
+    label: key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(),
+    value: typeof value === "string" ? oneLine(value) : safeJson(value, 0)
+  }));
+  if (expanded || rows.length <= MAX_ARGS) return rows;
+  return [...rows.slice(0, MAX_ARGS), { label: "", value: theme.dim(`+${rows.length - MAX_ARGS} more (ctrl+o)`) }];
+}
+function ApprovalCard(props) {
+  const { approvalId, title, message, args, destructive = false, context, busy, error, isActive, width, onDecision } = props;
+  const [state, setState] = useState(initialApprovalState);
+  useInput(
+    (input, key) => {
+      setState((current) => approvalKeyReducer(current, input, key));
+    },
+    { isActive: isActive && !busy }
+  );
+  useEffect(() => {
+    if (state.decision) {
+      onDecision(state.decision);
+      setState((current) => ({ ...current, decision: void 0 }));
+    }
+  }, [state.decision, onDecision]);
+  const inner = Math.max(20, width - 2);
+  const optionWidth = Math.max(10, Math.min(inner - 4, 52));
+  return /* @__PURE__ */ jsxs2(Rail, { tone: destructive ? "danger" : "attention", width, children: [
+    /* @__PURE__ */ jsxs2(Box3, { width: inner, children: [
+      /* @__PURE__ */ jsx4(Box3, { flexGrow: 1, children: /* @__PURE__ */ jsxs2(Text3, { children: [
+        (destructive ? theme.danger : theme.attention)(theme.symbols.attention),
+        " ",
+        theme.bold("Approval needed")
+      ] }) }),
+      /* @__PURE__ */ jsx4(Text3, { children: theme.dim(shortId(approvalId)) })
+    ] }),
+    /* @__PURE__ */ jsx4(Text3, { children: " " }),
+    /* @__PURE__ */ jsx4(Text3, { wrap: "wrap", children: message ? oneLine(message) : `${theme.bold(title)} wants to run with these inputs` }),
+    /* @__PURE__ */ jsx4(Text3, { children: " " }),
+    /* @__PURE__ */ jsx4(Box3, { marginLeft: 2, children: /* @__PURE__ */ jsx4(KeyValue, { rows: argRows(args, state.expanded), width: Math.max(16, inner - 2), wrap: state.expanded }) }),
+    /* @__PURE__ */ jsx4(Text3, { children: " " }),
+    /* @__PURE__ */ jsx4(Text3, { wrap: "truncate-end", children: destructive ? theme.danger("This cannot be undone") : theme.dim(context ?? "Writes to your account") }),
+    /* @__PURE__ */ jsx4(Text3, { children: " " }),
+    APPROVAL_OPTIONS.map((option, i) => {
+      const selected = i === state.selected;
+      const pointer = selected ? theme.accent(theme.symbols.pointer) : " ";
+      const label = `${i + 1}. ${option.label}`;
+      return /* @__PURE__ */ jsxs2(Text3, { wrap: "truncate-end", children: [
+        pointer,
+        " ",
+        selected ? theme.accent(padEnd(label, optionWidth)) : padEnd(label, optionWidth),
+        " ",
+        theme.dim(option.hotkey)
+      ] }, option.decision);
+    }),
+    /* @__PURE__ */ jsx4(Text3, { children: " " }),
+    busy ? /* @__PURE__ */ jsx4(Spinner, { label: theme.dim(busy === "approve" ? "Approving\u2026" : busy === "reject" ? "Rejecting\u2026" : "Leaving it pending\u2026") }) : error ? /* @__PURE__ */ jsx4(Text3, { wrap: "wrap", children: theme.error(`${theme.symbols.error} ${error}`) }) : /* @__PURE__ */ jsx4(
+      KeyHints,
+      {
+        width: inner,
+        hints: [
+          { key: theme.symbols.upDown, label: "select" },
+          { key: "enter", label: "confirm" },
+          { key: "esc", label: "leave pending" },
+          { key: "ctrl+o", label: "all inputs" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/components/Form.tsx
+import { Box as Box4, Text as Text4, useInput as useInput2 } from "ink";
+import { memo as memo3, useEffect as useEffect2, useReducer } from "react";
+
+// src/ui/fuzzy.ts
+function rankMatch(query, primary, secondary = "") {
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  const p = primary.toLowerCase();
+  if (p === q) return 0;
+  if (p.startsWith(q)) return 1;
+  if (p.split(/[\s._/-]+/).some((word) => word.startsWith(q))) return 2;
+  if (p.includes(q)) return 3;
+  if (isSubsequence(q, p)) return 4;
+  if (secondary && q.length >= 3 && secondary.toLowerCase().includes(q)) return 5;
+  return null;
+}
+function isSubsequence(needle, haystack) {
+  let i = 0;
+  for (const char of haystack) {
+    if (char === needle[i]) i += 1;
+    if (i === needle.length) return true;
+  }
+  return needle.length === 0;
+}
+function fuzzyFilter(items, query, fields) {
+  if (!query.trim()) return [...items];
+  return items.map((item, index) => {
+    const [primary, secondary] = fields(item);
+    return { item, index, rank: rankMatch(query, primary, secondary) };
+  }).filter((entry) => entry.rank !== null).sort((a, b) => a.rank - b.rank || a.index - b.index).map((entry) => entry.item);
+}
+function windowAround(count, cursor, size) {
+  if (count <= size) return { start: 0, end: count };
+  const half = Math.floor(size / 2);
+  const start = Math.max(0, Math.min(count - size, cursor - half));
+  return { start, end: start + size };
+}
+
+// src/ui/components/form-model.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rawFromValue(spec, value) {
+  if (value === void 0) return "";
+  if (value === null) return spec.nullable ? "null" : "";
+  if (spec.kind === "array" && Array.isArray(value) && value.every((v) => typeof v !== "object")) return value.join(", ");
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function createFormState(schema, initial = {}, opts = {}) {
+  const skip = new Set(opts.skip ?? []);
+  const specs = schemaToFlags(schema).filter((spec) => !skip.has(spec.property));
+  const ordered = [...specs.filter((s) => s.required), ...specs.filter((s) => !s.required)];
+  const fields = ordered.map((spec) => ({ spec, label: spec.flag }));
+  const values = {};
+  for (const field of fields) values[field.spec.property] = rawFromValue(field.spec, initial[field.spec.property]);
+  const missing = new Set(opts.missingRequired ?? []);
+  const firstMissing = fields.findIndex((f) => missing.has(f.spec.property) || f.spec.required && !values[f.spec.property]);
+  return {
+    schema,
+    fields,
+    values,
+    focus: Math.max(0, firstMissing),
+    errors: {},
+    status: "editing",
+    base: isRecord(initial) ? { ...initial } : {}
+  };
+}
+function validateField(schema, spec, raw) {
+  if (raw.trim() === "") return spec.required ? { error: "Required" } : {};
+  try {
+    const { input } = parseToolInput(schema, { [spec.attr]: raw });
+    return { value: input[spec.property] };
+  } catch (error) {
+    if (isCliError(error)) return { error: error.hint ? `${error.message}. ${error.hint}` : error.message };
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function withError(state, property, error) {
+  const errors = { ...state.errors };
+  if (error) errors[property] = error;
+  else delete errors[property];
+  return { ...state, errors };
+}
+function focused(state) {
+  return state.fields[state.focus];
+}
+function setValue(state, value) {
+  const field = focused(state);
+  if (!field) return state;
+  return withError({ ...state, values: { ...state.values, [field.spec.property]: value } }, field.spec.property, void 0);
+}
+function choices(spec) {
+  if (spec.kind === "boolean") return spec.required ? ["true", "false"] : ["", "true", "false"];
+  const values = spec.enumValues ?? [];
+  return spec.required ? values : ["", ...values];
+}
+function submit(state) {
+  let next = { ...state, errors: {} };
+  const result = { ...state.base };
+  for (const field of state.fields) {
+    const property = field.spec.property;
+    const checked = validateField(state.schema, field.spec, state.values[property] ?? "");
+    if (checked.error) next = withError(next, property, checked.error);
+    else if (checked.value === void 0) delete result[property];
+    else result[property] = checked.value;
+  }
+  const firstError = state.fields.findIndex((f) => next.errors[f.spec.property]);
+  if (firstError >= 0) return { ...next, focus: firstError };
+  return { ...next, status: "submitted", result };
+}
+function formReducer(state, action) {
+  if (state.status !== "editing") return state;
+  const field = focused(state);
+  const raw = field ? state.values[field.spec.property] ?? "" : "";
+  switch (action.type) {
+    case "type":
+      if (field?.spec.kind === "boolean") {
+        const c = action.text.toLowerCase();
+        if (c === "y" || c === "t") return setValue(state, "true");
+        if (c === "n" || c === "f") return setValue(state, "false");
+        if (c === " ") return formReducer(state, { type: "toggle" });
+        return state;
+      }
+      return field ? setValue(state, raw + action.text.replace(/\r\n?|\n/g, " ")) : state;
+    case "backspace":
+      return field ? setValue(state, field.spec.kind === "boolean" ? "" : [...raw].slice(0, -1).join("")) : state;
+    case "clear-field":
+      return setValue(state, "");
+    case "toggle":
+    case "cycle": {
+      if (!field || field.spec.kind !== "boolean" && field.spec.kind !== "enum") return state;
+      const options = choices(field.spec);
+      const delta = action.type === "cycle" ? action.delta : 1;
+      const index = Math.max(0, options.indexOf(raw));
+      return setValue(state, options[(index + delta + options.length) % options.length] ?? "");
+    }
+    case "next":
+    case "prev": {
+      if (state.fields.length === 0) return state;
+      const checked = field ? validateField(state.schema, field.spec, raw) : {};
+      const next = field && raw.trim() ? withError(state, field.spec.property, checked.error) : state;
+      const delta = action.type === "next" ? 1 : -1;
+      return { ...next, focus: (state.focus + delta + state.fields.length) % state.fields.length };
+    }
+    case "enter":
+      if (state.fields.length === 0 || state.focus >= state.fields.length - 1) return submit(state);
+      return formReducer(state, { type: "next" });
+    case "submit":
+      return submit(state);
+    case "cancel":
+      return { ...state, status: "cancelled" };
+    default:
+      return state;
+  }
+}
+function formKeyAction(state, input, key) {
+  const kind = focused(state)?.spec.kind;
+  if (key.escape) return { type: "cancel" };
+  if (key.tab) return key.shift ? { type: "prev" } : { type: "next" };
+  if (key.downArrow) return { type: "next" };
+  if (key.upArrow) return { type: "prev" };
+  if (key.return) return { type: "enter" };
+  if (key.ctrl && input === "s") return { type: "submit" };
+  if (key.ctrl && input === "u") return { type: "clear-field" };
+  if ((kind === "enum" || kind === "boolean") && (key.leftArrow || key.rightArrow)) {
+    return { type: "cycle", delta: key.leftArrow ? -1 : 1 };
+  }
+  if (key.backspace || key.delete) return { type: "backspace" };
+  if (key.ctrl || key.meta) return null;
+  return input ? { type: "type", text: input } : null;
+}
+function shellQuote(text) {
+  return /^[\w@%+=:,./-]+$/.test(text) ? text : `'${text.replace(/'/g, `'\\''`)}'`;
+}
+function equivalentCommand(tool, input, skip = []) {
+  const parts = ["tabbio", ...tool.commandPath];
+  for (const spec of schemaToFlags(tool.inputSchema)) {
+    const value = input[spec.property];
+    if (value === void 0 || skip.includes(spec.property)) continue;
+    if (spec.kind === "boolean" && typeof value === "boolean") {
+      parts.push(value ? `--${spec.flag}` : `--${spec.flag}=false`);
+      continue;
+    }
+    const text = spec.kind === "array" && Array.isArray(value) && value.every((v) => typeof v !== "object") ? value.join(",") : typeof value === "object" && value !== null ? JSON.stringify(value) : String(value);
+    parts.push(`--${spec.flag}`, shellQuote(text));
+  }
+  return parts.join(" ");
+}
+
+// src/ui/components/Form.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+function valueText(field, raw, focused2) {
+  const kind = field.spec.kind;
+  if (kind === "boolean") {
+    const on = raw === "true";
+    const unset = raw === "";
+    const box = unset ? "[ ]" : on ? "[x]" : "[-]";
+    const label = unset ? theme.dim("unset") : on ? "yes" : "no";
+    return `${focused2 ? theme.accent(box) : box} ${label}`;
+  }
+  if (kind === "enum") {
+    const text = raw || theme.dim("none");
+    return focused2 ? `${theme.accent("\u2039")} ${text} ${theme.accent("\u203A")}` : text;
+  }
+  return raw;
+}
+var FieldRow = memo3(function FieldRow2(props) {
+  const { field, raw, focused: focused2, error, labelWidth, width } = props;
+  const marker = field.spec.required ? theme.attention("*") : " ";
+  const label = padEnd(truncate(field.label, labelWidth), labelWidth);
+  const valueWidth = Math.max(8, Math.floor((width - labelWidth - 6) * 0.6));
+  const textLike = field.spec.kind !== "boolean" && field.spec.kind !== "enum";
+  const shown = textLike ? truncateStart(raw, valueWidth - 1) : valueText(field, raw, focused2);
+  const cursor = focused2 && textLike ? theme.accent(theme.symbols.cursor) : "";
+  const descBudget = width - labelWidth - 6 - valueWidth - 2;
+  const hint = field.spec.kind === "enum" && field.spec.enumValues?.length ? field.spec.enumValues.join(" | ") : field.spec.kind === "array" ? "comma-separated" : field.spec.kind === "json" ? "JSON" : field.spec.description;
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text4, { wrap: "truncate-end", children: [
+      focused2 ? theme.accent(theme.symbols.pointer) : " ",
+      " ",
+      focused2 ? theme.bold(label) : label,
+      " ",
+      marker,
+      " ",
+      padEnd(`${shown}${cursor}`, valueWidth),
+      descBudget > 8 && hint ? `  ${theme.dim(truncate(hint, descBudget))}` : ""
+    ] }),
+    error ? /* @__PURE__ */ jsxs3(Text4, { wrap: "truncate-end", children: [
+      "    ",
+      theme.error(`${theme.symbols.error} ${error}`)
+    ] }) : null
+  ] });
+});
+function Form(props) {
+  const { width, height, isActive, submitLabel = "run" } = props;
+  const [state, dispatch] = useReducer(formReducer, props.initial);
+  useInput2(
+    (input, key) => {
+      const action = formKeyAction(state, input, key);
+      if (action) dispatch(action);
+    },
+    { isActive: isActive && state.status === "editing" }
+  );
+  const { onSubmit, onCancel } = props;
+  useEffect2(() => {
+    if (state.status === "submitted" && state.result) onSubmit(state.result);
+    if (state.status === "cancelled") onCancel();
+  }, [state.status, state.result, onSubmit, onCancel]);
+  const labelWidth = Math.min(24, Math.max(6, ...state.fields.map((f) => displayWidth(f.label))));
+  const errorRows = Object.keys(state.errors).length;
+  const rows = Math.max(1, height - errorRows);
+  const { start, end } = windowAround(state.fields.length, state.focus, rows);
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width, children: [
+    state.fields.length === 0 ? /* @__PURE__ */ jsx5(Text4, { children: theme.dim("  This tool takes no input.") }) : null,
+    start > 0 ? /* @__PURE__ */ jsx5(Text4, { children: theme.dim(`  ${theme.symbols.ellipsis} ${start} above`) }) : null,
+    state.fields.slice(start, end).map((field, i) => /* @__PURE__ */ jsx5(
+      FieldRow,
+      {
+        field,
+        raw: state.values[field.spec.property] ?? "",
+        focused: start + i === state.focus,
+        error: state.errors[field.spec.property],
+        labelWidth,
+        width
+      },
+      field.spec.property
+    )),
+    end < state.fields.length ? /* @__PURE__ */ jsx5(Text4, { children: theme.dim(`  ${theme.symbols.ellipsis} ${state.fields.length - end} more`) }) : null,
+    /* @__PURE__ */ jsx5(Text4, { children: " " }),
+    /* @__PURE__ */ jsx5(
+      KeyHints,
+      {
+        width,
+        hints: [
+          { key: "tab", label: "next" },
+          { key: "shift+tab", label: "back" },
+          { key: "enter", label: state.focus >= state.fields.length - 1 ? submitLabel : "next" },
+          { key: "ctrl+s", label: submitLabel },
+          { key: "esc", label: "cancel" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/screens/chat/Chat.tsx
+import { Box as Box15, Static, Text as Text15, useInput as useInput5 } from "ink";
+import { memo as memo14, useCallback as useCallback3, useEffect as useEffect5, useMemo as useMemo4, useReducer as useReducer3, useRef as useRef4, useState as useState4 } from "react";
+
+// src/ui/components/editor-model.ts
+var emptyEditor = { value: "", cursor: 0, history: [], historyIndex: null, draft: "" };
+function chars(value) {
+  return [...value];
+}
+function place(state, next, cursor) {
+  return { ...state, value: next.join(""), cursor: Math.max(0, Math.min(next.length, cursor)), historyIndex: null };
+}
+function editorReducer(state, action) {
+  const list = chars(state.value);
+  switch (action.type) {
+    case "insert": {
+      const text = action.text.replace(/\r\n?/g, "\n");
+      const inserted = chars(text);
+      return place(state, [...list.slice(0, state.cursor), ...inserted, ...list.slice(state.cursor)], state.cursor + inserted.length);
+    }
+    case "newline":
+      return editorReducer(state, { type: "insert", text: "\n" });
+    case "backslash-newline":
+      if (state.cursor === 0 || list[state.cursor - 1] !== "\\") return editorReducer(state, { type: "newline" });
+      return place(state, [...list.slice(0, state.cursor - 1), "\n", ...list.slice(state.cursor)], state.cursor);
+    case "backspace":
+      if (state.cursor === 0) return state;
+      return place(state, [...list.slice(0, state.cursor - 1), ...list.slice(state.cursor)], state.cursor - 1);
+    case "left":
+      return { ...state, cursor: Math.max(0, state.cursor - 1) };
+    case "right":
+      return { ...state, cursor: Math.min(list.length, state.cursor + 1) };
+    case "home":
+      return { ...state, cursor: 0 };
+    case "end":
+      return { ...state, cursor: list.length };
+    case "kill-line":
+      return place(state, list.slice(state.cursor), 0);
+    case "kill-word": {
+      let i = state.cursor;
+      while (i > 0 && /\s/.test(list[i - 1])) i -= 1;
+      while (i > 0 && !/\s/.test(list[i - 1])) i -= 1;
+      return place(state, [...list.slice(0, i), ...list.slice(state.cursor)], i);
+    }
+    case "set":
+      return { ...state, value: action.value, cursor: chars(action.value).length, historyIndex: null };
+    case "clear":
+      return { ...state, value: "", cursor: 0, historyIndex: null, draft: "" };
+    case "remember": {
+      const value = action.value.trim();
+      if (!value || state.history[state.history.length - 1] === value) return state;
+      return { ...state, history: [...state.history, value].slice(-100) };
+    }
+    case "history-prev": {
+      if (state.history.length === 0) return state;
+      const index = state.historyIndex === null ? state.history.length - 1 : Math.max(0, state.historyIndex - 1);
+      const value = state.history[index];
+      return { ...state, value, cursor: chars(value).length, historyIndex: index, draft: state.historyIndex === null ? state.value : state.draft };
+    }
+    case "history-next": {
+      if (state.historyIndex === null) return state;
+      const index = state.historyIndex + 1;
+      if (index >= state.history.length) {
+        return { ...state, value: state.draft, cursor: chars(state.draft).length, historyIndex: null };
+      }
+      const value = state.history[index];
+      return { ...state, value, cursor: chars(value).length, historyIndex: index };
+    }
+    default:
+      return state;
+  }
+}
+function editorKeyAction(state, input, key) {
+  if (key.return) {
+    const list = chars(state.value);
+    if (state.cursor > 0 && list[state.cursor - 1] === "\\") return { type: "backslash-newline" };
+    return { type: "submit" };
+  }
+  if (input === "\n" && !key.ctrl) return { type: "newline" };
+  if (key.backspace || key.delete) return { type: "backspace" };
+  if (key.leftArrow) return { type: "left" };
+  if (key.rightArrow) return { type: "right" };
+  if (key.upArrow) return { type: "history-prev" };
+  if (key.downArrow) return { type: "history-next" };
+  if (key.ctrl) {
+    if (input === "a") return { type: "home" };
+    if (input === "e") return { type: "end" };
+    if (input === "u") return { type: "kill-line" };
+    if (input === "w") return { type: "kill-word" };
+    return null;
+  }
+  if (key.escape || key.tab || key.meta) return null;
+  if (input) return { type: "insert", text: input };
+  return null;
+}
+
+// src/ui/components/SelectList.tsx
+import { Box as Box5, Text as Text5, useInput as useInput3 } from "ink";
+import { memo as memo4, useMemo, useState as useState2 } from "react";
+
+// src/ui/components/select-model.ts
+var initialSelectState = { cursor: 0, query: "", filtering: false };
+function visibleItems(items, query) {
+  return fuzzyFilter(items, query, (item) => [item.label, item.description]);
+}
+function selectReducer(state, action, count) {
+  switch (action.type) {
+    case "move":
+      return count === 0 ? { ...state, cursor: 0 } : { ...state, cursor: Math.max(0, Math.min(count - 1, state.cursor + action.delta)) };
+    case "start-filter":
+      return { ...state, filtering: true };
+    case "type":
+      return { ...state, query: state.query + action.text, cursor: 0 };
+    case "backspace":
+      return state.query ? { ...state, query: [...state.query].slice(0, -1).join(""), cursor: 0 } : { ...state, filtering: false };
+    case "stop-filter":
+      return { ...state, filtering: false, query: "", cursor: 0 };
+    default:
+      return state;
+  }
+}
+function selectKeyAction(state, input, key, filterable) {
+  if (key.upArrow || key.ctrl && input === "p") return { type: "move", delta: -1 };
+  if (key.downArrow || key.ctrl && input === "n") return { type: "move", delta: 1 };
+  if (key.pageUp) return { type: "move", delta: -10 };
+  if (key.pageDown) return { type: "move", delta: 10 };
+  if (key.return) return { type: "select" };
+  if (key.escape) return state.filtering ? { type: "stop-filter" } : { type: "cancel" };
+  if (state.filtering) {
+    if (key.backspace || key.delete) return { type: "backspace" };
+    if (input && !key.ctrl && !key.meta && !key.tab) return { type: "type", text: input };
+    return null;
+  }
+  if (input === "j") return { type: "move", delta: 1 };
+  if (input === "k") return { type: "move", delta: -1 };
+  if (input === "q") return { type: "cancel" };
+  if (input === "/" && filterable) return { type: "start-filter" };
+  return null;
+}
+
+// src/ui/components/SelectList.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var Row = memo4(function Row2({ item, selected, width }) {
+  const meta = item.meta ? `  ${item.meta}` : "";
+  const labelBudget = Math.max(4, width - 2 - displayWidth(meta));
+  const label = truncate(item.label, labelBudget);
+  const descBudget = labelBudget - displayWidth(label) - 2;
+  const desc = item.description && descBudget > 6 ? `  ${truncate(item.description, descBudget)}` : "";
+  const fill = " ".repeat(Math.max(0, width - 2 - displayWidth(label) - displayWidth(desc) - displayWidth(meta)));
+  return /* @__PURE__ */ jsxs4(Text5, { wrap: "truncate-end", children: [
+    selected ? theme.accent(theme.symbols.pointer) : " ",
+    " ",
+    selected ? theme.accent(label) : label,
+    theme.dim(desc),
+    fill,
+    theme.dim(meta)
+  ] });
+});
+function SelectList(props) {
+  const { items, width, height, isActive, filterable = true, emptyText = "Nothing here", showHints = true } = props;
+  const [state, setState] = useState2(initialSelectState);
+  const shown = useMemo(() => visibleItems(items, state.query), [items, state.query]);
+  const cursor = Math.min(state.cursor, Math.max(0, shown.length - 1));
+  useInput3(
+    (input, key) => {
+      const outcome = selectKeyAction(state, input, key, filterable);
+      if (!outcome) return;
+      if (outcome.type === "select") {
+        const item = shown[cursor];
+        if (item) props.onSelect(item);
+        return;
+      }
+      if (outcome.type === "cancel") {
+        props.onCancel();
+        return;
+      }
+      const next = selectReducer(state, outcome, outcome.type === "move" ? shown.length : visibleItems(items, state.query).length);
+      setState(next);
+      props.onHighlight?.(visibleItems(items, next.query)[next.cursor]);
+    },
+    { isActive }
+  );
+  const rows = Math.max(1, height);
+  const { start, end } = windowAround(shown.length, cursor, rows);
+  return /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", width, children: [
+    state.filtering ? /* @__PURE__ */ jsxs4(Text5, { children: [
+      theme.accent("/"),
+      " ",
+      state.query,
+      theme.accent(theme.symbols.cursor)
+    ] }) : null,
+    shown.length === 0 ? /* @__PURE__ */ jsx6(Text5, { children: theme.dim(`  ${emptyText}`) }) : null,
+    shown.slice(start, end).map((item, i) => /* @__PURE__ */ jsx6(Row, { item, selected: isActive && start + i === cursor, width }, item.id)),
+    shown.length > rows ? /* @__PURE__ */ jsx6(Text5, { children: theme.dim(`  ${cursor + 1} of ${shown.length}`) }) : null,
+    showHints ? /* @__PURE__ */ jsx6(
+      KeyHints,
+      {
+        width,
+        hints: [
+          { key: theme.symbols.upDown, label: "move" },
+          { key: "enter", label: "open" },
+          ...filterable ? [{ key: "/", label: "filter" }] : [],
+          { key: "esc", label: "back" }
+        ]
+      }
+    ) : null
+  ] });
+}
+
+// src/ui/components/StatusBar.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { memo as memo5 } from "react";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function fitStatusBar(segments, hints, width) {
+  const sep = ` ${theme.symbols.middot} `;
+  let segs = [...segments];
+  let fitted = [...hints];
+  const measure = () => displayWidth(segs.join(sep)) + (fitted.length ? displayWidth(formatHints(fitted)) + 2 : 0);
+  while (measure() > width && fitted.length > 1) fitted = fitHints(fitted, displayWidth(formatHints(fitted)) - 1);
+  while (measure() > width && segs.length > 1) segs = segs.slice(0, -1);
+  if (measure() > width) fitted = [];
+  return { left: theme.dim(segs.join(sep)), right: fitted.length ? formatHints(fitted) : "" };
+}
+var StatusBar = memo5(function StatusBar2({ segments, hints = [], width }) {
+  const clean = segments.filter((s) => typeof s === "string" && s.length > 0);
+  const { left, right } = fitStatusBar(clean, hints, width);
+  return /* @__PURE__ */ jsxs5(Box6, { width, children: [
+    /* @__PURE__ */ jsx7(Box6, { flexGrow: 1, children: /* @__PURE__ */ jsx7(Text6, { wrap: "truncate-end", children: left }) }),
+    right ? /* @__PURE__ */ jsx7(Text6, { wrap: "truncate-end", children: right }) : null
+  ] });
+});
+
+// src/ui/components/TextInput.tsx
+import { Box as Box7, Text as Text7, useInput as useInput4 } from "ink";
+import { memo as memo6 } from "react";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+function cursorCell(char) {
+  if (theme.chalk.level > 0) return theme.inverse(char);
+  return `${theme.symbols.cursor}${char === " " ? "" : char}`;
+}
+function renderComposerLine(state, width, placeholder, showCursor) {
+  const budget = Math.max(4, width);
+  const chars2 = [...state.value];
+  if (chars2.length === 0) {
+    const hint = theme.dim(truncate(placeholder, Math.max(1, budget - 1)));
+    return showCursor ? `${cursorCell(" ")}${hint}` : hint;
+  }
+  const cells = chars2.map((char) => char === "\n" ? { text: theme.dim(theme.symbols.newline), width: displayWidth(theme.symbols.newline) } : { text: char, width: displayWidth(char) });
+  cells.push({ text: " ", width: 1 });
+  const cursor = Math.min(state.cursor, chars2.length);
+  let start = 0;
+  let used = cells.slice(0, cursor + 1).reduce((sum, c) => sum + c.width, 0);
+  while (used > budget - 1 && start < cursor) {
+    used -= cells[start].width;
+    start += 1;
+  }
+  let end = cursor + 1;
+  let total = used;
+  while (end < cells.length && total + cells[end].width <= budget - (start > 0 ? 1 : 0)) {
+    total += cells[end].width;
+    end += 1;
+  }
+  const out = cells.slice(start, end).map((cell, i) => {
+    const index = start + i;
+    if (index === cursor && showCursor) return cursorCell(index < chars2.length && chars2[index] !== "\n" ? cell.text : " ");
+    return cell.text;
+  });
+  if (end === cells.length && !showCursor) out.pop();
+  return `${start > 0 ? theme.dim(theme.symbols.ellipsis) : ""}${out.join("")}`;
+}
+var TextInput = memo6(function TextInput2(props) {
+  const { editor, dispatch, onSubmit, onKey, isActive, width, placeholder = "", boxed = false, prompt } = props;
+  useInput4(
+    (input, key) => {
+      if (onKey?.(input, key)) return;
+      const action = editorKeyAction(editor, input, key);
+      if (!action) return;
+      if (action.type === "submit") onSubmit(editor.value);
+      else dispatch(action);
+    },
+    { isActive }
+  );
+  const promptText = prompt ?? theme.symbols.pointer;
+  const inner = boxed ? width - 4 : width;
+  const line = renderComposerLine(editor, Math.max(4, inner - displayWidth(promptText) - 1), placeholder, isActive);
+  const content = /* @__PURE__ */ jsxs6(Text7, { wrap: "truncate-end", children: [
+    isActive ? theme.accent(promptText) : theme.dim(promptText),
+    " ",
+    line
+  ] });
+  if (!boxed) return content;
+  return /* @__PURE__ */ jsx8(Box7, { borderStyle: theme.boxStyle, borderDimColor: true, paddingX: 1, width, children: content });
+});
+
+// src/ui/screens/Palette.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import { memo as memo7 } from "react";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function paletteMatches(commands, draft) {
+  if (!draft.startsWith("/") || /\s/.test(draft)) return [];
+  return fuzzyFilter(commands, draft.slice(1), (c) => [c.name, c.description]);
+}
+function paletteArgMatches(commands, draft) {
+  const match = /^\/([a-z][\w-]*) (\S*)$/i.exec(draft);
+  if (!match) return [];
+  const command = commands.find((c) => c.name === match[1].toLowerCase());
+  if (!command?.args?.length) return [];
+  const typed = (match[2] ?? "").toLowerCase();
+  return command.args.filter((arg) => arg.value.startsWith(typed)).map((arg) => ({
+    name: `${command.name} ${arg.value}`,
+    usage: `/${command.name} ${arg.value}`,
+    description: arg.description,
+    completion: `/${command.name} ${arg.value}`
+  }));
+}
+function parseSlash(text) {
+  const match = /^\/([a-z][\w-]*)\s*([\s\S]*)$/i.exec(text.trim());
+  return match ? { name: match[1].toLowerCase(), arg: (match[2] ?? "").trim() } : null;
+}
+var Palette = memo7(function Palette2(props) {
+  const { commands, selected, width, maxRows = 6 } = props;
+  const nameWidth = Math.min(22, Math.max(8, ...commands.map((c) => displayWidth(c.usage ?? `/${c.name}`)))) + 2;
+  const { start, end } = windowAround(commands.length, selected, maxRows);
+  if (commands.length === 0) return /* @__PURE__ */ jsx9(Text8, { children: theme.dim("  No commands match") });
+  return /* @__PURE__ */ jsx9(Box8, { flexDirection: "column", width, children: commands.slice(start, end).map((command, i) => {
+    const active = start + i === selected;
+    const name = padEnd(truncate(command.usage ?? `/${command.name}`, nameWidth - 1), nameWidth);
+    return /* @__PURE__ */ jsxs7(Text8, { wrap: "truncate-end", children: [
+      active ? theme.accent(theme.symbols.pointer) : " ",
+      " ",
+      active ? theme.accent(name) : name,
+      theme.dim(command.description),
+      command.hint ? `  ${command.hint}` : ""
+    ] }, command.name);
+  }) });
+});
+
+// src/ui/screens/chat/commands.ts
+function choices2(key) {
+  return CAPABILITY_CHOICES[key].map((value) => ({ value, description: CAPABILITY_CHOICE_HELP[key][value] ?? "" }));
+}
+function chatCommands(opts) {
+  return [
+    { name: "new", description: "Start a new chat" },
+    { name: "threads", description: "Resume a recent chat" },
+    {
+      name: "mode",
+      usage: "/mode seeker|employer",
+      description: "Switch workspace",
+      args: [
+        { value: "seeker", description: "Your own career" },
+        { value: "employer", description: "Hiring for a company" }
+      ]
+    },
+    { name: "model", usage: "/model <id|auto>", description: "Pick the model" },
+    { name: "research", usage: "/research auto|on|off", description: "Web research for the next messages", args: choices2("research") },
+    { name: "image", usage: "/image auto|on|off", description: "Image generation", args: choices2("image") },
+    { name: "result", usage: "/result auto|summary|document|\u2026", description: "What to make: answer, document, slides, page, image", args: choices2("result") },
+    { name: "help", description: "Keys and commands" },
+    ...opts.hostedByHome ? [{ name: "home", description: "Back to the home screen" }] : [],
+    { name: "exit", description: "Quit tabbio" }
+  ];
+}
+function parseMode(value) {
+  const v = value.trim().toLowerCase();
+  return v === "seeker" || v === "employer" ? v : null;
+}
+var CHAT_HELP = [
+  "Commands: /new \xB7 /threads \xB7 /mode seeker|employer \xB7 /model <id|auto> \xB7 /help \xB7 /exit",
+  "          /research auto|on|off \xB7 /image auto|on|off \xB7 /result auto|summary|document|slides|page|image",
+  "          (saved for this profile; sent with every message in seeker mode)",
+  "Keys: enter send (queues while streaming) \xB7 ctrl+j or \\ then enter newline \xB7 esc interrupt",
+  "      \u2191\u2193 history \xB7 shift+tab switch mode \xB7 ctrl+o expand the last tool \xB7 ctrl+c twice quit"
+].join("\n");
+
+// src/ui/screens/chat/Transcript.tsx
+import { Box as Box14, Text as Text14 } from "ink";
+import { memo as memo13 } from "react";
+
+// src/ui/components/ArtifactRow.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { memo as memo8 } from "react";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+function kindGlyph(kind) {
+  switch (kind) {
+    case "document":
+      return theme.symbols.kindDocument;
+    case "slides":
+      return theme.symbols.kindSlides;
+    case "image":
+      return theme.symbols.kindImage;
+    case "page":
+      return theme.symbols.kindPage;
+    default:
+      return theme.symbols.kindFile;
+  }
+}
+function kindLabel(kind) {
+  return kind === "slides" ? "Slides" : kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+function artifactStatusText(artifact, draft) {
+  if (artifact.status === "pending") {
+    if (draft && draft.phase !== "end") return draftSummary(draft);
+    return artifact.previewAvailable ? "preview ready, rendering files" : "rendering";
+  }
+  return artifact.status;
+}
+var ArtifactRow = memo8(function ArtifactRow2({ artifact, draft, width, hint = true }) {
+  const status = artifactStatusText(artifact, draft);
+  const tone = artifact.status === "failed" ? theme.error : artifact.status === "ready" ? theme.success : theme.dim;
+  const meta = [kindLabel(artifact.kind).toLowerCase(), status, shortId(artifact.id, 6, 4)];
+  if (artifact.versionNumber && artifact.versionNumber > 1) meta.push(`v${artifact.versionNumber}`);
+  const openHint = hint && artifact.status !== "failed" ? `tabbio artifacts open ${artifact.id}` : "";
+  const titleBudget = Math.max(8, Math.min(48, width - 4 - displayWidth(meta.join(" \xB7 ")) - 6));
+  const title = truncate(artifact.title || "Untitled", titleBudget);
+  const linked = artifact.status === "ready" && artifact.previewUrl;
+  return /* @__PURE__ */ jsxs8(Box9, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs8(Box9, { width, children: [
+      artifact.status === "pending" ? /* @__PURE__ */ jsx10(Spinner, {}) : /* @__PURE__ */ jsx10(Text9, { children: artifact.status === "ready" ? theme.success(theme.symbols.success) : theme.error(theme.symbols.error) }),
+      /* @__PURE__ */ jsx10(Box9, { flexShrink: 0, marginLeft: 1, children: /* @__PURE__ */ jsxs8(Text9, { children: [
+        theme.accent(kindGlyph(artifact.kind)),
+        " ",
+        linked ? hyperlink(theme.bold(title), artifact.previewUrl) : theme.bold(title)
+      ] }) }),
+      /* @__PURE__ */ jsx10(Box9, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs8(Text9, { wrap: "truncate-end", children: [
+        theme.dim(` ${theme.symbols.middot} `),
+        tone(meta.join(` ${theme.symbols.middot} `)),
+        openHint ? theme.dim(`  ${openHint}`) : ""
+      ] }) })
+    ] }),
+    artifact.failure?.message ? /* @__PURE__ */ jsx10(Text9, { wrap: "truncate-end", children: theme.dim(`  ${theme.symbols.arrowRight} ${artifact.failure.message}`) }) : null
+  ] });
+});
+
+// src/ui/components/Markdown.tsx
+import { Box as Box11, Text as Text11 } from "ink";
+import { marked } from "marked";
+import { memo as memo10, useMemo as useMemo3 } from "react";
+
+// src/ui/components/markdown-inline.ts
+var ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+  "&nbsp;": " "
+};
+function decodeEntities(text) {
+  return text.replace(/&(?:amp|lt|gt|quot|apos|nbsp|#39);/g, (m) => ENTITIES[m] ?? m).replace(/&#(\d{1,6});/g, (m, code) => {
+    const n = Number(code);
+    return n > 0 && n < 1114111 ? String.fromCodePoint(n) : m;
+  });
+}
+function childTokens(token) {
+  const tokens = token.tokens;
+  return Array.isArray(tokens) ? tokens : void 0;
+}
+function textOf(token) {
+  const text = token.text;
+  if (typeof text === "string") return text;
+  const raw = token.raw;
+  return typeof raw === "string" ? raw : "";
+}
+function renderLink(token) {
+  const label = renderInline(token.tokens, token.text);
+  const href = token.href ?? "";
+  const plain = stripAnsi(label).trim();
+  if (!href || plain === href || `mailto:${plain}` === href) return theme.link(label || href);
+  return `${label} ${theme.dim(`(${href})`)}`;
+}
+function renderToken(token) {
+  switch (token.type) {
+    case "text": {
+      const children = childTokens(token);
+      return children ? renderInline(children, textOf(token)) : decodeEntities(textOf(token));
+    }
+    case "escape":
+      return textOf(token);
+    case "strong":
+      return theme.bold(renderInline(childTokens(token), textOf(token)));
+    case "em":
+      return theme.italic(renderInline(childTokens(token), textOf(token)));
+    case "del":
+      return theme.strike(renderInline(childTokens(token), textOf(token)));
+    case "codespan":
+      return theme.code(decodeEntities(textOf(token)));
+    case "br":
+      return "\n";
+    case "link":
+      return renderLink(token);
+    case "image": {
+      const image = token;
+      return `${theme.dim("[image]")} ${image.text || ""}${image.href ? ` ${theme.dim(`(${image.href})`)}` : ""}`.trim();
+    }
+    case "html": {
+      const text = textOf(token);
+      return /^<br\s*\/?>$/i.test(text.trim()) ? "\n" : "";
+    }
+    case "checkbox":
+      return "";
+    default:
+      return decodeEntities(textOf(token));
+  }
+}
+function renderInline(tokens, fallback = "") {
+  if (!tokens || tokens.length === 0) return decodeEntities(fallback);
+  let out = "";
+  for (const token of tokens) {
+    try {
+      out += renderToken(token);
+    } catch {
+      out += textOf(token);
+    }
+  }
+  return out;
+}
+
+// src/ui/components/Table.tsx
+import { Box as Box10, Text as Text10 } from "ink";
+import { memo as memo9, useMemo as useMemo2 } from "react";
+
+// src/ui/components/table-layout.ts
+var TABLE_GAP = 2;
+var MIN_CELL = 4;
+function minWidth(column) {
+  return Math.min(Math.max(MIN_CELL, displayWidth(column.header)), 10);
+}
+function layoutTable(columns, rows, width, gap = TABLE_GAP) {
+  let visible = [...columns];
+  const natural = (column) => Math.min(
+    column.maxWidth ?? 48,
+    Math.max(displayWidth(column.header), ...rows.map((row) => displayWidth(row[column.key] ?? "")))
+  );
+  let widths = visible.map(natural);
+  const total = () => widths.reduce((a, b) => a + b, 0) + gap * Math.max(0, widths.length - 1);
+  for (; ; ) {
+    while (total() > width) {
+      let widest = -1;
+      for (let i = 0; i < widths.length; i += 1) {
+        const column = visible[i];
+        if (widths[i] > minWidth(column) && (widest < 0 || widths[i] > widths[widest])) {
+          widest = i;
+        }
+      }
+      if (widest < 0) break;
+      widths[widest] = widths[widest] - 1;
+    }
+    if (total() <= width || visible.length <= 1) break;
+    visible = visible.slice(0, -1);
+    widths = visible.map(natural);
+  }
+  if (visible.length === 1 && total() > width) widths = [Math.max(1, width)];
+  return { columns: visible, widths };
+}
+function formatTableRow(layout, cells, gap = TABLE_GAP) {
+  return layout.columns.map((column, i) => {
+    const w = layout.widths[i];
+    const text = truncate((cells[column.key] ?? "").replace(/\s+/g, " "), w);
+    return column.align === "right" ? padStart(text, w) : padEnd(text, w);
+  }).join(" ".repeat(gap)).trimEnd();
+}
+function formatTableHeader(layout, gap = TABLE_GAP) {
+  const cells = {};
+  for (const column of layout.columns) cells[column.key] = column.header;
+  return formatTableRow(layout, cells, gap);
+}
+
+// src/ui/components/Table.tsx
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var Table = memo9(function Table2({ columns, rows, width, offset = 0, limit }) {
+  const layout = useMemo2(() => layoutTable(columns, rows, width), [columns, rows, width]);
+  const shown = rows.slice(offset, limit === void 0 ? void 0 : offset + limit);
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx11(Text10, { wrap: "truncate-end", children: theme.dim(formatTableHeader(layout)) }),
+    shown.map((row, i) => /* @__PURE__ */ jsx11(Text10, { wrap: "truncate-end", children: formatTableRow(layout, row) }, offset + i))
+  ] });
+});
+
+// src/ui/components/Markdown.tsx
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
+function lexMarkdown(text) {
+  try {
+    return marked.lexer(text.replace(/\r\n?/g, "\n"), { gfm: true });
+  } catch {
+    return [{ type: "paragraph", raw: text, text, tokens: [{ type: "text", raw: text, text }] }];
+  }
+}
+function tokensOf(token) {
+  const tokens = token.tokens;
+  return Array.isArray(tokens) ? tokens : void 0;
+}
+function textOf2(token) {
+  const text = token.text;
+  return typeof text === "string" ? text : typeof token.raw === "string" ? token.raw : "";
+}
+function renderList(list, ctx, key, trailing = "") {
+  const start = typeof list.start === "number" ? list.start : 1;
+  const markers = list.items.map(
+    (item, i) => list.ordered ? `${start + i}.` : item.task ? item.checked ? "[x]" : "[ ]" : theme.symbols.bullet
+  );
+  const markerWidth = Math.max(...markers.map((m) => stripAnsi(m).length)) + 1;
+  return /* @__PURE__ */ jsx12(Box11, { flexDirection: "column", children: list.items.map((item, i) => /* @__PURE__ */ jsxs10(Box11, { children: [
+    /* @__PURE__ */ jsx12(Box11, { width: markerWidth, flexShrink: 0, children: /* @__PURE__ */ jsx12(Text11, { children: list.ordered ? markers[i] : theme.dim(markers[i]) }) }),
+    /* @__PURE__ */ jsx12(Box11, { flexDirection: "column", width: Math.max(8, ctx.width - markerWidth), children: renderBlocks(
+      item.tokens,
+      { width: Math.max(8, ctx.width - markerWidth), trailing: i === list.items.length - 1 && trailing ? trailing : void 0 },
+      `${key}-${i}`,
+      false
+    ) })
+  ] }, `${key}-${i}`)) }, key);
+}
+function renderTable(table, ctx, key) {
+  const columns = table.header.map((cell, i) => ({
+    key: String(i),
+    header: stripAnsi(renderInline(cell.tokens, cell.text)),
+    align: table.align[i] === "right" ? "right" : "left"
+  }));
+  const rows = table.rows.map((row) => {
+    const record = {};
+    row.forEach((cell, i) => {
+      record[String(i)] = stripAnsi(renderInline(cell.tokens, cell.text));
+    });
+    return record;
+  });
+  return /* @__PURE__ */ jsx12(Table, { columns, rows, width: ctx.width }, key);
+}
+function renderBlock(token, ctx, key, trailing) {
+  switch (token.type) {
+    case "heading":
+      return /* @__PURE__ */ jsxs10(Text11, { bold: true, children: [
+        renderInline(tokensOf(token), textOf2(token)),
+        trailing
+      ] }, key);
+    case "paragraph":
+    case "text":
+      return /* @__PURE__ */ jsxs10(Text11, { children: [
+        renderInline(tokensOf(token), textOf2(token)),
+        trailing
+      ] }, key);
+    case "list":
+      return renderList(token, ctx, key, trailing);
+    case "code": {
+      const lines = textOf2(token).replace(/\n$/, "").split("\n");
+      return /* @__PURE__ */ jsx12(
+        Box11,
+        {
+          flexDirection: "column",
+          marginLeft: 2,
+          borderStyle: theme.unicode ? "single" : "classic",
+          borderTop: false,
+          borderRight: false,
+          borderBottom: false,
+          borderLeftDimColor: true,
+          paddingLeft: 1,
+          children: lines.map((line, i) => /* @__PURE__ */ jsx12(Text11, { children: line || " " }, i))
+        },
+        key
+      );
+    }
+    case "blockquote":
+      return /* @__PURE__ */ jsx12(Rail, { tone: "muted", children: renderBlocks(tokensOf(token) ?? [], { width: Math.max(8, ctx.width - 2) }, key, false) }, key);
+    case "hr":
+      return /* @__PURE__ */ jsx12(Text11, { children: theme.dim(theme.symbols.line.repeat(Math.max(3, Math.min(ctx.width, 60)))) }, key);
+    case "table":
+      return renderTable(token, ctx, key);
+    case "html":
+      return /* @__PURE__ */ jsx12(Text11, { children: theme.dim(textOf2(token).trim()) }, key);
+    case "space":
+    case "def":
+      return null;
+    default:
+      return /* @__PURE__ */ jsx12(Text11, { children: textOf2(token) }, key);
+  }
+}
+var INLINE_TAIL = /* @__PURE__ */ new Set(["paragraph", "text", "heading", "list"]);
+function renderBlocks(tokens, ctx, keyPrefix, spaced = true) {
+  const blocks = tokens.filter((t) => t.type !== "space" && t.type !== "def");
+  const out = [];
+  blocks.forEach((token, i) => {
+    const isLast = i === blocks.length - 1;
+    const trailing = isLast && ctx.trailing && INLINE_TAIL.has(token.type) ? ctx.trailing : "";
+    let node;
+    try {
+      node = renderBlock(token, ctx, `${keyPrefix}-${i}`, trailing);
+    } catch {
+      node = /* @__PURE__ */ jsx12(Text11, { children: token.raw }, `${keyPrefix}-${i}`);
+    }
+    if (spaced && i > 0) out.push(/* @__PURE__ */ jsx12(Text11, { children: " " }, `${keyPrefix}-${i}-gap`));
+    out.push(node);
+    if (isLast && ctx.trailing && !trailing) out.push(/* @__PURE__ */ jsx12(Text11, { children: ctx.trailing }, `${keyPrefix}-tail`));
+  });
+  if (blocks.length === 0 && ctx.trailing) out.push(/* @__PURE__ */ jsx12(Text11, { children: ctx.trailing }, `${keyPrefix}-tail`));
+  return out;
+}
+var Markdown = memo10(function Markdown2({ text, width, trailing }) {
+  const tokens = useMemo3(() => lexMarkdown(text), [text]);
+  return /* @__PURE__ */ jsx12(Box11, { flexDirection: "column", width, children: renderBlocks(tokens, { width, trailing }, "md") });
+});
+
+// src/ui/components/SourcesList.tsx
+import { Box as Box12, Text as Text12 } from "ink";
+import { memo as memo11 } from "react";
+import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
+var MAX_SOURCES = 8;
+function hostOf(source) {
+  if (source.domain) return source.domain;
+  try {
+    return new URL(source.url).host;
+  } catch {
+    return "";
+  }
+}
+var SourcesList = memo11(function SourcesList2(props) {
+  const { sources, width } = props;
+  const links = props.links ?? supportsHyperlinks();
+  const shown = sources.slice(0, MAX_SOURCES);
+  const numberWidth = String(shown.length).length;
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx13(Text12, { children: theme.dim("Sources") }),
+    shown.map((source, i) => {
+      const host = hostOf(source);
+      const title = truncate(source.title, Math.max(10, Math.min(60, width - numberWidth - displayWidth(host) - 8)));
+      return /* @__PURE__ */ jsxs11(Box12, { width, children: [
+        /* @__PURE__ */ jsx13(Box12, { flexShrink: 0, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+          theme.dim(String(i + 1).padStart(numberWidth)),
+          " ",
+          links ? hyperlink(title, source.url) : title
+        ] }) }),
+        /* @__PURE__ */ jsx13(Box12, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsxs11(Text12, { wrap: "truncate-end", children: [
+          host && host !== source.title ? theme.dim(` ${theme.symbols.middot} ${host}`) : "",
+          links ? "" : theme.dim(`  ${source.url}`)
+        ] }) })
+      ] }, `${i}-${source.url}`);
+    }),
+    sources.length > shown.length ? /* @__PURE__ */ jsx13(Text12, { children: theme.dim(`+${sources.length - shown.length} more`) }) : null
+  ] });
+});
+
+// src/ui/components/ToolCallRow.tsx
+import { Box as Box13, Text as Text13 } from "ink";
+import { memo as memo12 } from "react";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resultSummary(result) {
+  if (Array.isArray(result)) return `${result.length} found`;
+  if (!isRecord2(result)) return "";
+  if (result.ok === false || result.error === true) return "failed";
+  for (const key of ["total", "totalCount", "count"]) {
+    if (typeof result[key] === "number") return `${result[key]} found`;
+  }
+  const arrays = Object.values(result).filter(Array.isArray);
+  return arrays.length === 1 ? `${arrays[0].length} found` : "";
+}
+function glyph(call) {
+  if (call.decision === "approve") return /* @__PURE__ */ jsx14(Text13, { children: theme.success(theme.symbols.success) });
+  if (call.decision === "reject") return /* @__PURE__ */ jsx14(Text13, { children: theme.error(theme.symbols.error) });
+  if (call.left) return /* @__PURE__ */ jsx14(Text13, { children: theme.attention(theme.symbols.attention) });
+  switch (call.stage) {
+    case "running":
+      return /* @__PURE__ */ jsx14(Spinner, {});
+    case "pending_approval":
+      return /* @__PURE__ */ jsx14(Text13, { children: theme.attention(theme.symbols.attention) });
+    case "completed":
+      return /* @__PURE__ */ jsx14(Text13, { children: theme.success(theme.symbols.success) });
+    case "failed":
+      return /* @__PURE__ */ jsx14(Text13, { children: theme.error(theme.symbols.error) });
+    default:
+      return /* @__PURE__ */ jsx14(Text13, { children: theme.dim(theme.symbols.error) });
+  }
+}
+function titleText(call) {
+  if (call.decision === "approve") return `Approved ${call.title}`;
+  if (call.decision === "reject") return `Rejected ${call.title}`;
+  if (call.left) return `Left pending ${call.title}`;
+  if (call.stage === "running") return `${call.title}${theme.symbols.ellipsis}`;
+  if (call.stage === "declined") return `${call.title} ${theme.dim("declined")}`;
+  return call.title;
+}
+function formatToolDuration(ms) {
+  if (ms === void 0) return null;
+  return ms < 100 ? "<0.1s" : formatElapsed(ms);
+}
+var RunningTime = memo12(function RunningTime2({ since }) {
+  useClockTick(true);
+  const elapsed = Date.now() - since;
+  return elapsed >= 1e3 ? /* @__PURE__ */ jsx14(Text13, { children: theme.dim(formatElapsed(elapsed)) }) : null;
+});
+var ToolCallRow = memo12(function ToolCallRow2({ call, width, expanded = false }) {
+  const card = cardOf(call);
+  if (card && !(call.stage === "pending_approval" && !call.decision)) {
+    return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", width, children: [
+      /* @__PURE__ */ jsx14(ArtifactRow, { artifact: card, draft: call.draft, width }),
+      expanded ? /* @__PURE__ */ jsx14(ToolCallDetail, { call, width }) : null
+    ] });
+  }
+  const waiting = call.stage === "pending_approval" && !call.decision && !call.left;
+  const summary = waiting ? theme.attention("waiting for approval") : call.left && call.approvalId ? theme.dim(shortId(call.approvalId)) : theme.dim(call.denial ? "unavailable" : call.stage === "failed" ? "failed" : call.research ? sourcesSummary(call) : resultSummary(call.result));
+  const measured = formatToolDuration(call.durationMs);
+  const duration = measured ? theme.dim(measured) : null;
+  const running = call.stage === "running" && call.endedAt === void 0;
+  const rightWidth = displayWidth(summary) + 2 + (duration ? displayWidth(duration) : 6);
+  const args = summarizeArgs(call.args, Math.max(8, width - displayWidth(titleText(call)) - rightWidth - 7));
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs12(Box13, { width, children: [
+      glyph(call),
+      /* @__PURE__ */ jsx14(Box13, { flexGrow: 1, flexShrink: 1, marginLeft: 1, children: /* @__PURE__ */ jsxs12(Text13, { wrap: "truncate-end", children: [
+        titleText(call),
+        args ? theme.dim(` ${theme.symbols.middot} ${args}`) : ""
+      ] }) }),
+      /* @__PURE__ */ jsxs12(Box13, { flexShrink: 0, marginLeft: 1, children: [
+        summary ? /* @__PURE__ */ jsxs12(Text13, { children: [
+          summary,
+          "  "
+        ] }) : null,
+        duration ? /* @__PURE__ */ jsx14(Text13, { children: duration }) : running ? /* @__PURE__ */ jsx14(RunningTime, { since: call.startedAt }) : null
+      ] })
+    ] }),
+    call.denial ? /* @__PURE__ */ jsx14(Text13, { wrap: "truncate-end", children: theme.dim(`  ${theme.symbols.arrowRight} ${call.denial.message}${call.denial.reason ? ` (${call.denial.reason})` : ""}`) }) : null,
+    expanded ? /* @__PURE__ */ jsx14(ToolCallDetail, { call, width }) : null
+  ] });
+});
+function cardOf(call) {
+  if (call.artifact) return call.artifact;
+  if (!call.draft || call.stage !== "running") return null;
+  const title = typeof call.args.title === "string" && call.args.title ? call.args.title : call.title;
+  return { id: call.draft.artifactId, kind: call.draft.kind, title, status: "pending" };
+}
+function sourcesSummary(call) {
+  const n = call.sources?.length ?? 0;
+  if (call.stage === "running") return "";
+  return n ? `${n} ${n === 1 ? "source" : "sources"}` : "no sources";
+}
+function researchLines(call) {
+  const result = isRecord2(call.result) ? call.result : {};
+  const queries = Array.isArray(result.queries) ? result.queries.filter((q) => typeof q === "string") : [];
+  const lines = queries.map((q) => `query  ${q}`);
+  (call.sources ?? []).forEach((source, i) => lines.push(`${i + 1}  ${source.title}  ${theme.dim(source.url)}`));
+  return lines;
+}
+var ToolCallDetail = memo12(function ToolCallDetail2({ call, width }) {
+  if (call.research && call.result !== void 0 && !call.denial) {
+    const { lines, hidden } = clipLines(researchLines(call).join("\n"), 16);
+    return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", marginLeft: 2, width: Math.max(10, width - 2), children: [
+      lines.map((line, i) => /* @__PURE__ */ jsxs12(Text13, { wrap: "truncate-end", children: [
+        theme.dim(theme.symbols.gutter),
+        " ",
+        line
+      ] }, i)),
+      hidden > 0 ? /* @__PURE__ */ jsx14(Text13, { children: theme.dim(`  +${hidden} lines`) }) : null
+    ] });
+  }
+  const blocks = [["args", call.args]];
+  if (call.result !== void 0) blocks.push(["result", call.result]);
+  return /* @__PURE__ */ jsx14(Box13, { flexDirection: "column", marginLeft: 2, width: Math.max(10, width - 2), children: blocks.map(([label, value]) => {
+    const { lines, hidden } = clipLines(safeJson(value), 16);
+    return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx14(Text13, { children: theme.dim(label) }),
+      lines.map((line, i) => /* @__PURE__ */ jsxs12(Text13, { wrap: "truncate-end", children: [
+        theme.dim(theme.symbols.gutter),
+        " ",
+        line
+      ] }, i)),
+      hidden > 0 ? /* @__PURE__ */ jsx14(Text13, { children: theme.dim(`  +${hidden} lines`) }) : null
+    ] }, label);
+  }) });
+});
+
+// src/ui/screens/chat/Transcript.tsx
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+var ASSISTANT_INDENT = 2;
+var USER_MAX_LINES = 6;
+var WAITING_AFTER_MS = 1e4;
+function noticeGlyph(tone) {
+  if (tone === "error") return theme.error(theme.symbols.error);
+  if (tone === "success") return theme.success(theme.symbols.success);
+  if (tone === "attention") return theme.attention(theme.symbols.attention);
+  return theme.dim(theme.symbols.dot);
+}
+function UserTurn({ text, width }) {
+  const lines = text.split("\n");
+  const shown = lines.slice(0, USER_MAX_LINES);
+  return /* @__PURE__ */ jsx15(Box14, { marginTop: 1, children: /* @__PURE__ */ jsxs13(Rail, { tone: "accent", width, children: [
+    shown.map((line, i) => /* @__PURE__ */ jsx15(Text14, { wrap: "wrap", children: line || " " }, i)),
+    lines.length > USER_MAX_LINES ? /* @__PURE__ */ jsx15(Text14, { children: theme.dim(`+${lines.length - USER_MAX_LINES} lines`) }) : null
+  ] }) });
+}
+var EntryView = memo13(function EntryView2({ entry, width }) {
+  const inner = Math.max(10, width - ASSISTANT_INDENT);
+  switch (entry.kind) {
+    case "header": {
+      const fill = Math.max(1, width - displayWidth(entry.text) - displayWidth(entry.right));
+      return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsxs13(Text14, { wrap: "truncate-end", children: [
+          entry.text,
+          " ".repeat(fill),
+          theme.dim(entry.right)
+        ] }),
+        /* @__PURE__ */ jsx15(Text14, { children: theme.dim(theme.symbols.line.repeat(width)) })
+      ] });
+    }
+    case "user":
+      return /* @__PURE__ */ jsx15(UserTurn, { text: entry.text, width });
+    case "assistant":
+      return /* @__PURE__ */ jsx15(Box14, { marginTop: 1, children: /* @__PURE__ */ jsxs13(Text14, { children: [
+        theme.accent(theme.symbols.dot),
+        " ",
+        theme.bold("Tabbio")
+      ] }) });
+    case "markdown":
+      return /* @__PURE__ */ jsx15(Box14, { paddingLeft: ASSISTANT_INDENT, marginTop: entry.gap ? 1 : 0, width, children: /* @__PURE__ */ jsx15(Markdown, { text: entry.text, width: inner }) });
+    case "tool":
+      return /* @__PURE__ */ jsx15(Box14, { paddingLeft: ASSISTANT_INDENT, marginTop: entry.gap ? 1 : 0, width, children: /* @__PURE__ */ jsx15(ToolCallRow, { call: entry.call, width: inner }) });
+    case "tool-detail":
+      return /* @__PURE__ */ jsxs13(Box14, { paddingLeft: ASSISTANT_INDENT, flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsx15(Text14, { children: theme.dim(`${theme.symbols.expanded} ${entry.call.title}`) }),
+        /* @__PURE__ */ jsx15(ToolCallDetail, { call: entry.call, width: inner })
+      ] });
+    case "artifact":
+      return /* @__PURE__ */ jsx15(Box14, { paddingLeft: ASSISTANT_INDENT, width, children: /* @__PURE__ */ jsx15(ArtifactRow, { artifact: entry.artifact, width: inner }) });
+    case "sources":
+      return /* @__PURE__ */ jsx15(Box14, { paddingLeft: ASSISTANT_INDENT, marginTop: 1, width, children: /* @__PURE__ */ jsx15(SourcesList, { sources: entry.sources, width: inner }) });
+    case "notice":
+      return /* @__PURE__ */ jsxs13(Box14, { paddingLeft: ASSISTANT_INDENT, marginTop: 1, flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsxs13(Text14, { wrap: "wrap", children: [
+          noticeGlyph(entry.tone),
+          " ",
+          entry.tone === "error" ? theme.error(entry.text) : entry.tone === "info" ? theme.dim(entry.text) : entry.text
+        ] }),
+        entry.hint ? /* @__PURE__ */ jsx15(Text14, { wrap: "wrap", children: theme.dim(`  ${theme.symbols.arrowRight} ${entry.hint}`) }) : null
+      ] });
+    default:
+      return null;
+  }
+});
+function clipLiveText(text, width, maxLines) {
+  if (estimateHeight(text, width) <= maxLines) return { text, hidden: 0 };
+  const lines = text.split("\n");
+  const kept = [];
+  let used = 1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const h = estimateHeight(lines[i], width);
+    if (used + h > maxLines) break;
+    kept.unshift(lines[i]);
+    used += h;
+  }
+  return { text: kept.join("\n"), hidden: lines.length - kept.length };
+}
+function WaitingLine({ turn }) {
+  useClockTick(true);
+  const idleFor = Date.now() - turn.lastEventAt;
+  const empty = turn.items.length === 0;
+  if (!empty && idleFor < WAITING_AFTER_MS) return null;
+  const label = empty && idleFor < WAITING_AFTER_MS ? "Thinking\u2026" : "waiting for Tabbio\u2026";
+  return /* @__PURE__ */ jsx15(Box14, { paddingLeft: ASSISTANT_INDENT, children: /* @__PURE__ */ jsx15(Spinner, { label: theme.dim(`${label} ${formatElapsed(Date.now() - (empty ? turn.startedAt : turn.lastEventAt))}`) }) });
+}
+function liveGap(prev, item) {
+  if (item.kind === "tool") return prev === "markdown" || prev === "text";
+  return prev === "tool" || prev === "markdown" || item.committed > 0;
+}
+var LiveItemView = memo13(function LiveItemView2(props) {
+  const { item, width, expanded, cursor, maxLines, gap } = props;
+  if (item.kind === "tool") {
+    return /* @__PURE__ */ jsx15(Box14, { marginTop: gap ? 1 : 0, children: /* @__PURE__ */ jsx15(ToolCallRow, { call: item.call, width, expanded }) });
+  }
+  const pending = item.text.slice(item.committed);
+  if (!pending && !cursor) return null;
+  const clipped = clipLiveText(pending, width, maxLines);
+  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", width, marginTop: gap ? 1 : 0, children: [
+    clipped.hidden > 0 ? /* @__PURE__ */ jsx15(Text14, { children: theme.dim(`${theme.symbols.ellipsis} ${clipped.hidden} more lines above (streaming)`) }) : null,
+    /* @__PURE__ */ jsx15(Markdown, { text: clipped.text, width, trailing: cursor ? theme.accent(theme.symbols.cursor) : void 0 })
+  ] });
+});
+function LiveTurn(props) {
+  const { turn, width, expandTools, maxLines, streaming } = props;
+  const inner = Math.max(10, width - ASSISTANT_INDENT);
+  const last = turn.items[turn.items.length - 1];
+  const tools = turn.items.filter((i) => i.kind === "tool").length;
+  const textBudget = Math.max(3, maxLines - tools - 1);
+  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx15(Box14, { flexDirection: "column", paddingLeft: ASSISTANT_INDENT, width, children: turn.items.map((item, i) => {
+      const before = turn.items[i - 1];
+      const prev = before ? before.kind === "tool" ? "tool" : "text" : turn.lastKind;
+      return /* @__PURE__ */ jsx15(
+        LiveItemView,
+        {
+          item,
+          width: inner,
+          expanded: expandTools,
+          cursor: streaming && item === last && item.kind === "text",
+          maxLines: textBudget,
+          gap: liveGap(prev, item)
+        },
+        item.id
+      );
+    }) }),
+    streaming ? /* @__PURE__ */ jsx15(WaitingLine, { turn }) : null
+  ] });
+}
+
+// src/ui/screens/chat/useChatCommands.ts
+import { useCallback, useRef } from "react";
+function useChatCommands(deps) {
+  const { session, services, companyId, hostedByHome, onExit, openThreads } = deps;
+  const { state } = session;
+  const availability = useRef(null);
+  const warnIfUnavailable = useCallback(
+    (capabilities) => {
+      if (!services.loadCapabilities) return;
+      availability.current ??= services.loadCapabilities().catch(() => null);
+      void availability.current.then((answer) => {
+        for (const text of unavailableNotices(capabilities, answer)) session.dispatch({ type: "notice", tone: "info", text });
+      });
+    },
+    [services, session]
+  );
+  const setCapability = useCallback(
+    (key, arg) => {
+      if (!arg) {
+        session.dispatch({ type: "notice", tone: "info", text: `${key} ${state.capabilities[key]} ${theme.symbols.middot} /${key} <mode> to change it` });
+        return;
+      }
+      let value;
+      try {
+        value = parseCapabilityMode(key, arg);
+      } catch (error) {
+        session.dispatch({ type: "notice", tone: "error", text: toCliError(error).message.replace(/^--/, "/") });
+        return;
+      }
+      const next = { ...state.capabilities, [key]: value };
+      session.dispatch({ type: "set-capability", key, value });
+      let saved = false;
+      try {
+        services.saveCapabilityPrefs?.(next);
+        saved = Boolean(services.saveCapabilityPrefs);
+      } catch {
+        saved = false;
+      }
+      const scope = state.mode === "employer" ? " (employer chats ignore it)" : "";
+      session.dispatch({
+        type: "notice",
+        tone: "info",
+        text: `${key} ${value}${scope}${saved ? ` ${theme.symbols.middot} saved for profile ${services.profileName}` : ""}`
+      });
+      if (state.mode !== "employer") warnIfUnavailable(next);
+    },
+    [session, services, state.capabilities, state.mode, warnIfUnavailable]
+  );
+  return useCallback(
+    (name, arg) => {
+      switch (name) {
+        case "new":
+          session.dispatch({ type: "new-thread" });
+          session.dispatch({ type: "notice", tone: "info", text: `New chat ${theme.symbols.middot} ${state.mode}` });
+          return;
+        case "threads":
+          openThreads();
+          return;
+        case "mode": {
+          const mode = parseMode(arg);
+          if (!mode) session.dispatch({ type: "notice", tone: "error", text: "Use /mode seeker or /mode employer" });
+          else {
+            session.dispatch({ type: "set-mode", mode });
+            session.dispatch({ type: "notice", tone: "info", text: `Mode ${mode} ${theme.symbols.middot} new chat` });
+          }
+          return;
+        }
+        case "model": {
+          if (!arg) {
+            const current = state.modelId ?? "auto";
+            services.listModels({ mode: state.mode, companyId }).then(({ models }) => {
+              const list = models.map((m) => `${m.id === current ? `${theme.symbols.pointer} ` : "  "}${m.id}  ${m.displayName}${m.locked ? ` (${m.minimumTier} plan)` : ""}`);
+              session.dispatch({ type: "notice", tone: "info", text: [`Model: ${current} \xB7 /model <id> to switch`, ...list].join("\n") });
+            }).catch(() => session.dispatch({ type: "notice", tone: "info", text: `Model: ${current} ${theme.symbols.middot} /model <id> or /model auto` }));
+            return;
+          }
+          const modelId = arg === "auto" ? void 0 : arg;
+          session.dispatch({ type: "set-model", modelId });
+          session.dispatch({ type: "notice", tone: "info", text: `Model ${modelId ?? "auto"} for the next messages` });
+          return;
+        }
+        case "research":
+        case "image":
+        case "result":
+          setCapability(name, arg);
+          return;
+        case "help":
+          session.dispatch({ type: "notice", tone: "info", text: CHAT_HELP });
+          return;
+        case "home":
+          onExit(hostedByHome ? "home" : "exit");
+          return;
+        case "exit":
+        case "quit":
+          onExit("exit");
+          return;
+        default:
+          session.dispatch({ type: "notice", tone: "error", text: `Unknown command /${name}`, hint: "Type / to see the commands." });
+      }
+    },
+    [session, state.mode, state.modelId, openThreads, onExit, hostedByHome, services, companyId, setCapability]
+  );
+}
+
+// src/ui/screens/chat/useChatSession.ts
+import { useCallback as useCallback2, useEffect as useEffect4, useReducer as useReducer2, useRef as useRef3, useState as useState3 } from "react";
+
+// src/ui/screens/chat/useArtifactFollowUp.ts
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+var FOLLOW_TIMEOUT_MS = 5 * 6e4;
+function liveArtifacts(state) {
+  const items = state.turn?.items ?? [];
+  return items.flatMap((item) => item.kind === "tool" && item.call.artifact ? [item.call.artifact] : []);
+}
+function useArtifactFollowUp(state, dispatch, services) {
+  const followed = useRef2(/* @__PURE__ */ new Map());
+  const alive = useRef2(true);
+  useEffect3(
+    () => () => {
+      alive.current = false;
+    },
+    []
+  );
+  const cards = liveArtifacts(state);
+  const key = cards.map((c) => `${c.id}:${c.status}:${c.linkPending ? 1 : 0}:${c.released ? 1 : 0}`).join("|");
+  useEffect3(() => {
+    const send = (action) => {
+      if (alive.current) dispatch(action);
+    };
+    const mintLink = async (card) => {
+      try {
+        const url = services.artifactPreviewUrl ? await services.artifactPreviewUrl(card.id, card.kind) : void 0;
+        send({ type: "artifact-status", artifactId: card.id, ...url ? { previewUrl: url } : {} });
+      } catch {
+        send({ type: "artifact-status", artifactId: card.id });
+      }
+    };
+    for (const card of cards) {
+      if (card.released) continue;
+      const task = followed.current.get(card.id);
+      if (card.status === "pending" && task !== "poll") {
+        followed.current.set(card.id, "poll");
+        const getArtifact2 = services.getArtifact;
+        if (!getArtifact2) {
+          send({ type: "artifact-status", artifactId: card.id, release: true });
+          continue;
+        }
+        void (async () => {
+          try {
+            const { artifact, timedOut } = await waitForArtifact(() => getArtifact2(card.id), { timeoutMs: FOLLOW_TIMEOUT_MS });
+            if (!artifact || timedOut) {
+              send({ type: "artifact-status", artifactId: card.id, release: true });
+              return;
+            }
+            const url = artifact.status === "ready" && services.hyperlinks && services.artifactPreviewUrl ? await services.artifactPreviewUrl(card.id, card.kind).catch(() => void 0) : void 0;
+            send({
+              type: "artifact-status",
+              artifactId: card.id,
+              status: artifact.status,
+              title: artifact.title,
+              ...url ? { previewUrl: url } : {},
+              ...artifact.error ? { failure: artifact.error } : {}
+            });
+          } catch {
+            send({ type: "artifact-status", artifactId: card.id, release: true });
+          }
+        })();
+      } else if (card.status === "ready" && card.linkPending && !task) {
+        followed.current.set(card.id, "link");
+        void mintLink(card);
+      }
+    }
+  }, [key, dispatch, services]);
+}
+
+// src/ui/screens/chat/useChatSession.ts
+var FLUSH_INTERVAL_MS = 50;
+var HISTORY_LIMIT = 20;
+function useChatSession(opts) {
+  const { services, companyId } = opts;
+  const [state, dispatch] = useReducer2(
+    chatReducer,
+    opts,
+    (o) => initialChatState({
+      mode: o.mode,
+      threadId: o.threadId,
+      modelId: o.modelId,
+      capabilities: o.capabilities ?? o.services.capabilityPrefs ?? DEFAULT_CAPABILITIES,
+      links: Boolean(o.services.hyperlinks)
+    })
+  );
+  const stateRef = useRef3(state);
+  stateRef.current = state;
+  const buffer = useRef3([]);
+  const abortRef = useRef3(null);
+  const mounted = useRef3(true);
+  const [queue, setQueue] = useState3([]);
+  const [deciding, setDeciding] = useState3(null);
+  const [loading, setLoading] = useState3(
+    opts.threadId ? { label: "Loading the thread\u2026", since: Date.now() } : null
+  );
+  const flush = useCallback2(() => {
+    const events = buffer.current.splice(0);
+    for (const event of events) dispatch(event);
+  }, []);
+  useEffect4(() => {
+    if (!state.streaming) return void 0;
+    const id = setInterval(() => {
+      flush();
+      dispatch({ type: "tick" });
+    }, FLUSH_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, [state.streaming, flush]);
+  useEffect4(
+    () => () => {
+      mounted.current = false;
+      abortRef.current?.abort();
+    },
+    []
+  );
+  const send = useCallback2(
+    (text) => {
+      const message = text.trim();
+      if (!message) return;
+      if (stateRef.current.streaming) {
+        setQueue((q) => [...q, message]);
+        return;
+      }
+      dispatch({ type: "submit", text: message, at: Date.now() });
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const { mode, threadId, modelId, capabilities } = stateRef.current;
+      void (async () => {
+        try {
+          const request = { mode, message, threadId, modelId, companyId, ...capabilityRequestFields(mode, capabilities) };
+          const stream = services.streamChat(request, controller.signal);
+          for await (const event of stream) buffer.current.push({ ...event, at: Date.now() });
+          if (!mounted.current) return;
+          flush();
+          dispatch({ type: "tick" });
+        } catch (error) {
+          if (!mounted.current) return;
+          flush();
+          const cancelled = controller.signal.aborted || isCliError(error) && error.exitCode === 130;
+          const cli = toCliError(error);
+          dispatch({
+            type: "stream-failed",
+            message: cancelled ? "Stopped" : cli.message,
+            hint: cancelled ? void 0 : cli.hint,
+            cancelled,
+            at: Date.now()
+          });
+        } finally {
+          if (abortRef.current === controller) abortRef.current = null;
+        }
+      })();
+    },
+    [services, companyId, flush]
+  );
+  const interrupt = useCallback2(() => {
+    if (!abortRef.current) return false;
+    abortRef.current.abort();
+    return true;
+  }, []);
+  useEffect4(() => {
+    if (state.streaming || state.approvals.length > 0 || queue.length === 0) return;
+    const [next, ...rest] = queue;
+    setQueue(rest);
+    if (next) send(next);
+  }, [state.streaming, state.approvals.length, queue, send]);
+  const decide = useCallback2(
+    async (approval, decision) => {
+      if (decision === "leave") {
+        dispatch({ type: "approval-decided", approvalId: approval.approvalId, decision, at: Date.now() });
+        return;
+      }
+      setDeciding(decision);
+      try {
+        const data = await services.decideApproval(approval.approvalId, decision, { mode: stateRef.current.mode, companyId });
+        if (!mounted.current) return;
+        dispatch({ type: "approval-decided", approvalId: approval.approvalId, decision, text: data.assistant?.text, at: Date.now() });
+      } catch (error) {
+        if (!mounted.current) return;
+        const cli = toCliError(error);
+        dispatch({
+          type: "approval-decided",
+          approvalId: approval.approvalId,
+          decision,
+          error: cli.hint ? `${cli.message}. ${cli.hint}` : cli.message,
+          at: Date.now()
+        });
+      } finally {
+        if (mounted.current) setDeciding(null);
+      }
+    },
+    [services, companyId]
+  );
+  const resume = useCallback2(
+    async (threadId, title) => {
+      setLoading({ label: "Loading the thread\u2026", since: Date.now() });
+      try {
+        const data = await services.getThreadMessages(threadId, { mode: stateRef.current.mode, companyId });
+        if (!mounted.current) return;
+        const messages = data.messages.map((m) => ({ role: m.role, text: messageText(m.content) })).filter((m) => m.text.trim()).slice(-HISTORY_LIMIT);
+        dispatch({ type: "notice", tone: "info", text: `Resumed ${title ? `\u201C${title}\u201D` : "thread"} \xB7 last ${messages.length} messages` });
+        dispatch({ type: "history", threadId, messages });
+      } catch (error) {
+        if (!mounted.current) return;
+        const cli = toCliError(error);
+        dispatch({ type: "notice", tone: "error", text: `Could not load the thread: ${cli.message}`, hint: cli.hint });
+      } finally {
+        if (mounted.current) setLoading(null);
+      }
+    },
+    [services, companyId]
+  );
+  const booted = useRef3(false);
+  useEffect4(() => {
+    if (booted.current) return;
+    booted.current = true;
+    void (async () => {
+      if (opts.threadId) await resume(opts.threadId);
+      if (opts.initialMessage && mounted.current) send(opts.initialMessage);
+    })();
+  }, [opts.threadId, opts.initialMessage, resume, send]);
+  useArtifactFollowUp(state, dispatch, services);
+  return { state, dispatch, send, interrupt, decide, deciding, queue, setQueue, resume, loading };
+}
+
+// src/ui/screens/chat/Chat.tsx
+import { jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+var DOUBLE_PRESS_MS = 2e3;
+var ChatStatus = memo14(function ChatStatus2(props) {
+  useClockTick(props.since !== null);
+  const elapsed = props.since !== null ? formatElapsed(Date.now() - props.since) : null;
+  const hints = props.approval ? [
+    { key: "y", label: "approve" },
+    { key: "n", label: "reject" },
+    { key: "l", label: "later" }
+  ] : props.streaming ? [
+    { key: "enter", label: "queue" },
+    { key: "esc", label: "interrupt" },
+    { key: "/", label: "commands" }
+  ] : [
+    { key: "enter", label: "send" },
+    { key: "/", label: "commands" },
+    { key: "ctrl+c", label: "quit" }
+  ];
+  return /* @__PURE__ */ jsx16(StatusBar, { width: props.width, segments: [...props.segments, elapsed], hints });
+});
+function Chat(props) {
+  const { services, width, height, hostedByHome = false, onExit } = props;
+  const gutter = pageMargin(useTerminalSize().columns);
+  const session = useChatSession(props);
+  const { state } = session;
+  const [editor, dispatchEditor] = useReducer3(editorReducer, emptyEditor);
+  const [paletteIndex, setPaletteIndex] = useState4(0);
+  const [overlay, setOverlay] = useState4(null);
+  const [expandTools, setExpandTools] = useState4(false);
+  const [hint, setHint] = useState4(null);
+  const lastCtrlC = useRef4(0);
+  const lastEsc = useRef4(0);
+  const commands = useMemo4(() => chatCommands({ hostedByHome }), [hostedByHome]);
+  const commandMatches = overlay ? [] : paletteMatches(commands, editor.value);
+  const argMatches = overlay || commandMatches.length ? [] : paletteArgMatches(commands, editor.value);
+  const matches = commandMatches.length ? commandMatches : argMatches;
+  const selected = Math.min(paletteIndex, Math.max(0, matches.length - 1));
+  const approval = !state.streaming ? state.approvals[0] : void 0;
+  const composerActive = !overlay && !approval;
+  const [header] = useState4(() => ({
+    kind: "header",
+    id: "chat-header",
+    text: `${theme.bold("Chat")} ${theme.dim(`${theme.symbols.middot} ${props.mode}${props.threadId ? ` ${theme.symbols.middot} resumed` : ""}`)}`,
+    right: `profile ${services.profileName}`
+  }));
+  const staticItems = useMemo4(() => [header, ...state.entries], [header, state.entries]);
+  useEffect5(() => {
+    if (!hint) return void 0;
+    const timer = setTimeout(() => setHint(null), DOUBLE_PRESS_MS);
+    return () => clearTimeout(timer);
+  }, [hint]);
+  const openThreads = useCallback3(() => {
+    setOverlay({ kind: "threads", since: Date.now() });
+    services.listThreads({ mode: state.mode, companyId: props.companyId }).then((threads) => setOverlay((o) => o ? { ...o, threads } : o)).catch((error) => setOverlay((o) => o ? { ...o, error: toCliError(error).message } : o));
+  }, [services, state.mode, props.companyId]);
+  const runCommand = useChatCommands({ session, services, companyId: props.companyId, hostedByHome, onExit, openThreads });
+  const submit2 = useCallback3(
+    (value) => {
+      const text = value.trim();
+      if (!text) return;
+      const slash = parseSlash(text);
+      if (slash) {
+        const exact = commands.find((c) => c.name === slash.name);
+        const choice = exact ?? commandMatches[selected];
+        const picked = exact?.args ? argMatches[selected]?.completion : void 0;
+        if (choice?.args && !slash.arg && !picked) {
+          dispatchEditor({ type: "set", value: `/${choice.name} ` });
+          setPaletteIndex(0);
+          return;
+        }
+        let arg = exact ? slash.arg : "";
+        const known = exact?.args?.some((a) => a.value === arg.toLowerCase());
+        if (exact?.args && !known && picked) arg = parseSlash(picked)?.arg ?? arg;
+        dispatchEditor({ type: "remember", value: text });
+        dispatchEditor({ type: "clear" });
+        setPaletteIndex(0);
+        runCommand(choice?.name ?? slash.name, arg);
+        return;
+      }
+      dispatchEditor({ type: "remember", value: text });
+      dispatchEditor({ type: "clear" });
+      session.send(text);
+    },
+    [commandMatches, argMatches, selected, commands, runCommand, session]
+  );
+  const onCtrlC = useCallback3(() => {
+    const now = Date.now();
+    if (now - lastCtrlC.current < DOUBLE_PRESS_MS) {
+      session.interrupt();
+      onExit("exit");
+      return;
+    }
+    lastCtrlC.current = now;
+    if (session.interrupt()) setHint("Stopped. Press ctrl+c again to quit.");
+    else {
+      if (editor.value) dispatchEditor({ type: "clear" });
+      setHint("Press ctrl+c again to quit.");
+    }
+  }, [session, onExit, editor.value]);
+  useInput5((input, key) => {
+    if (key.ctrl && input === "c") onCtrlC();
+  });
+  const onComposerKey = useCallback3(
+    (input, key) => {
+      if (key.ctrl && input === "c") return true;
+      if (matches.length > 0) {
+        if (key.upArrow || key.downArrow) {
+          setPaletteIndex((i) => key.upArrow ? Math.max(0, i - 1) : Math.min(matches.length - 1, i + 1));
+          return true;
+        }
+        if (key.tab) {
+          const choice = matches[selected];
+          if (choice?.completion) dispatchEditor({ type: "set", value: choice.completion });
+          else if (choice) dispatchEditor({ type: "set", value: `/${choice.name}${choice.usage ? " " : ""}` });
+          setPaletteIndex(0);
+          return true;
+        }
+      }
+      if (key.escape) {
+        if (session.interrupt()) return true;
+        const now = Date.now();
+        if (!editor.value) {
+          if (hostedByHome) onExit("home");
+          else setHint("Type /exit or press ctrl+c twice to quit.");
+        } else if (matches.length > 0 || now - lastEsc.current < 600) dispatchEditor({ type: "clear" });
+        lastEsc.current = now;
+        return true;
+      }
+      if (key.tab && key.shift) {
+        if (!state.streaming) runCommand("mode", state.mode === "seeker" ? "employer" : "seeker");
+        return true;
+      }
+      if (key.ctrl && input === "o") {
+        const liveTools = state.turn?.items.some((item) => item.kind === "tool");
+        if (liveTools) setExpandTools((v) => !v);
+        else session.dispatch({ type: "expand-last-tool" });
+        return true;
+      }
+      return false;
+    },
+    [matches, selected, session, editor.value, state.streaming, state.mode, state.turn, runCommand, hostedByHome, onExit]
+  );
+  const cardRows = approval ? 14 + Math.min(9, Object.keys(approval.args).length) : 0;
+  const fixedRows = 4 + 1 + (hint ? 1 : 0) + session.queue.length + (matches.length ? Math.min(6, matches.length) : 0) + (overlay ? 12 : 0) + cardRows + 2;
+  const liveBudget = Math.max(3, height - fixedRows - 1);
+  const placeholder = approval ? "Decide the approval above first" : state.streaming ? `Queue a follow-up${theme.symbols.ellipsis} (esc to interrupt)` : "Ask Tabbio anything, or / for commands";
+  const segments = [
+    `profile ${services.profileName}`,
+    state.mode,
+    state.modelId ?? "auto",
+    ...capabilitySegments(state.mode, state.capabilities),
+    state.threadId ? shortId(state.threadId, 6, 3) : "new chat"
+  ];
+  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx16(Static, { items: staticItems, children: (item) => /* @__PURE__ */ jsx16(Box15, { paddingLeft: gutter, children: /* @__PURE__ */ jsx16(EntryView, { entry: item, width }) }, item.id) }),
+    state.turn ? /* @__PURE__ */ jsx16(LiveTurn, { turn: state.turn, width, expandTools, maxLines: liveBudget, streaming: state.streaming }) : null,
+    session.loading ? /* @__PURE__ */ jsx16(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx16(Working, { label: session.loading.label, since: session.loading.since }) }) : null,
+    approval ? /* @__PURE__ */ jsx16(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx16(
+      ApprovalCard,
+      {
+        approvalId: approval.approvalId,
+        title: approval.title,
+        args: approval.args,
+        destructive: isDestructiveTool(approval.name),
+        context: `Writes to your account ${theme.symbols.middot} profile ${services.profileName}`,
+        busy: session.deciding,
+        isActive: !session.deciding && !overlay,
+        width,
+        onDecision: (decision) => void session.decide(approval, decision)
+      }
+    ) }) : null,
+    overlay ? /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx16(Text15, { children: theme.bold("Recent chats") }),
+      overlay.error ? /* @__PURE__ */ jsx16(Text15, { children: theme.error(`${theme.symbols.error} ${overlay.error}`) }) : !overlay.threads ? /* @__PURE__ */ jsx16(Working, { label: "Loading chats\u2026", since: overlay.since }) : /* @__PURE__ */ jsx16(
+        SelectList,
+        {
+          items: overlay.threads.map((t) => ({
+            id: t.id,
+            label: t.title?.trim() || "Untitled chat",
+            meta: relativeTime(new Date(t.lastMessageAt ?? t.updatedAt))
+          })),
+          width,
+          height: 8,
+          isActive: true,
+          emptyText: "No chats yet",
+          onSelect: (item) => {
+            setOverlay(null);
+            void session.resume(item.id, item.label);
+          },
+          onCancel: () => setOverlay(null)
+        }
+      ),
+      overlay.error || !overlay.threads ? /* @__PURE__ */ jsx16(SelectEscape, { onClose: () => setOverlay(null) }) : null
+    ] }) : null,
+    session.queue.map((queued, i) => /* @__PURE__ */ jsx16(Text15, { wrap: "truncate-end", children: theme.dim(`${theme.symbols.arrowRight} queued: ${queued}`) }, `q-${i}`)),
+    matches.length > 0 ? /* @__PURE__ */ jsx16(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx16(Palette, { commands: matches, selected, width }) }) : null,
+    /* @__PURE__ */ jsx16(Box15, { marginTop: matches.length > 0 ? 0 : 1, children: /* @__PURE__ */ jsx16(
+      TextInput,
+      {
+        editor,
+        dispatch: dispatchEditor,
+        onSubmit: submit2,
+        onKey: onComposerKey,
+        isActive: composerActive,
+        width,
+        placeholder,
+        boxed: true
+      }
+    ) }),
+    hint ? /* @__PURE__ */ jsx16(Text15, { children: theme.attention(hint) }) : null,
+    /* @__PURE__ */ jsx16(
+      ChatStatus,
+      {
+        width,
+        segments,
+        since: state.streaming && state.turn ? state.turn.startedAt : null,
+        streaming: state.streaming,
+        approval: Boolean(approval)
+      }
+    )
+  ] });
+}
+function capabilitySegments(mode, capabilities) {
+  if (mode === "employer") return [];
+  return ["research", "image", "result"].filter((key) => capabilities[key] !== DEFAULT_CAPABILITIES[key]).map((key) => `${key} ${capabilities[key]}`);
+}
+function SelectEscape({ onClose }) {
+  useInput5((input, key) => {
+    if (key.escape || input === "q") onClose();
+  });
+  return null;
+}
+
+// src/ui/screens/home/Home.tsx
+import { Box as Box24, Text as Text24, useInput as useInput10 } from "ink";
+import { useCallback as useCallback6, useEffect as useEffect8, useMemo as useMemo7, useReducer as useReducer4, useRef as useRef7, useState as useState9 } from "react";
+
+// src/ui/screens/Approvals.tsx
+import { Box as Box18, Text as Text18, useInput as useInput7 } from "ink";
+import { useCallback as useCallback4, useEffect as useEffect6, useRef as useRef5, useState as useState6 } from "react";
+
+// src/ui/screens/ResultPanel.tsx
+import { Box as Box17, Text as Text17, useInput as useInput6 } from "ink";
+import { useMemo as useMemo5, useState as useState5 } from "react";
+
+// src/ui/components/Panel.tsx
+import { Box as Box16, Text as Text16 } from "ink";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+var BORDER = {
+  round: { tl: "\u256D", tr: "\u256E", h: "\u2500" },
+  classic: { tl: "+", tr: "+", h: "-" }
+};
+function toneColor(tone) {
+  if (tone === "accent") return theme.accentInk;
+  if (tone === "success") return "green";
+  if (tone === "danger") return "red";
+  if (tone === "attention") return "yellow";
+  return void 0;
+}
+function paintBorder(tone, text) {
+  if (tone === "accent") return theme.accent(text);
+  if (tone === "success") return theme.success(text);
+  if (tone === "danger") return theme.danger(text);
+  if (tone === "attention") return theme.attention(text);
+  return theme.dim(text);
+}
+function panelTopLine(width, title = "", right = "", tone = "muted") {
+  const chars2 = BORDER[theme.boxStyle];
+  const inner = Math.max(0, width - 2);
+  const titleText2 = title ? ` ${title} ` : "";
+  let rightText = right ? ` ${right} ` : "";
+  if (2 + displayWidth(titleText2) + displayWidth(rightText) > inner) rightText = "";
+  const fittedTitle = titleText2 && 2 + displayWidth(titleText2) > inner ? ` ${truncate(title, Math.max(1, inner - 4))} ` : titleText2;
+  const used = 1 + displayWidth(fittedTitle) + displayWidth(rightText) + 1;
+  const fill = chars2.h.repeat(Math.max(0, inner - used));
+  return paintBorder(tone, `${chars2.tl}${chars2.h}`) + fittedTitle + paintBorder(tone, fill) + (rightText ? theme.dim(rightText) : "") + paintBorder(tone, `${chars2.h}${chars2.tr}`);
+}
+function Panel({
+  title,
+  right,
+  width,
+  tone = "muted",
+  children
+}) {
+  const color = toneColor(tone);
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx17(Text16, { children: panelTopLine(width, title, right, tone) }),
+    /* @__PURE__ */ jsx17(
+      Box16,
+      {
+        borderStyle: theme.boxStyle,
+        borderTop: false,
+        borderColor: color,
+        borderDimColor: tone === "muted",
+        paddingX: 1,
+        flexDirection: "column",
+        width,
+        children
+      }
+    )
+  ] });
+}
+
+// src/ui/result-model.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRowList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isRecord3);
+}
+function tableBody(rows, summary, now) {
+  const picked = pickColumns(rows);
+  const columns = picked.map((c) => ({ key: c.key, header: c.label, align: c.align }));
+  const cells = rows.map((row) => {
+    const record = {};
+    for (const column of picked) record[column.key] = humanCell(getPath(row, column.key), now);
+    return record;
+  });
+  return { kind: "table", columns, rows: cells, total: rows.length, summary };
+}
+function kvValue(value, now) {
+  if (Array.isArray(value) && value.some((v) => typeof v === "object" && v !== null)) {
+    return `${value.length} item${value.length === 1 ? "" : "s"}`;
+  }
+  if (isRecord3(value)) {
+    const json = safeJson(value, 0);
+    return json.length > 100 ? `${json.slice(0, 99)}\u2026` : json;
+  }
+  return humanCell(value, now);
+}
+function describeResult(result, now = Date.now()) {
+  if (result === null || result === void 0 || result === "") return { kind: "empty" };
+  if (typeof result === "string") return { kind: "text", text: result };
+  if (typeof result !== "object") return { kind: "text", text: String(result) };
+  if (isRowList(result)) return tableBody(result, [], now);
+  if (Array.isArray(result)) {
+    return result.length === 0 ? { kind: "empty" } : { kind: "text", text: result.map((v) => humanCell(v, now)).join("\n") };
+  }
+  const wrapper = findListWrapper(result);
+  if (wrapper) {
+    const summary = Object.entries(result).filter(([key, value]) => key !== wrapper.key && (typeof value !== "object" || value === null) && value !== void 0).map(([key, value]) => `${key} ${humanCell(value, now)}`);
+    if (wrapper.rows.length === 0) return { kind: "kv", rows: [{ label: wrapper.key, value: "none" }] };
+    return tableBody(wrapper.rows, summary, now);
+  }
+  const rows = Object.entries(result).filter(([, value]) => value !== void 0).map(([label, value]) => ({ label, value: kvValue(value, now) }));
+  return rows.length ? { kind: "kv", rows } : { kind: "empty" };
+}
+function bodyLength(body) {
+  switch (body.kind) {
+    case "table":
+      return body.rows.length;
+    case "kv":
+      return body.rows.length;
+    case "text":
+      return body.text.split("\n").length;
+    default:
+      return 1;
+  }
+}
+
+// src/ui/screens/ResultPanel.tsx
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+function summaryLine(body) {
+  switch (body.kind) {
+    case "table":
+      return [`${body.total} result${body.total === 1 ? "" : "s"}`, ...body.summary].join(` ${theme.symbols.middot} `);
+    case "kv":
+      return `${body.rows.length} field${body.rows.length === 1 ? "" : "s"}`;
+    case "text":
+      return "Text result";
+    default:
+      return "No output";
+  }
+}
+function ErrorBody({ error }) {
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", children: [
+    error.hint ? /* @__PURE__ */ jsx18(Text17, { wrap: "wrap", children: theme.dim(`${theme.symbols.arrowRight} ${error.hint}`) }) : null,
+    /* @__PURE__ */ jsx18(Text17, { children: theme.dim([error.requestId ? `request id ${error.requestId}` : null, `exit ${error.exitCode}`].filter(Boolean).join(` ${theme.symbols.middot} `)) })
+  ] });
+}
+function ResultPanel(props) {
+  const { title, result, error, durationMs, requestId, note, width, height, interactive } = props;
+  const body = useMemo5(() => describeResult(result), [result]);
+  const jsonLines = useMemo5(() => safeJson(result ?? null).split("\n"), [result]);
+  const [view, setView] = useState5("human");
+  const [offset, setOffset] = useState5(0);
+  const total = view === "json" ? jsonLines.length : bodyLength(body);
+  const chrome = 3 + (note ? 1 : 0) + 3;
+  const window = interactive ? Math.max(3, height - chrome - (body.kind === "table" ? 1 : 0)) : total;
+  const maxOffset = Math.max(0, total - window);
+  const clamped = Math.min(offset, maxOffset);
+  useInput6(
+    (input, key) => {
+      if (key.escape || input === "q") props.onBack?.();
+      else if (input === "j") {
+        setView((v) => v === "json" ? "human" : "json");
+        setOffset(0);
+      } else if (input === "r") props.onRerun?.();
+      else if (input === "e") props.onEdit?.();
+      else if (key.upArrow) setOffset((o) => Math.max(0, Math.min(o, maxOffset) - 1));
+      else if (key.downArrow) setOffset((o) => Math.min(maxOffset, o + 1));
+      else if (key.pageUp) setOffset((o) => Math.max(0, Math.min(o, maxOffset) - window));
+      else if (key.pageDown) setOffset((o) => Math.min(maxOffset, o + window));
+      else if (input === "g") setOffset(0);
+      else if (input === "G") setOffset(maxOffset);
+    },
+    { isActive: interactive }
+  );
+  const ok = !error;
+  const heading = `${ok ? theme.success(theme.symbols.success) : theme.error(theme.symbols.error)} ${theme.bold(title)}`;
+  const right = [formatElapsed(durationMs), requestId ? `req ${shortId(requestId, 4, 3)}` : null].filter(Boolean).join(` ${theme.symbols.middot} `);
+  const inner = Math.max(10, width - 4);
+  const hints = [
+    { key: "j", label: view === "json" ? "table" : "json" },
+    ...props.onRerun ? [{ key: "r", label: "re-run" }] : [],
+    ...props.onEdit ? [{ key: "e", label: "edit input" }] : [],
+    ...total > window ? [{ key: theme.symbols.upDown, label: "scroll" }] : [],
+    { key: "q", label: "back" }
+  ];
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx18(Panel, { title: heading, right, width, tone: ok ? "muted" : "danger", children: /* @__PURE__ */ jsx18(Text17, { wrap: "truncate-end", children: error ? theme.error(error.message) : theme.dim(summaryLine(body)) }) }),
+    note ? /* @__PURE__ */ jsx18(Text17, { wrap: "truncate-end", children: note }) : null,
+    /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", paddingLeft: 2, width, children: [
+      error ? /* @__PURE__ */ jsx18(ErrorBody, { error }) : view === "json" ? jsonLines.slice(clamped, clamped + window).map((line, i) => /* @__PURE__ */ jsx18(Text17, { wrap: "truncate-end", children: line }, clamped + i)) : body.kind === "table" ? /* @__PURE__ */ jsx18(Table, { columns: body.columns, rows: body.rows, width: inner, offset: clamped, limit: window }) : body.kind === "kv" ? /* @__PURE__ */ jsx18(KeyValue, { rows: body.rows.slice(clamped, clamped + window), width: inner }) : body.kind === "text" ? interactive ? body.text.split("\n").slice(clamped, clamped + window).map((line, i) => /* @__PURE__ */ jsx18(Text17, { wrap: "truncate-end", children: line }, clamped + i)) : /* @__PURE__ */ jsx18(Markdown, { text: body.text, width: inner }) : /* @__PURE__ */ jsx18(Text17, { children: theme.dim("No output") }),
+      interactive && total > window ? /* @__PURE__ */ jsx18(Text17, { children: theme.dim(`${clamped + 1}\u2013${Math.min(total, clamped + window)} of ${total}`) }) : null
+    ] }),
+    interactive ? /* @__PURE__ */ jsx18(Box17, { marginTop: 1, children: /* @__PURE__ */ jsx18(KeyHints, { width, hints }) }) : null
+  ] });
+}
+
+// src/ui/screens/Approvals.tsx
+import { jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
+function argsOf(item) {
+  return typeof item.args === "object" && item.args !== null && !Array.isArray(item.args) ? item.args : {};
+}
+function Approvals({ services, width, height, onExit }) {
+  const [phase, setPhase] = useState6({ name: "loading", since: Date.now() });
+  const mounted = useRef5(true);
+  useEffect6(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  const load = useCallback4(async () => {
+    if (!services.account.hasSession) {
+      setPhase({ name: "failed", message: "Approvals need a full sign-in", hint: "Run `tabbio login`; a personal MCP token cannot approve." });
+      return;
+    }
+    setPhase({ name: "loading", since: Date.now() });
+    try {
+      const items = await services.loadPendingApprovals();
+      if (mounted.current) setPhase({ name: "list", items });
+    } catch (error) {
+      const cli = toCliError(error);
+      if (mounted.current) setPhase({ name: "failed", message: cli.message, hint: cli.hint });
+    }
+  }, [services]);
+  useEffect6(() => {
+    void load();
+  }, [load]);
+  const decide = useCallback4(
+    async (decision) => {
+      if (phase.name !== "card") return;
+      if (decision === "leave") {
+        setPhase({ name: "list", items: phase.items });
+        return;
+      }
+      setPhase({ ...phase, busy: decision, error: null });
+      try {
+        const data = await services.decideApproval(phase.item.id, decision);
+        if (!mounted.current) return;
+        setPhase({
+          name: "done",
+          item: phase.item,
+          decision,
+          result: decision === "approve" ? data.mcp?.result ?? data.assistant?.text ?? null : null,
+          durationMs: Date.now() - phase.shownAt
+        });
+      } catch (error) {
+        if (mounted.current) setPhase({ ...phase, busy: null, error: toCliError(error).message });
+      }
+    },
+    [phase, services]
+  );
+  useInput7(
+    (input, key) => {
+      if (phase.name === "done" && phase.decision !== "approve" && (key.return || key.escape || input === "q")) void load();
+      else if (phase.name === "failed" && (key.escape || input === "q" || key.return)) onExit();
+      else if (phase.name === "loading" && (key.escape || input === "q")) onExit();
+    },
+    { isActive: phase.name === "done" && phase.decision !== "approve" || phase.name === "failed" || phase.name === "loading" }
+  );
+  const count = phase.name === "list" || phase.name === "card" ? phase.items.length : null;
+  const header = /* @__PURE__ */ jsx19(Box18, { marginBottom: 1, children: /* @__PURE__ */ jsxs17(Text18, { children: [
+    theme.bold("Approvals"),
+    count !== null ? theme.dim(` ${theme.symbols.middot} ${count} waiting`) : ""
+  ] }) });
+  switch (phase.name) {
+    case "loading":
+      return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx19(Working, { label: "Loading approvals\u2026", since: phase.since })
+      ] });
+    case "failed":
+      return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx19(Text18, { children: theme.error(`${theme.symbols.error} ${phase.message}`) }),
+        phase.hint ? /* @__PURE__ */ jsx19(Text18, { wrap: "wrap", children: theme.dim(`  ${theme.symbols.arrowRight} ${phase.hint}`) }) : null,
+        /* @__PURE__ */ jsx19(Box18, { marginTop: 1, children: /* @__PURE__ */ jsx19(KeyHints, { width, hints: [{ key: "q", label: "back" }] }) })
+      ] });
+    case "list":
+      return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx19(
+          SelectList,
+          {
+            items: phase.items.map((item) => ({
+              id: item.id,
+              label: `${theme.symbols.attention} ${sentenceCase(item.toolName)}`,
+              description: summarizeArgs(argsOf(item), 40),
+              meta: `${relativeTime(new Date(item.createdAt))}  ${shortId(item.id)}`
+            })),
+            width,
+            height: Math.max(3, height - 5),
+            isActive: true,
+            emptyText: "No approvals waiting",
+            onSelect: (selected) => {
+              const item = phase.items.find((i) => i.id === selected.id);
+              if (item) setPhase({ name: "card", items: phase.items, item, shownAt: Date.now(), busy: null, error: null });
+            },
+            onCancel: onExit
+          }
+        )
+      ] });
+    case "card":
+      return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx19(
+          ApprovalCard,
+          {
+            approvalId: phase.item.id,
+            title: sentenceCase(phase.item.toolName),
+            args: argsOf(phase.item),
+            destructive: isDestructiveTool(phase.item.toolName),
+            context: `Requested over MCP ${theme.symbols.middot} ${relativeTime(new Date(phase.item.createdAt))} ${theme.symbols.middot} profile ${services.profileName}`,
+            busy: phase.busy,
+            error: phase.error,
+            isActive: !phase.busy,
+            width,
+            onDecision: (decision) => void decide(decision)
+          }
+        )
+      ] });
+    case "done":
+      return /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, children: [
+        header,
+        phase.decision === "approve" ? /* @__PURE__ */ jsx19(
+          ResultPanel,
+          {
+            title: sentenceCase(phase.item.toolName),
+            result: phase.result,
+            durationMs: phase.durationMs,
+            note: approvalOutcomeText("approve", sentenceCase(phase.item.toolName), phase.item.id, phase.durationMs),
+            width,
+            height: Math.max(6, height - 2),
+            interactive: true,
+            onBack: () => void load()
+          }
+        ) : /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsx19(Text18, { children: approvalOutcomeText(phase.decision, sentenceCase(phase.item.toolName), phase.item.id, phase.durationMs) }),
+          /* @__PURE__ */ jsx19(Box18, { marginTop: 1, children: /* @__PURE__ */ jsx19(KeyHints, { width, hints: [{ key: "enter", label: "back to approvals" }] }) })
+        ] })
+      ] });
+  }
+}
+
+// src/ui/screens/ToolBrowser.tsx
+import { Box as Box20, Text as Text20, useInput as useInput9 } from "ink";
+import { memo as memo15, useMemo as useMemo6, useState as useState8 } from "react";
+
+// src/ui/screens/ToolRun.tsx
+import { Box as Box19, Text as Text19, useInput as useInput8 } from "ink";
+import { useCallback as useCallback5, useEffect as useEffect7, useRef as useRef6, useState as useState7 } from "react";
+import { jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
+function toolLabel(tool) {
+  return tool.commandPath.join(" ") || tool.id;
+}
+function ToolRun({ tool, services, width, height, initialInput = {}, start, onExit }) {
+  const [phase, setPhase] = useState7({ name: "form", input: initialInput });
+  const mounted = useRef6(true);
+  const controller = useRef6(null);
+  useEffect7(
+    () => () => {
+      mounted.current = false;
+      controller.current?.abort();
+    },
+    []
+  );
+  const withDefaults = useCallback5(
+    (input) => autoFilledProperties(tool, tool.inputSchema).includes("userId") && input.userId === void 0 && services.account.userId ? { ...input, userId: services.account.userId } : input,
+    [tool, services.account.userId]
+  );
+  const run = useCallback5(
+    async (input) => {
+      const startedAt = Date.now();
+      controller.current?.abort();
+      const abort = new AbortController();
+      controller.current = abort;
+      setPhase({ name: "running", input, startedAt });
+      try {
+        const outcome = await services.callTool(tool.id, withDefaults(input), { signal: abort.signal });
+        if (!mounted.current || abort.signal.aborted) return;
+        if (!outcome.ok) setPhase({ name: "error", input, error: outcome.error, durationMs: outcome.durationMs });
+        else if (outcome.approval) {
+          setPhase(
+            services.account.hasSession ? { name: "approval", input, approval: outcome.approval, requestedAt: Date.now(), busy: null, error: null } : { name: "left", input, approval: outcome.approval }
+          );
+        } else setPhase({ name: "result", input, result: outcome.result, durationMs: outcome.durationMs, requestId: outcome.requestId });
+      } catch (error) {
+        if (!mounted.current || abort.signal.aborted) return;
+        setPhase({ name: "error", input, error: toCliError(error), durationMs: Date.now() - startedAt });
+      }
+    },
+    [services, tool.id, withDefaults]
+  );
+  const started = useRef6(false);
+  useEffect7(() => {
+    if (started.current || start !== "run") return;
+    started.current = true;
+    void run(initialInput);
+  }, [start, run, initialInput]);
+  const decide = useCallback5(
+    async (decision) => {
+      if (phase.name !== "approval") return;
+      const { approval, input, requestedAt } = phase;
+      const title = sentenceCase(approval.toolName || tool.title);
+      if (decision === "leave") {
+        setPhase({ name: "left", input, approval });
+        return;
+      }
+      setPhase({ ...phase, busy: decision, error: null });
+      try {
+        const data = await services.decideApproval(approval.approvalId, decision);
+        if (!mounted.current) return;
+        setPhase({
+          name: "result",
+          input,
+          result: decision === "approve" ? data.mcp?.result ?? data.assistant?.text ?? null : null,
+          durationMs: Date.now() - requestedAt,
+          note: approvalOutcomeText(decision, title, approval.approvalId, Date.now() - requestedAt)
+        });
+      } catch (error) {
+        if (!mounted.current) return;
+        setPhase({ ...phase, busy: null, error: toCliError(error).message });
+      }
+    },
+    [phase, services, tool.title]
+  );
+  useInput8(
+    (input, key) => {
+      if (phase.name === "running" && key.escape) {
+        controller.current?.abort();
+        setPhase({ name: "form", input: phase.input });
+      } else if (phase.name === "error" || phase.name === "left") {
+        if (key.escape || input === "q") onExit();
+        else if (input === "r") void run(phase.input);
+        else if (input === "e") setPhase({ name: "form", input: phase.input });
+      }
+    },
+    { isActive: phase.name === "running" || phase.name === "error" || phase.name === "left" }
+  );
+  const label = toolLabel(tool);
+  const header = /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs18(Text19, { wrap: "truncate-end", children: [
+      theme.bold(label),
+      " ",
+      theme.dim(`${theme.symbols.middot} ${oneLine(tool.title)}`)
+    ] }),
+    tool.description ? /* @__PURE__ */ jsx20(Text19, { wrap: "truncate-end", children: theme.dim(oneLine(tool.description)) }) : null
+  ] });
+  switch (phase.name) {
+    case "form":
+      return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx20(
+          Form,
+          {
+            initial: createFormState(tool.inputSchema, phase.input, { skip: autoFilledProperties(tool, tool.inputSchema) }),
+            width,
+            height: Math.max(3, height - 6),
+            isActive: true,
+            onSubmit: (input) => void run(input),
+            onCancel: onExit
+          }
+        )
+      ] });
+    case "running":
+      return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx20(Working, { label: `Running ${label}${theme.symbols.ellipsis}`, since: phase.startedAt }),
+        /* @__PURE__ */ jsx20(Box19, { marginTop: 1, children: /* @__PURE__ */ jsx20(KeyHints, { width, hints: [{ key: "esc", label: "cancel" }] }) })
+      ] });
+    case "approval":
+      return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx20(
+          ApprovalCard,
+          {
+            approvalId: phase.approval.approvalId,
+            title: sentenceCase(phase.approval.toolName || tool.title),
+            message: phase.approval.message,
+            args: withDefaults(phase.input),
+            destructive: isDestructiveTool(phase.approval.toolName || tool.id),
+            context: `Writes to your account ${theme.symbols.middot} profile ${services.profileName}`,
+            busy: phase.busy,
+            error: phase.error,
+            isActive: !phase.busy,
+            width,
+            onDecision: (decision) => void decide(decision)
+          }
+        )
+      ] });
+    case "result":
+      return /* @__PURE__ */ jsx20(
+        ResultPanel,
+        {
+          title: label,
+          result: phase.result,
+          durationMs: phase.durationMs,
+          requestId: phase.requestId,
+          note: phase.note,
+          width,
+          height,
+          interactive: true,
+          onBack: onExit,
+          onRerun: () => void run(phase.input),
+          onEdit: () => setPhase({ name: "form", input: phase.input })
+        }
+      );
+    case "error":
+      return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsx20(ResultPanel, { title: label, error: phase.error, durationMs: phase.durationMs, width, height, interactive: false }),
+        /* @__PURE__ */ jsx20(Box19, { marginTop: 1, children: /* @__PURE__ */ jsx20(KeyHints, { width, hints: [{ key: "r", label: "retry" }, { key: "e", label: "edit input" }, { key: "q", label: "back" }] }) })
+      ] });
+    case "left":
+      return /* @__PURE__ */ jsxs18(Box19, { flexDirection: "column", width, children: [
+        header,
+        /* @__PURE__ */ jsx20(Text19, { children: approvalOutcomeText("leave", sentenceCase(phase.approval.toolName || tool.title), phase.approval.approvalId) }),
+        /* @__PURE__ */ jsx20(Text19, { wrap: "wrap", children: theme.dim(
+          services.account.hasSession ? "Decide later in the Tabbio app or with `tabbio approvals`." : `Approve it in the Tabbio app, or run \`tabbio approvals wait ${shortId(phase.approval.approvalId, 12, 4)}\`.`
+        ) }),
+        /* @__PURE__ */ jsx20(Box19, { marginTop: 1, children: /* @__PURE__ */ jsx20(KeyHints, { width, hints: [{ key: "r", label: "run again" }, { key: "e", label: "edit input" }, { key: "q", label: "back" }] }) })
+      ] });
+  }
+}
+
+// src/ui/screens/tool-browser-model.ts
+function initialBrowserState(opts = {}) {
+  return { query: opts.query ?? "", cursor: 0, expanded: opts.group ? { [opts.group]: true } : {} };
+}
+function toolRank(tool, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return 0;
+  const group = tool.group.toLowerCase();
+  const path = tool.commandPath.join(" ").toLowerCase();
+  const id = tool.id.toLowerCase();
+  if (q === group || q === path || q === id) return 0;
+  if (group.startsWith(q) || tool.action.toLowerCase().startsWith(q) || path.startsWith(q) || id.startsWith(q)) return 1;
+  const ranks = [rankMatch(q, path), rankMatch(q, id), rankMatch(q, tool.title, tool.description)].filter(
+    (r) => r !== null
+  );
+  return ranks.length ? Math.max(2, Math.min(...ranks)) : null;
+}
+function browserRows(tools, state) {
+  const visible = tools.filter((t) => !t.hidden);
+  const groups = /* @__PURE__ */ new Map();
+  for (const tool of visible) {
+    const entry = groups.get(tool.group) ?? { total: 0, hits: [] };
+    entry.total += 1;
+    const rank = toolRank(tool, state.query);
+    if (rank !== null) entry.hits.push({ tool, rank });
+    groups.set(tool.group, entry);
+  }
+  const filtering = state.query.trim().length > 0;
+  const rows = [];
+  const best = (group) => Math.min(...groups.get(group)?.hits.map((h) => h.rank) ?? [Infinity]);
+  const names = [...groups.keys()].sort((a, b) => (filtering ? best(a) - best(b) : 0) || a.localeCompare(b));
+  for (const group of names) {
+    const entry = groups.get(group);
+    if (filtering && entry.hits.length === 0) continue;
+    const expanded = state.expanded[group] ?? filtering;
+    rows.push({ kind: "group", group, matched: entry.hits.length, total: entry.total, expanded });
+    if (!expanded) continue;
+    const hits = filtering ? [...entry.hits].sort((a, b) => a.rank - b.rank) : entry.hits;
+    for (const hit of hits) rows.push({ kind: "tool", tool: hit.tool, group });
+  }
+  return rows;
+}
+function browserReducer(state, action, rows) {
+  switch (action.type) {
+    case "type":
+      return { ...state, query: state.query + action.text, cursor: 0, expanded: {} };
+    case "backspace":
+      return { ...state, query: [...state.query].slice(0, -1).join(""), cursor: 0, expanded: {} };
+    case "clear":
+      return { ...state, query: "", cursor: 0, expanded: {} };
+    case "move":
+      return { ...state, cursor: Math.max(0, Math.min(rows.length - 1, state.cursor + action.delta)) };
+    case "fold": {
+      const row = rows[state.cursor];
+      if (!row) return state;
+      const group = row.group;
+      const expanded = { ...state.expanded, [group]: action.expand };
+      const groupIndex = rows.findIndex((r) => r.kind === "group" && r.group === group);
+      return { ...state, expanded, cursor: !action.expand && groupIndex >= 0 ? groupIndex : state.cursor };
+    }
+    default:
+      return state;
+  }
+}
+function applyBrowserAction(tools, state, action) {
+  const next = browserReducer(state, action, browserRows(tools, state));
+  if (action.type !== "type" && action.type !== "backspace" && action.type !== "clear") return next;
+  if (!next.query) return next;
+  const index = browserRows(tools, next).findIndex((row) => row.kind === "tool");
+  return index >= 0 ? { ...next, cursor: index } : next;
+}
+function browserKeyAction(state, input, key, rows) {
+  const row = rows[Math.min(state.cursor, rows.length - 1)];
+  if (key.upArrow) return { type: "move", delta: -1 };
+  if (key.downArrow) return { type: "move", delta: 1 };
+  if (key.pageUp) return { type: "move", delta: -10 };
+  if (key.pageDown) return { type: "move", delta: 10 };
+  if (key.leftArrow) return { type: "fold", expand: false };
+  if (key.rightArrow) return { type: "fold", expand: true };
+  if (key.return) {
+    if (!row) return null;
+    if (row.kind === "tool") return { type: "open", tool: row.tool };
+    return { type: "fold", expand: !row.expanded };
+  }
+  if (key.escape) return state.query ? { type: "clear" } : { type: "exit" };
+  if (key.backspace || key.delete) return { type: "backspace" };
+  if (key.ctrl && input === "u") return { type: "clear" };
+  if (key.ctrl || key.meta || key.tab) return null;
+  if (input === "q" && !state.query) return { type: "exit" };
+  return input ? { type: "type", text: input } : null;
+}
+
+// src/ui/screens/ToolBrowser.tsx
+import { jsx as jsx21, jsxs as jsxs19 } from "react/jsx-runtime";
+var TWO_PANE_MIN = fromTerminal(90);
+function badge(tool) {
+  if (tool.kind === "workflow") return theme.dim("workflow");
+  if (tool.kind === "agent") return theme.dim("agent");
+  if (tool.annotations.destructiveHint === true) return theme.danger("write");
+  return tool.readOnly ? theme.dim("read") : "write";
+}
+var ListRow = memo15(function ListRow2({ row, selected, width }) {
+  const pointer = selected ? theme.accent(theme.symbols.pointer) : " ";
+  if (row.kind === "group") {
+    const glyph2 = row.expanded ? theme.symbols.expanded : theme.symbols.collapsed;
+    const count = theme.dim(row.matched === row.total ? String(row.total) : `${row.matched} of ${row.total}`);
+    const name = truncate(row.group, Math.max(4, width - 12));
+    const fill = Math.max(1, width - 4 - displayWidth(name) - displayWidth(count));
+    return /* @__PURE__ */ jsxs19(Text20, { wrap: "truncate-end", children: [
+      pointer,
+      " ",
+      theme.dim(glyph2),
+      " ",
+      selected ? theme.accent(theme.bold(name)) : theme.bold(name),
+      " ".repeat(fill),
+      count
+    ] });
+  }
+  const label = row.tool.kind === "workflow" ? row.tool.action : row.tool.commandPath.join(" ");
+  const tag = badge(row.tool);
+  const labelWidth = Math.max(4, width - 4 - displayWidth(tag) - 1);
+  const text = padEnd(truncate(label, labelWidth), labelWidth);
+  return /* @__PURE__ */ jsxs19(Text20, { wrap: "truncate-end", children: [
+    pointer,
+    "   ",
+    selected ? theme.accent(text) : text,
+    " ",
+    tag
+  ] });
+});
+var ToolDetail = memo15(function ToolDetail2({ tool, width, height }) {
+  const flags = useMemo6(() => describeSchema(tool.inputSchema), [tool]);
+  const example = useMemo6(() => exampleInvocation(tool, tool.inputSchema), [tool]);
+  const flagWidth = Math.min(28, Math.max(8, ...flags.map((f) => displayWidth(`${f.flag} <${f.type}>`))));
+  const descLines = Math.max(1, Math.min(4, height - flags.length - 8));
+  const lines = wrapWords(tool.description, width, descLines);
+  const shownFlags = flags.slice(0, Math.max(1, height - 7 - lines.length));
+  return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs19(Box20, { width, children: [
+      /* @__PURE__ */ jsx21(Box20, { flexGrow: 1, children: /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: theme.bold(tool.commandPath.join(" ")) }) }),
+      /* @__PURE__ */ jsx21(Text20, { children: badge(tool) })
+    ] }),
+    /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: oneLine(tool.title) }),
+    /* @__PURE__ */ jsx21(Text20, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: theme.dim(line) }, i)),
+    /* @__PURE__ */ jsx21(Text20, { children: " " }),
+    /* @__PURE__ */ jsx21(Text20, { children: theme.dim("FLAGS") }),
+    flags.length === 0 ? /* @__PURE__ */ jsx21(Text20, { children: theme.dim("  none") }) : null,
+    shownFlags.map((flag) => /* @__PURE__ */ jsxs19(Text20, { wrap: "truncate-end", children: [
+      "  ",
+      padEnd(truncate(`${flag.flag} <${flag.type}>`, flagWidth), flagWidth),
+      " ",
+      flag.required ? theme.attention("required") : "        ",
+      " ",
+      theme.dim(flag.description)
+    ] }, flag.flag)),
+    flags.length > shownFlags.length ? /* @__PURE__ */ jsx21(Text20, { children: theme.dim(`  +${flags.length - shownFlags.length} more`) }) : null,
+    /* @__PURE__ */ jsx21(Text20, { children: " " }),
+    /* @__PURE__ */ jsx21(Text20, { children: theme.dim("EXAMPLE") }),
+    /* @__PURE__ */ jsxs19(Text20, { wrap: "truncate-end", children: [
+      "  ",
+      example
+    ] })
+  ] });
+});
+function ToolBrowser(props) {
+  const { tools, services, width, height, onExit } = props;
+  const [state, setState] = useState8(() => {
+    const initial = initialBrowserState({ query: props.initialQuery, group: props.initialGroup });
+    return initial.query ? applyBrowserAction(tools, { ...initial, query: "" }, { type: "type", text: initial.query }) : initial;
+  });
+  const [running, setRunning] = useState8(null);
+  const rows = useMemo6(() => browserRows(tools, state), [tools, state]);
+  const cursor = Math.min(state.cursor, Math.max(0, rows.length - 1));
+  const current = rows[cursor];
+  useInput9(
+    (input, key) => {
+      const outcome = browserKeyAction({ ...state, cursor }, input, key, rows);
+      if (!outcome) return;
+      if (outcome.type === "exit") onExit();
+      else if (outcome.type === "open") setRunning(outcome.tool);
+      else setState((s) => applyBrowserAction(tools, { ...s, cursor }, outcome));
+    },
+    { isActive: !running }
+  );
+  if (running) {
+    return /* @__PURE__ */ jsx21(ToolRun, { tool: running, services, width, height, start: "form", onExit: () => setRunning(null) });
+  }
+  const visibleCount = tools.filter((t) => !t.hidden).length;
+  const groupCount = new Set(tools.filter((t) => !t.hidden).map((t) => t.group)).size;
+  const twoPane = width >= TWO_PANE_MIN;
+  const leftWidth = twoPane ? Math.min(46, Math.floor(width * 0.42)) : width;
+  const rightWidth = width - leftWidth - 3;
+  const listHeight = Math.max(3, height - (twoPane ? 5 : 9));
+  const { start, end } = windowAround(rows.length, cursor, listHeight);
+  const filter = `${theme.dim("filter")} ${theme.accent(theme.symbols.pointer)} ${state.query}${theme.accent(theme.symbols.cursor)}`;
+  const title = `${theme.bold("Tools")} ${theme.dim(`${theme.symbols.middot} ${visibleCount} in ${groupCount} groups`)}`;
+  const rule = theme.dim(
+    twoPane ? `${theme.symbols.line.repeat(leftWidth + 1)}\u252C${theme.symbols.line.repeat(Math.max(0, rightWidth + 1))}` : theme.symbols.line.repeat(width)
+  );
+  const detailTool = current?.kind === "tool" ? current.tool : null;
+  return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsxs19(Box20, { width, children: [
+      /* @__PURE__ */ jsx21(Box20, { flexGrow: 1, children: /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: title }) }),
+      /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: filter })
+    ] }),
+    /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: theme.unicode ? rule : theme.dim("-".repeat(width)) }),
+    /* @__PURE__ */ jsxs19(Box20, { width, children: [
+      /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", width: leftWidth, children: [
+        rows.length === 0 ? /* @__PURE__ */ jsx21(Text20, { children: theme.dim(`  No tools match "${state.query}"`) }) : null,
+        rows.slice(start, end).map((row, i) => /* @__PURE__ */ jsx21(
+          ListRow,
+          {
+            row,
+            selected: start + i === cursor,
+            width: leftWidth
+          },
+          row.kind === "group" ? `g:${row.group}` : `t:${row.tool.id}`
+        ))
+      ] }),
+      twoPane ? /* @__PURE__ */ jsx21(Box20, { flexDirection: "column", marginLeft: 1, paddingLeft: 1, borderStyle: theme.unicode ? "single" : "classic", borderTop: false, borderRight: false, borderBottom: false, borderDimColor: true, width: rightWidth + 2, children: detailTool ? /* @__PURE__ */ jsx21(ToolDetail, { tool: detailTool, width: rightWidth, height: listHeight }) : /* @__PURE__ */ jsx21(Text20, { children: theme.dim(current?.kind === "group" ? `${current.group}: enter or \u2192 to open the group` : "Select a tool") }) }) : null
+    ] }),
+    !twoPane && detailTool ? /* @__PURE__ */ jsx21(Box20, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: theme.dim(oneLine(detailTool.description || detailTool.title)) }) }) : null,
+    /* @__PURE__ */ jsx21(Text20, { wrap: "truncate-end", children: theme.dim(theme.symbols.line.repeat(width)) }),
+    /* @__PURE__ */ jsx21(
+      KeyHints,
+      {
+        width,
+        hints: [
+          { key: theme.symbols.upDown, label: "move" },
+          { key: theme.symbols.leftRight, label: "fold" },
+          { key: "enter", label: "run" },
+          { key: "type", label: "filter" },
+          { key: "esc", label: state.query ? "clear" : "back" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/screens/home/home-model.ts
+var emptyHomeData = { plan: null, pendingApprovals: null, recent: null };
+function homeCommands(data, toolCount) {
+  const waiting = data.pendingApprovals;
+  return [
+    { name: "chat", description: "Chat with Tabbio" },
+    { name: "tools", description: toolCount ? `Browse ${toolCount} tools` : "Browse every tool" },
+    { name: "approvals", description: waiting === null ? "Approve or reject actions" : waiting > 0 ? `${waiting} waiting` : "None waiting" },
+    { name: "status", description: "Account, tokens, catalog" },
+    { name: "help", description: "Keys and commands" },
+    { name: "exit", description: "Quit tabbio" }
+  ];
+}
+function isHomeCommand(name) {
+  return ["chat", "tools", "approvals", "status", "help", "exit", "quit"].includes(name);
+}
+var HOME_HELP_ROWS = [
+  ["type + enter", "Start a chat with that message"],
+  ["/", "Command palette (chat, tools, approvals, status, help, exit)"],
+  ["tab", "Jump to recent chats"],
+  ["esc", "Close, go back, or interrupt"],
+  ["ctrl+j", "New line in the composer (or \\ then enter)"],
+  ["\u2191 \u2193", "Composer history, or move in lists"],
+  ["ctrl+c \xD72", "Quit"]
+];
+
+// src/ui/screens/home/HomeView.tsx
+import { Box as Box23, Text as Text23 } from "ink";
+import { memo as memo17 } from "react";
+
+// src/ui/components/Header.tsx
+import { Box as Box22, Text as Text22 } from "ink";
+import { memo as memo16 } from "react";
+
+// src/ui/components/Wordmark.tsx
+import { Box as Box21, Text as Text21 } from "ink";
+import Gradient from "ink-gradient";
+import { jsx as jsx22 } from "react/jsx-runtime";
+var WORDMARK_ROWS = [
+  " \u2588       \u2588    \u2588    \u2580",
+  "\u2580\u2588\u2580 \u2584\u2580\u2580\u2588 \u2588\u2580\u2580\u2584 \u2588\u2580\u2580\u2584 \u2588 \u2584\u2580\u2580\u2584",
+  " \u2588\u2584 \u2580\u2584\u2584\u2588 \u2588\u2584\u2584\u2580 \u2588\u2584\u2584\u2580 \u2588 \u2580\u2584\u2584\u2580"
+];
+var WORDMARK_WIDTH = 25;
+function Wordmark() {
+  if (!theme.unicode) return /* @__PURE__ */ jsx22(Text21, { children: theme.accentBold("tabbio") });
+  const rows = WORDMARK_ROWS.map((row) => row.padEnd(WORDMARK_WIDTH));
+  const gradient = theme.wordmarkGradient;
+  if (gradient) {
+    return /* @__PURE__ */ jsx22(Gradient, { colors: [...gradient], children: /* @__PURE__ */ jsx22(Text21, { children: rows.join("\n") }) });
+  }
+  return /* @__PURE__ */ jsx22(Box21, { flexDirection: "column", children: rows.map((row, i) => /* @__PURE__ */ jsx22(Text21, { children: theme.accent(row) }, i)) });
+}
+
+// src/ui/components/Header.tsx
+import { jsx as jsx23, jsxs as jsxs20 } from "react/jsx-runtime";
+var WIDE_HEADER_MIN = fromTerminal(60);
+function oneLineHeader({ version, profile, account }) {
+  const sep = theme.dim(` ${theme.symbols.middot} `);
+  const who = account?.name || account?.email;
+  const parts = [
+    theme.accentBold(`tabbio ${version}`),
+    who ?? null,
+    account?.plan ? capitalize(account.plan) : null,
+    theme.dim(profile)
+  ].filter((p) => Boolean(p));
+  return parts.join(sep);
+}
+function capitalize(value) {
+  return value ? value.charAt(0).toUpperCase() + value.slice(1) : value;
+}
+var Header = memo16(function Header2(props) {
+  const { version, width, tagline = "Your career, from the terminal" } = props;
+  if (width < WIDE_HEADER_MIN || !theme.unicode) {
+    return /* @__PURE__ */ jsx23(Text22, { wrap: "truncate-end", children: oneLineHeader(props) });
+  }
+  const showTagline = width >= WORDMARK_WIDTH + 3 + tagline.length;
+  return /* @__PURE__ */ jsxs20(Box22, { children: [
+    /* @__PURE__ */ jsx23(Wordmark, {}),
+    /* @__PURE__ */ jsxs20(Box22, { flexDirection: "column", marginLeft: 3, children: [
+      /* @__PURE__ */ jsx23(Text22, { children: " " }),
+      /* @__PURE__ */ jsx23(Text22, { children: theme.bold(`tabbio ${version}`) }),
+      /* @__PURE__ */ jsx23(Text22, { wrap: "truncate-end", children: showTagline ? theme.dim(tagline) : "" })
+    ] })
+  ] });
+});
+
+// src/ui/screens/home/HomeView.tsx
+import { jsx as jsx24, jsxs as jsxs21 } from "react/jsx-runtime";
+var TWO_COLUMN_MIN = fromTerminal(100);
+function AccountLine({ services, plan, width }) {
+  const { account } = services;
+  const sep = theme.dim(` ${theme.symbols.middot} `);
+  const who = account.signedIn ? [account.name, account.email, plan ? capitalize(plan) : null].filter(Boolean).join(sep) || theme.dim("personal MCP token") : theme.attention("Not signed in");
+  const left = `${account.signedIn ? theme.success(theme.symbols.dot) : theme.attention(theme.symbols.dot)} ${who}`;
+  const right = theme.dim(`profile ${services.profileName} ${theme.symbols.middot} ${services.apiHost}`);
+  const fill = width - displayWidth(left) - displayWidth(right);
+  return /* @__PURE__ */ jsx24(Text23, { wrap: "truncate-end", children: fill >= 2 ? `${left}${" ".repeat(fill)}${right}` : left });
+}
+var QuickActions = memo17(function QuickActions2({ commands, width, pending }) {
+  const nameWidth = 13;
+  return /* @__PURE__ */ jsxs21(Box23, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx24(Text23, { children: theme.dim("START") }),
+    commands.filter((c) => c.name !== "exit").map((c) => /* @__PURE__ */ jsxs21(Text23, { wrap: "truncate-end", children: [
+      theme.accent(padEnd(`/${c.name}`, nameWidth)),
+      truncate(c.description, Math.max(4, width - nameWidth - 3)),
+      c.name === "approvals" && pending ? ` ${theme.attention(theme.symbols.dot)}` : ""
+    ] }, c.name))
+  ] });
+});
+function Recent(props) {
+  const { data, focus, width, rows, services } = props;
+  const title = /* @__PURE__ */ jsx24(Text23, { children: theme.dim("RECENT CHATS") });
+  if (!services.account.hasSession) {
+    return /* @__PURE__ */ jsxs21(Box23, { flexDirection: "column", width, children: [
+      title,
+      /* @__PURE__ */ jsx24(Text23, { wrap: "truncate-end", children: theme.dim("Sign in with `tabbio login` to see your chats") })
+    ] });
+  }
+  if (data.recent === null) {
+    return /* @__PURE__ */ jsxs21(Box23, { flexDirection: "column", width, children: [
+      title,
+      /* @__PURE__ */ jsx24(Text23, { children: theme.dim(data.error ? `Could not load: ${data.error}` : `Loading${theme.symbols.ellipsis}`) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs21(Box23, { flexDirection: "column", width, children: [
+    title,
+    data.recent.length === 0 ? /* @__PURE__ */ jsx24(Text23, { children: theme.dim("No chats yet. Type below to start one.") }) : null,
+    data.recent.length > 0 ? /* @__PURE__ */ jsx24(
+      SelectList,
+      {
+        items: data.recent.map((r) => ({ id: r.id, label: r.title, meta: r.when })),
+        width,
+        height: rows,
+        isActive: focus === "recent",
+        filterable: false,
+        showHints: false,
+        onSelect: (item) => props.onRecentSelect(item.id, item.label),
+        onCancel: props.onRecentCancel
+      }
+    ) : null
+  ] });
+}
+function HomeView(props) {
+  const { services, data, commands, matches, width, height } = props;
+  const wide = width >= TWO_COLUMN_MIN;
+  const tall = height >= 26;
+  const showWordmark = width >= WIDE_HEADER_MIN && tall;
+  const showAccount = width >= WIDE_HEADER_MIN;
+  const recentRows = wide ? 5 : height >= 30 ? 3 : 0;
+  const colWidth = wide ? Math.floor((width - 4) / 2) : width;
+  const account = { name: services.account.name, email: services.account.email, plan: data.plan };
+  return /* @__PURE__ */ jsxs21(Box23, { flexDirection: "column", width, children: [
+    showWordmark ? /* @__PURE__ */ jsx24(Header, { version: services.version, profile: services.profileName, width, account }) : /* @__PURE__ */ jsx24(Header, { version: services.version, profile: services.profileName, width: Math.min(width, WIDE_HEADER_MIN - 1), account }),
+    showAccount ? /* @__PURE__ */ jsx24(Box23, { marginTop: 1, children: /* @__PURE__ */ jsx24(AccountLine, { services, plan: data.plan, width }) }) : null,
+    /* @__PURE__ */ jsxs21(Box23, { marginTop: 1, flexDirection: wide ? "row" : "column", width, children: [
+      /* @__PURE__ */ jsx24(QuickActions, { commands, width: colWidth, pending: data.pendingApprovals }),
+      recentRows > 0 ? /* @__PURE__ */ jsx24(Box23, { marginLeft: wide ? 4 : 0, marginTop: wide ? 0 : 1, children: /* @__PURE__ */ jsx24(Recent, { ...props, width: colWidth, rows: recentRows }) }) : null
+    ] }),
+    matches.length > 0 ? /* @__PURE__ */ jsx24(Box23, { marginTop: 1, children: /* @__PURE__ */ jsx24(Palette, { commands: matches, selected: props.paletteIndex, width }) }) : null,
+    /* @__PURE__ */ jsx24(Box23, { marginTop: 1, children: /* @__PURE__ */ jsx24(
+      TextInput,
+      {
+        editor: props.editor,
+        dispatch: props.dispatchEditor,
+        onSubmit: props.onSubmit,
+        onKey: props.onComposerKey,
+        isActive: props.focus === "composer",
+        width,
+        placeholder: width < WIDE_HEADER_MIN ? "Ask Tabbio anything, or / for commands" : "Ask Tabbio anything, or type / for commands",
+        boxed: true
+      }
+    ) }),
+    props.notice ? /* @__PURE__ */ jsx24(Text23, { wrap: "truncate-end", children: props.notice }) : null,
+    /* @__PURE__ */ jsx24(
+      KeyHints,
+      {
+        width,
+        hints: [
+          { key: "enter", label: "send" },
+          { key: "/", label: "commands" },
+          ...services.account.hasSession && recentRows > 0 ? [{ key: "tab", label: "recent chats" }] : [],
+          { key: "ctrl+c", label: "quit" }
+        ]
+      }
+    )
+  ] });
+}
+
+// src/ui/screens/home/Home.tsx
+import { jsx as jsx25, jsxs as jsxs22 } from "react/jsx-runtime";
+var DOUBLE_PRESS_MS2 = 2e3;
+function BackKeys({ onBack }) {
+  useInput10((input, key) => {
+    if (key.escape || input === "q" || key.return) onBack();
+  });
+  return null;
+}
+function Home(props) {
+  const { services, width, height, onExit, mode = "seeker" } = props;
+  const [route, setRoute] = useState9({ name: "home" });
+  const [data, setData] = useState9(props.initialData ?? emptyHomeData);
+  const [editor, dispatchEditor] = useReducer4(editorReducer, emptyEditor);
+  const [paletteIndex, setPaletteIndex] = useState9(0);
+  const [focus, setFocus] = useState9("composer");
+  const [notice, setNotice] = useState9(null);
+  const lastCtrlC = useRef7(0);
+  const mounted = useRef7(true);
+  useEffect8(
+    () => () => {
+      mounted.current = false;
+    },
+    []
+  );
+  const loadData = useCallback6(async () => {
+    if (props.initialData || !services.account.hasSession) return;
+    const [plan, approvals, threads] = await Promise.allSettled([
+      services.loadPlan(),
+      services.loadPendingApprovals(),
+      services.listThreads({ mode, companyId: props.companyId })
+    ]);
+    if (!mounted.current) return;
+    setData({
+      plan: plan.status === "fulfilled" ? plan.value : null,
+      pendingApprovals: approvals.status === "fulfilled" ? approvals.value.length : null,
+      recent: threads.status === "fulfilled" ? threads.value.slice(0, 5).map((t) => ({
+        id: t.id,
+        title: t.title?.trim() || "Untitled chat",
+        when: relativeTime(new Date(t.lastMessageAt ?? t.updatedAt))
+      })) : null,
+      error: threads.status === "rejected" ? toCliError(threads.reason).message : void 0
+    });
+  }, [props.initialData, props.companyId, services, mode]);
+  useEffect8(() => {
+    if (route.name === "home") void loadData();
+  }, [route.name, loadData]);
+  useEffect8(() => {
+    if (!notice) return void 0;
+    const timer = setTimeout(() => setNotice(null), 4e3);
+    return () => clearTimeout(timer);
+  }, [notice]);
+  const commands = useMemo7(() => homeCommands(data, services.cachedToolCount), [data, services.cachedToolCount]);
+  const matches = paletteMatches(commands, editor.value);
+  const selected = Math.min(paletteIndex, Math.max(0, matches.length - 1));
+  const goHome = useCallback6(() => setRoute({ name: "home" }), []);
+  const needSession = useCallback6(
+    (what) => {
+      if (services.account.hasSession) return true;
+      setNotice(theme.attention(`${theme.symbols.attention} ${what} needs a full sign-in. Run \`tabbio login\`.`));
+      return false;
+    },
+    [services.account.hasSession]
+  );
+  const open = useCallback6(
+    (name) => {
+      switch (name) {
+        case "chat":
+          if (needSession("Chat")) setRoute({ name: "chat" });
+          return;
+        case "tools": {
+          if (!services.account.signedIn) {
+            setNotice(theme.attention(`${theme.symbols.attention} Sign in first: run \`tabbio login\`.`));
+            return;
+          }
+          const since = Date.now();
+          setRoute({ name: "tools", since });
+          services.listTools().then((tools) => mounted.current && setRoute((r) => r.name === "tools" ? { ...r, tools } : r)).catch((error) => mounted.current && setRoute((r) => r.name === "tools" ? { ...r, error: toCliError(error).message } : r));
+          return;
+        }
+        case "approvals":
+          if (needSession("Approvals")) setRoute({ name: "approvals" });
+          return;
+        case "status": {
+          setRoute({ name: "status", since: Date.now() });
+          services.loadStatus().then((rows) => mounted.current && setRoute((r) => r.name === "status" ? { ...r, rows } : r)).catch((error) => mounted.current && setRoute((r) => r.name === "status" ? { ...r, error: toCliError(error).message } : r));
+          return;
+        }
+        case "help":
+          setRoute({ name: "help" });
+          return;
+        case "exit":
+        case "quit":
+          onExit();
+          return;
+        default:
+          setNotice(theme.error(`${theme.symbols.error} Unknown command /${name}`));
+      }
+    },
+    [needSession, services, onExit]
+  );
+  const submit2 = useCallback6(
+    (value) => {
+      const text = value.trim();
+      if (!text) return;
+      const slash = parseSlash(text);
+      dispatchEditor({ type: "remember", value: text });
+      dispatchEditor({ type: "clear" });
+      setPaletteIndex(0);
+      if (slash) {
+        const exact = isHomeCommand(slash.name) ? slash.name : void 0;
+        open(exact ?? matches[selected]?.name ?? slash.name);
+        return;
+      }
+      if (needSession("Chat")) setRoute({ name: "chat", initialMessage: text });
+    },
+    [open, matches, selected, needSession]
+  );
+  const onComposerKey = useCallback6(
+    (input, key) => {
+      if (key.ctrl && input === "c") return true;
+      if (matches.length > 0 && (key.upArrow || key.downArrow)) {
+        setPaletteIndex((i) => key.upArrow ? Math.max(0, i - 1) : Math.min(matches.length - 1, i + 1));
+        return true;
+      }
+      if (key.tab) {
+        if (matches.length > 0) {
+          const choice = matches[selected];
+          if (choice) dispatchEditor({ type: "set", value: `/${choice.name}` });
+        } else if (data.recent?.length) setFocus("recent");
+        return true;
+      }
+      if (key.escape) {
+        dispatchEditor({ type: "clear" });
+        return true;
+      }
+      return false;
+    },
+    [matches, selected, data.recent]
+  );
+  useInput10(
+    (input, key) => {
+      if (!(key.ctrl && input === "c")) return;
+      const now = Date.now();
+      if (now - lastCtrlC.current < DOUBLE_PRESS_MS2) {
+        onExit();
+        return;
+      }
+      lastCtrlC.current = now;
+      if (editor.value) dispatchEditor({ type: "clear" });
+      setNotice(theme.attention("Press ctrl+c again to quit."));
+    },
+    { isActive: route.name !== "chat" }
+  );
+  switch (route.name) {
+    case "chat":
+      return /* @__PURE__ */ jsx25(
+        Chat,
+        {
+          services,
+          mode,
+          companyId: props.companyId,
+          threadId: route.threadId,
+          initialMessage: route.initialMessage,
+          width,
+          height,
+          hostedByHome: true,
+          onExit: (reason) => reason === "home" ? goHome() : onExit()
+        }
+      );
+    case "tools":
+      if (route.tools) return /* @__PURE__ */ jsx25(ToolBrowser, { tools: route.tools, services, width, height, onExit: goHome });
+      return /* @__PURE__ */ jsxs22(Box24, { flexDirection: "column", width, children: [
+        route.error ? /* @__PURE__ */ jsx25(Text24, { children: theme.error(`${theme.symbols.error} ${route.error}`) }) : /* @__PURE__ */ jsx25(Working, { label: "Loading tools\u2026", since: route.since }),
+        /* @__PURE__ */ jsx25(BackKeys, { onBack: goHome })
+      ] });
+    case "approvals":
+      return /* @__PURE__ */ jsx25(Approvals, { services, width, height, onExit: goHome });
+    case "status":
+      return /* @__PURE__ */ jsxs22(Box24, { flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsx25(Text24, { children: theme.bold("Status") }),
+        /* @__PURE__ */ jsx25(Box24, { marginTop: 1, flexDirection: "column", children: route.rows ? /* @__PURE__ */ jsx25(KeyValue, { rows: route.rows, width }) : route.error ? /* @__PURE__ */ jsx25(Text24, { children: theme.error(`${theme.symbols.error} ${route.error}`) }) : /* @__PURE__ */ jsx25(Working, { label: "Checking\u2026", since: route.since }) }),
+        /* @__PURE__ */ jsx25(Box24, { marginTop: 1, children: /* @__PURE__ */ jsx25(KeyHints, { width, hints: [{ key: "q", label: "back" }] }) }),
+        /* @__PURE__ */ jsx25(BackKeys, { onBack: goHome })
+      ] });
+    case "help":
+      return /* @__PURE__ */ jsxs22(Box24, { flexDirection: "column", width, children: [
+        /* @__PURE__ */ jsx25(Text24, { children: theme.bold("Keys and commands") }),
+        /* @__PURE__ */ jsx25(Box24, { marginTop: 1, children: /* @__PURE__ */ jsx25(KeyValue, { rows: HOME_HELP_ROWS.map(([label, value]) => ({ label, value })), width }) }),
+        /* @__PURE__ */ jsx25(Box24, { marginTop: 1, children: /* @__PURE__ */ jsx25(KeyHints, { width, hints: [{ key: "q", label: "back" }] }) }),
+        /* @__PURE__ */ jsx25(BackKeys, { onBack: goHome })
+      ] });
+    default:
+      return /* @__PURE__ */ jsx25(
+        HomeView,
+        {
+          services,
+          data,
+          commands,
+          matches,
+          paletteIndex: selected,
+          editor,
+          dispatchEditor,
+          onSubmit: submit2,
+          onComposerKey,
+          focus,
+          onRecentSelect: (id) => {
+            setFocus("composer");
+            setRoute({ name: "chat", threadId: id });
+          },
+          onRecentCancel: () => setFocus("composer"),
+          notice,
+          width,
+          height
+        }
+      );
+  }
+}
+
+// src/ui/services.ts
+function hostOf2(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function createUiServices(ctx) {
+  const creds = ctx.api.credentials ?? ctx.credentials;
+  const cached = readCachedCatalog(ctx.profile, creds);
+  return {
+    version: CLI_VERSION,
+    profileName: ctx.profile.name,
+    apiHost: hostOf2(ctx.profile.apiUrl),
+    account: {
+      name: creds?.user?.name ?? null,
+      email: creds?.user?.email ?? null,
+      signedIn: Boolean(creds?.accessToken || creds?.mcpToken),
+      hasSession: Boolean(creds?.accessToken),
+      userId: creds?.user?.id
+    },
+    cachedToolCount: cached ? cached.tools.filter((t) => !t.hidden).length : null,
+    async loadPlan() {
+      if (!creds?.accessToken) return null;
+      const state = await ctx.api.json("/api/subscription/state");
+      return state?.snapshot?.tier ?? null;
+    },
+    async loadPendingApprovals() {
+      const state = await getMcpAccessState(ctx.api);
+      return state?.pendingApprovals ?? [];
+    },
+    listThreads: (scope) => listThreads(ctx, scope),
+    listModels: (scope) => listModels(ctx, scope),
+    getThreadMessages: (threadId, scope) => getThreadMessages(ctx, threadId, scope),
+    streamChat: (request, signal) => streamChat(ctx, request, { signal }),
+    decideApproval: (approvalId, decision, scope) => decision === "approve" ? confirmApproval(ctx, approvalId, scope) : rejectApproval(ctx, approvalId, scope),
+    async listTools(opts) {
+      const session = await ctx.mcp();
+      return session.listTools(opts);
+    },
+    async callTool(toolId, input, opts) {
+      const session = await ctx.mcp();
+      const started = Date.now();
+      const result = await session.callTool(toolId, input, opts);
+      return { ...result, durationMs: Date.now() - started };
+    },
+    capabilityPrefs: loadCapabilityPrefs(ctx.profile.name),
+    saveCapabilityPrefs: (capabilities) => saveCapabilityPrefs(ctx.profile.name, capabilities),
+    loadCapabilities: () => ctx.api.json("/api/agent/capabilities"),
+    getArtifact: (artifactId) => getArtifact(ctx.api, artifactId),
+    async artifactPreviewUrl(artifactId, kind) {
+      return (await previewUrl(ctx.api, artifactId, { variant: previewVariantFor(kind) })).url;
+    },
+    hyperlinks: supportsHyperlinks(),
+    async loadStatus() {
+      const { collectStatus } = await import("./status-I5UAQPBY.js");
+      const report = await collectStatus(ctx);
+      const who = report.user ? report.user.name ? `${report.user.name} <${report.user.email}>` : report.user.email : "not signed in";
+      const rows = [
+        ["Profile", `${report.profile.name} (${report.profile.source})`],
+        ["API", report.profile.apiUrl],
+        ["Account", who],
+        ["Plan", report.plan],
+        ["Session", report.session ? `${report.session.token}${report.session.refreshable ? " \xB7 auto-refresh" : ""}` : null],
+        ["Tools via", report.mcp?.label],
+        ["Approvals", report.pendingApprovals === null ? null : `${report.pendingApprovals} pending`],
+        ["Catalog", report.catalog ? `${report.catalog.tools} tools${report.catalog.fresh ? "" : " (stale)"}` : null],
+        ...report.problems.map((p) => ["Problem", p])
+      ];
+      return rows.filter((r) => Boolean(r[1])).map(([label, value]) => ({ label, value }));
+    }
+  };
+}
+
+// src/ui/entry.tsx
+import { jsx as jsx26, jsxs as jsxs23 } from "react/jsx-runtime";
+function unwrap(outcome) {
+  if (outcome.status === "interrupted") throw interruptedError();
+  return outcome.value;
+}
+async function runBrowseTools(ctx, tools, options) {
+  const services = createUiServices(ctx);
+  unwrap(
+    await renderScreen("The tool browser", ({ finish, width, height }) => /* @__PURE__ */ jsx26(
+      ToolBrowser,
+      {
+        tools,
+        services,
+        width,
+        height,
+        initialQuery: options.query,
+        initialGroup: options.group,
+        onExit: () => finish(void 0)
+      }
+    ))
+  );
+}
+async function runToolForm(_ctx, tool, initial, options) {
+  const skip = autoFilledProperties(tool, tool.inputSchema);
+  const state = createFormState(tool.inputSchema, initial, { skip, missingRequired: options.missingRequired });
+  return unwrap(
+    await renderScreen("The input form", ({ finish, width, height }) => /* @__PURE__ */ jsxs23(Box25, { flexDirection: "column", width, children: [
+      /* @__PURE__ */ jsxs23(Box25, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs23(Text25, { wrap: "truncate-end", children: [
+          theme.bold(toolLabel(tool)),
+          " ",
+          theme.dim(`${theme.symbols.middot} ${oneLine(tool.title)}`)
+        ] }),
+        options.missingRequired.length ? /* @__PURE__ */ jsx26(Text25, { wrap: "truncate-end", children: theme.dim(`Missing: ${options.missingRequired.join(", ")}`) }) : null
+      ] }),
+      /* @__PURE__ */ jsx26(
+        Form,
+        {
+          initial: state,
+          width,
+          height: Math.max(3, height - 5),
+          isActive: true,
+          onSubmit: (input) => finish(input, /* @__PURE__ */ jsx26(Text25, { wrap: "truncate-end", children: theme.dim(`${theme.symbols.pointer} ${equivalentCommand(tool, input, skip)}`) })),
+          onCancel: () => finish(null)
+        }
+      )
+    ] }))
+  );
+}
+async function runApprovalPrompt(ctx, approval) {
+  const shownAt = Date.now();
+  const title = sentenceCase(approval.toolName || "this action");
+  return unwrap(
+    await renderScreen("The approval prompt", ({ finish, width }) => /* @__PURE__ */ jsx26(
+      ApprovalCard,
+      {
+        approvalId: approval.approvalId,
+        title,
+        message: approval.message,
+        args: approval.args,
+        destructive: isDestructiveTool(approval.toolName),
+        context: `Writes to your account ${theme.symbols.middot} profile ${ctx.profile.name}`,
+        isActive: true,
+        width,
+        onDecision: (decision) => finish(decision, /* @__PURE__ */ jsx26(Text25, { children: approvalOutcomeText(decision, title, approval.approvalId, Date.now() - shownAt) }))
+      }
+    ))
+  );
+}
+function PrintOnce({ children, onPrinted }) {
+  const { columns } = useTerminalSize();
+  useEffect9(() => {
+    onPrinted();
+  }, [onPrinted]);
+  return /* @__PURE__ */ jsx26(Static2, { items: ["once"], children: (key) => /* @__PURE__ */ jsx26(Page, { columns, children }, key) });
+}
+async function runShowResult(_ctx, tool, result, meta) {
+  unwrap(
+    await renderScreen("The result panel", ({ finish, width, height }) => /* @__PURE__ */ jsx26(PrintOnce, { onPrinted: () => finish(void 0), children: /* @__PURE__ */ jsx26(
+      ResultPanel,
+      {
+        title: toolLabel(tool),
+        result,
+        durationMs: meta.durationMs,
+        requestId: meta.requestId,
+        width,
+        height,
+        interactive: false
+      }
+    ) }))
+  );
+}
+async function runHome(ctx, opts = {}) {
+  const services = createUiServices(ctx);
+  await renderScreen(
+    "The home screen",
+    ({ finish, width, height }) => /* @__PURE__ */ jsx26(Home, { services, width, height, mode: opts.mode, companyId: opts.companyId, onExit: () => finish(void 0) }),
+    { ctrlC: "screen" }
+  );
+}
+async function runChat(ctx, opts) {
+  const services = createUiServices(ctx);
+  await renderScreen(
+    "Chat",
+    ({ finish, width, height }) => /* @__PURE__ */ jsx26(
+      Chat,
+      {
+        services,
+        mode: opts.mode,
+        companyId: opts.companyId,
+        threadId: opts.threadId,
+        modelId: opts.modelId,
+        initialMessage: opts.message,
+        capabilities: opts.capabilities,
+        width,
+        height,
+        onExit: () => finish(void 0)
+      }
+    ),
+    { ctrlC: "screen" }
+  );
+}
+export {
+  PrintOnce,
+  runApprovalPrompt,
+  runBrowseTools,
+  runChat,
+  runHome,
+  runShowResult,
+  runToolForm
+};
+//# sourceMappingURL=entry-WENOOT6W.js.map