@thoth-agents/pi-thoth-theme 0.1.0 → 0.2.0

package/dist/index.ts

@@ -0,0 +1,3686 @@
+// @ts-nocheck
+
+// ../pi-core/src/validation.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+// ../pi-core/src/channels.ts
+function defineChannel(definition) {
+  return definition;
+}
+
+// ../pi-core/src/duration.ts
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return "0s";
+  if (ms < 1e3) return `${Math.floor(ms)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1).replace(/\.0$/, "")}s`;
+  const totalMinutes = Math.floor(ms / 6e4);
+  if (ms < 36e5) {
+    const seconds = Math.floor(ms / 1e3) % 60;
+    return `${totalMinutes}m ${String(seconds).padStart(2, "0")}s`;
+  }
+  const hours = Math.floor(ms / 36e5);
+  return `${hours}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
+}
+
+// ../pi-core/src/render-kit.ts
+var nativeFrames = {
+  spinnerFrames: Object.freeze([
+    "\u280B",
+    "\u2819",
+    "\u2839",
+    "\u2838",
+    "\u283C",
+    "\u2834",
+    "\u2826",
+    "\u2827",
+    "\u2807",
+    "\u280F"
+  ]),
+  workingFrames: Object.freeze(["\u25B3", "\u25ED", "\u25B2", "\u25EE"])
+};
+var terminalFooterGlyphs = {
+  completed: "\u2713",
+  deleted: "\u2713",
+  failed: "\u2717",
+  cancelled: "\u2717",
+  interrupted: "\u2717",
+  blocked: "\u2717"
+};
+function getToolElapsedMs(options) {
+  const context = options.context;
+  const state = context?.state;
+  if (options.elapsedMs !== void 0) {
+    const elapsedMs2 = Number.isFinite(options.elapsedMs) ? Math.max(0, options.elapsedMs) : void 0;
+    if (state && terminalFooterGlyphs[options.status] && elapsedMs2 !== void 0) {
+      state.completedElapsedMs = elapsedMs2;
+    }
+    return elapsedMs2;
+  }
+  if (!state) return void 0;
+  if (context.executionStarted && (options.status === "running" || options.status === "in_progress") && state.startedAt === void 0) {
+    state.startedAt = Date.now();
+  }
+  if (typeof state.completedElapsedMs === "number" && Number.isFinite(state.completedElapsedMs)) {
+    return Math.max(0, state.completedElapsedMs);
+  }
+  if (typeof state.startedAt !== "number" || !Number.isFinite(state.startedAt)) {
+    return void 0;
+  }
+  const elapsedMs = Math.max(0, Date.now() - state.startedAt);
+  if (terminalFooterGlyphs[options.status])
+    state.completedElapsedMs = elapsedMs;
+  return elapsedMs;
+}
+var RENDER_KIT_VERSION = 1;
+var registryKey = /* @__PURE__ */ Symbol.for(
+  `thoth-agents.pi-core.render-kit.v${RENDER_KIT_VERSION}`
+);
+var shared = globalThis;
+function registration() {
+  try {
+    const record = shared[registryKey];
+    if (record && typeof record.token === "symbol" && record.owner !== null && (typeof record.owner === "object" || typeof record.owner === "function"))
+      return record;
+  } catch {
+  }
+  return void 0;
+}
+function registerRenderKit(kit, owner) {
+  const token = /* @__PURE__ */ Symbol("render-kit-registration");
+  shared[registryKey] = { kit, owner, token };
+  return token;
+}
+function withdrawRenderKit(token) {
+  if (registration()?.token === token) delete shared[registryKey];
+}
+
+// ../pi-core/src/todo.ts
+var todoStatuses = [
+  "pending",
+  "in_progress",
+  "completed",
+  "deleted"
+];
+function isTodoSnapshot(value) {
+  try {
+    if (!isRecord(value)) return false;
+    const { tasks, nextId, counts } = value;
+    if (!Array.isArray(tasks) || !isTaskId(nextId) || !isRecord(counts))
+      return false;
+    for (const task of tasks) {
+      if (!isTodoTask(task)) return false;
+    }
+    return todoStatuses.every((status) => isNonNegativeInteger(counts[status]));
+  } catch {
+    return false;
+  }
+}
+function isTaskId(value) {
+  return isNonNegativeInteger(value) && value > 0;
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isTodoTask(value) {
+  if (!isRecord(value) || !isTaskId(value.id) || typeof value.subject !== "string" || !todoStatuses.some((status) => status === value.status) || !Array.isArray(value.blockedBy) || !isOptionalString(value.description) || !isOptionalString(value.activeForm) || !isOptionalString(value.owner))
+    return false;
+  for (const id of value.blockedBy) {
+    if (!isTaskId(id)) return false;
+  }
+  return true;
+}
+var TODO_STATE_CHANNEL = defineChannel({
+  name: "thoth:todo:state",
+  version: 1,
+  validate: isTodoSnapshot
+});
+function isTodoStateRequest(value) {
+  try {
+    if (!isRecord(value)) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return (prototype === Object.prototype || prototype === null) && Reflect.ownKeys(value).length === 0;
+  } catch {
+    return false;
+  }
+}
+var TODO_STATE_REQUEST = defineChannel({
+  name: "thoth:todo:state:request",
+  version: 1,
+  validate: isTodoStateRequest
+});
+
+// ../pi-core/src/tool-registry.ts
+var TOOL_DEFINITION_REGISTRY_VERSION = 1;
+var registryKey2 = /* @__PURE__ */ Symbol.for(
+  `thoth-agents.pi-core.tool-definitions.v${TOOL_DEFINITION_REGISTRY_VERSION}`
+);
+
+// src/render-kit/index.ts
+import {
+  stripTerminalSequences,
+  truncateToWidth as truncateToWidth3,
+  wrapTextWithAnsi
+} from "@earendil-works/pi-tui";
+
+// src/shared/cache.ts
+function cachedComponent(renderFn) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    render(width) {
+      let lines = cache.get(width);
+      if (lines === void 0) {
+        lines = renderFn(width);
+        cache.set(width, lines);
+      }
+      return lines;
+    },
+    invalidate() {
+      cache.clear();
+    }
+  };
+}
+
+// src/shared/icons.ts
+var ICONS = {
+  branch: { nerd: "\uE0A0", unicode: "\u2442", ascii: "git" },
+  folder: { nerd: "\uF07C", unicode: "dir", ascii: "dir" },
+  model: { nerd: "\u{F06A9}", unicode: "\u25CF", ascii: "*" },
+  effort: { nerd: "\u{F09D1}", unicode: "\u25D0", ascii: "o" },
+  context: { nerd: "\uF2DB", unicode: "ctx", ascii: "ctx" },
+  cost: { nerd: "\uF155", unicode: "$", ascii: "$" },
+  tokensIn: { nerd: "\uF062", unicode: "\u2191", ascii: "^" },
+  tokensOut: { nerd: "\uF063", unicode: "\u2193", ascii: "v" },
+  cache: { nerd: "\u{F01BC}", unicode: "cache", ascii: "cache" },
+  throughput: { nerd: "\u{F04C5}", unicode: "tok/s", ascii: "tok/s" },
+  agent: { nerd: "\u{F08C7}", unicode: "\u2699", ascii: "@" },
+  file: { nerd: "\u{F0214}", unicode: "file", ascii: "[file]" },
+  tool: { nerd: "\uF0AD", unicode: "*", ascii: "*" },
+  bash: { nerd: "\uF489", unicode: "$", ascii: "$" },
+  powershell: { nerd: "\uE70F", unicode: "PS", ascii: "PS" },
+  read: { nerd: "\uF06E", unicode: "read", ascii: "[read]" },
+  write: { nerd: "\uF0C7", unicode: "write", ascii: "[write]" },
+  edit: { nerd: "\uF044", unicode: "edit", ascii: "[edit]" },
+  search: { nerd: "\uF002", unicode: "search", ascii: "?" },
+  separator: { nerd: "\xB7", unicode: "\xB7", ascii: "|" },
+  ellipsis: { nerd: "\u2026", unicode: "\u2026", ascii: "..." },
+  arrowUp: { nerd: "\u2191", unicode: "\u2191", ascii: "^" },
+  arrowDown: { nerd: "\u2193", unicode: "\u2193", ascii: "v" },
+  arrowLeft: { nerd: "\u2190", unicode: "\u2190", ascii: "<" },
+  arrowRight: { nerd: "\u2192", unicode: "\u2192", ascii: ">" },
+  selection: { nerd: "\u203A", unicode: "\u203A", ascii: ">" },
+  selectionSelected: { nerd: "\uF111", unicode: "\u25CF", ascii: "*" },
+  selectionUnselected: { nerd: "\uF10C", unicode: "\u25CB", ascii: "o" },
+  taskInProgress: { nerd: "\u25D0", unicode: "\u25C7", ascii: "*" },
+  separatorHeavy: { nerd: "\u2503", unicode: "\u2503", ascii: "|" },
+  boxTopLeft: { nerd: "\u256D", unicode: "\u256D", ascii: "+" },
+  boxTopRight: { nerd: "\u256E", unicode: "\u256E", ascii: "+" },
+  boxVertical: { nerd: "\u2502", unicode: "\u2502", ascii: "|" },
+  boxBottomLeft: { nerd: "\u2570", unicode: "\u2570", ascii: "+" },
+  boxBottomRight: { nerd: "\u256F", unicode: "\u256F", ascii: "+" },
+  boxHorizontal: { nerd: "\u2500", unicode: "\u2500", ascii: "-" },
+  boxTDown: { nerd: "\u252C", unicode: "\u252C", ascii: "+" },
+  boxTUp: { nerd: "\u2534", unicode: "\u2534", ascii: "+" },
+  boxTRight: { nerd: "\u251C", unicode: "\u251C", ascii: "+" },
+  boxTLeft: { nerd: "\u2524", unicode: "\u2524", ascii: "+" },
+  boxCross: { nerd: "\u253C", unicode: "\u253C", ascii: "+" },
+  close: { nerd: "\uF00D", unicode: "\u2715", ascii: "x" },
+  scrollUp: { nerd: "\u2191", unicode: "\u2191", ascii: "^" },
+  scrollDown: { nerd: "\u2193", unicode: "\u2193", ascii: "v" },
+  ready: { nerd: "\u25B2", unicode: "\u25B2", ascii: "^" },
+  warning: { nerd: "\uF071", unicode: "\u26A0", ascii: "!" }
+};
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var WORKING_FRAMES = ["\u25B3", "\u25ED", "\u25B2", "\u25EE"];
+var FRAMES = {
+  spinnerFrames: {
+    nerd: SPINNER_FRAMES,
+    unicode: SPINNER_FRAMES,
+    ascii: ["|", "/", "-", "\\"]
+  },
+  workingFrames: {
+    nerd: WORKING_FRAMES,
+    unicode: WORKING_FRAMES,
+    ascii: [".", "o", "O", "0"]
+  }
+};
+var STOP = { nerd: "\uF05E", unicode: "\u25A0", ascii: "/" };
+var BLOCKED = { nerd: "\uF05E", unicode: "\u2298", ascii: "/" };
+var STATUS_ICONS = {
+  pending: { nerd: "\uF10C", unicode: "\u25CB", ascii: "-" },
+  queued: { nerd: "\u{F051F}", unicode: "\u25CB", ascii: "~" },
+  in_progress: { nerd: "\u25D0", unicode: "\u25D0", ascii: "*" },
+  running: { nerd: "\u25D0", unicode: "\u25D0", ascii: "*" },
+  completed: { nerd: "\uF00C", unicode: "\u2713", ascii: "+" },
+  failed: { nerd: "\uF00D", unicode: "\u2717", ascii: "x" },
+  cancelled: STOP,
+  interrupted: STOP,
+  stopping: STOP,
+  deleted: BLOCKED,
+  blocked: BLOCKED,
+  warning: { nerd: "\uF071", unicode: "!", ascii: "!" },
+  unknown: { nerd: "\uF128", unicode: "?", ascii: "?" }
+};
+function icon(name, mode) {
+  return ICONS[name][mode];
+}
+function frames(name, mode) {
+  return FRAMES[name][mode];
+}
+function statusIcon(status, mode) {
+  return STATUS_ICONS[status][mode];
+}
+
+// src/tools/border.ts
+function getBorderTone(state) {
+  return state.isError ? "error" : state.isSuccess ? "success" : "accent";
+}
+function getToolBorderTone(context) {
+  return getBorderTone({
+    isError: context?.isError,
+    isSuccess: !context?.isPartial
+  });
+}
+
+// src/tools/box.ts
+import {
+  DEFAULT_MAX_BYTES,
+  formatSize
+} from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth
+} from "@earendil-works/pi-tui";
+var BOX_HORIZONTAL = "\u2500";
+var BOX_VERTICAL = "\u2502";
+var BOX_ROUND_TOP_LEFT = "\u256D";
+var BOX_ROUND_TOP_RIGHT = "\u256E";
+var BOX_ROUND_BOTTOM_LEFT = "\u2570";
+var BOX_ROUND_BOTTOM_RIGHT = "\u256F";
+function getRawResultText(result) {
+  if (!result || !result.content || !Array.isArray(result.content)) return "";
+  return result.content.filter(
+    (block) => block && typeof block === "object" && block.type === "text"
+  ).map((block) => String(block.text ?? "")).join("\n");
+}
+function getResultText(result) {
+  return getRawResultText(result).replace(/\r/g, "");
+}
+function escapeControlCharacters(text) {
+  let escaped = "";
+  for (const character of text) {
+    const code = character.charCodeAt(0);
+    if (code < 32 && character !== "	") {
+      escaped += String.fromCharCode(9216 + code);
+    } else if (code === 127) {
+      escaped += "\u2421";
+    } else if (code >= 128 && code <= 159) {
+      escaped += `\\x${code.toString(16)}`;
+    } else {
+      escaped += character;
+    }
+  }
+  return escaped;
+}
+function stripSgr(text) {
+  return text.replace(/(?:\x1b\[|\x9b)[0-9;:]*m/g, "");
+}
+function escapeOutputRow(text) {
+  return escapeControlCharacters(stripSgr(text));
+}
+function hasImageContent(result) {
+  if (!result || !result.content || !Array.isArray(result.content))
+    return false;
+  return result.content.some(
+    (block) => block && typeof block === "object" && block.type === "image"
+  );
+}
+function splitResultNotice(text, details, tool) {
+  if (!details || typeof details !== "object") return { text, notices: [] };
+  const metadata = details;
+  let limitNotices = [""];
+  if (tool === "ls" && typeof metadata.entryLimitReached === "number") {
+    const limit = metadata.entryLimitReached;
+    limitNotices = [
+      `${limit} entries limit reached. Use limit=${limit * 2} for more`
+    ];
+  } else if (tool === "find" && typeof metadata.resultLimitReached === "number") {
+    const limit = metadata.resultLimitReached;
+    limitNotices = [
+      `${limit} results limit reached. Use limit=${limit * 2} for more, or refine pattern`,
+      // SDK custom glob operations use the shorter variant.
+      `${limit} results limit reached`
+    ];
+  } else if (tool === "grep" && typeof metadata.matchLimitReached === "number") {
+    const limit = metadata.matchLimitReached;
+    limitNotices = [
+      `${limit} matches limit reached. Use limit=${limit * 2} for more, or refine pattern`
+    ];
+  }
+  const commonNotices = [];
+  if (metadata.truncation?.truncated === true) {
+    commonNotices.push(`${formatSize(DEFAULT_MAX_BYTES)} limit reached`);
+  }
+  if (tool === "grep" && metadata.linesTruncated === true) {
+    commonNotices.push(
+      "Some lines truncated to 500 chars. Use read tool to see full lines"
+    );
+  }
+  for (const limitNotice of limitNotices) {
+    const notice = [limitNotice, ...commonNotices].filter(Boolean).join(". ");
+    if (!notice) continue;
+    const appendix = `[${notice}]`;
+    const suffix = `
+
+${appendix}`;
+    if (text.endsWith(suffix)) {
+      return { text: text.slice(0, -suffix.length), notices: [appendix] };
+    }
+  }
+  return { text, notices: [] };
+}
+function truncateBoxLine(line, limit) {
+  return line.length <= limit && !/[^\x20-\x7e]/.test(line) ? line : truncateToWidth(line, limit);
+}
+function renderBox(theme, bodyLines, width, options = {}) {
+  const safeWidth = Math.max(0, Math.floor(width));
+  const borderColor = getBorderTone(options);
+  if (safeWidth <= 0) {
+    return [];
+  }
+  if (safeWidth <= 4) {
+    const raw = [options.title, ...bodyLines, options.footer].filter(
+      (l) => typeof l === "string" && l.length > 0
+    );
+    const lines = raw.length > 0 ? raw : bodyLines;
+    return lines.map((l) => truncateBoxLine(l, safeWidth));
+  }
+  const result = [];
+  const innerWidth = Math.max(1, safeWidth - 2);
+  if (options.title) {
+    const rawTitle = ` ${options.title} `;
+    const maxTitleWidth = Math.max(1, innerWidth - 4);
+    const fitTitle = visibleWidth(rawTitle) > maxTitleWidth ? ` ${truncateToWidth(options.title, Math.max(1, maxTitleWidth - 2))} ` : rawTitle;
+    const titleWidth = visibleWidth(fitTitle);
+    const remainingDashes = Math.max(1, innerWidth - 2 - titleWidth);
+    const top = `${theme.fg(borderColor, `${BOX_ROUND_TOP_LEFT}${BOX_HORIZONTAL}${BOX_HORIZONTAL}`)}${fitTitle}${theme.fg(
+      borderColor,
+      `${BOX_HORIZONTAL.repeat(remainingDashes)}${BOX_ROUND_TOP_RIGHT}`
+    )}`;
+    result.push(truncateToWidth(top, safeWidth));
+  } else {
+    const top = `${theme.fg(borderColor, `${BOX_ROUND_TOP_LEFT}${BOX_HORIZONTAL.repeat(innerWidth)}${BOX_ROUND_TOP_RIGHT}`)}`;
+    result.push(truncateToWidth(top, safeWidth));
+  }
+  const contentWidth = Math.max(1, innerWidth - 2);
+  for (const line of bodyLines) {
+    const truncated = truncateBoxLine(line, contentWidth);
+    const pad = Math.max(0, contentWidth - visibleWidth(truncated));
+    const framed = `${theme.fg(borderColor, `${BOX_VERTICAL} `)}${truncated}${" ".repeat(pad)}${theme.fg(borderColor, ` ${BOX_VERTICAL}`)}`;
+    result.push(truncateBoxLine(framed, safeWidth));
+  }
+  if (options.footer) {
+    const rawFooter = ` ${options.footer} `;
+    const maxFooterWidth = Math.max(1, innerWidth - 4);
+    const fitFooter = visibleWidth(rawFooter) > maxFooterWidth ? ` ${truncateToWidth(options.footer, Math.max(1, maxFooterWidth - 2))} ` : rawFooter;
+    const footerWidth = visibleWidth(fitFooter);
+    const remainingDashes = Math.max(1, innerWidth - 2 - footerWidth);
+    const bottom = `${theme.fg(borderColor, `${BOX_ROUND_BOTTOM_LEFT}${BOX_HORIZONTAL}${BOX_HORIZONTAL}`)}${fitFooter}${theme.fg(
+      borderColor,
+      `${BOX_HORIZONTAL.repeat(remainingDashes)}${BOX_ROUND_BOTTOM_RIGHT}`
+    )}`;
+    result.push(truncateToWidth(bottom, safeWidth));
+  } else {
+    const bottom = `${theme.fg(
+      borderColor,
+      `${BOX_ROUND_BOTTOM_LEFT}${BOX_HORIZONTAL.repeat(innerWidth)}${BOX_ROUND_BOTTOM_RIGHT}`
+    )}`;
+    result.push(truncateToWidth(bottom, safeWidth));
+  }
+  return result.map((l) => truncateBoxLine(l, safeWidth));
+}
+function createComponent(renderFn) {
+  return cachedComponent((width) => {
+    const safeWidth = Math.max(0, Math.floor(width));
+    if (safeWidth <= 0) return [];
+    const lines = renderFn(safeWidth);
+    return lines.map((line) => truncateToWidth(line, safeWidth));
+  });
+}
+
+// src/tools/frame.ts
+import { relative, resolve } from "node:path";
+import { truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+var FRAME_HORIZONTAL = "\u2500";
+var FRAME_VERTICAL = "\u2502";
+var FRAME_ROUND_TOP_LEFT = "\u256D";
+var FRAME_ROUND_TOP_RIGHT = "\u256E";
+var FRAME_ROUND_BOTTOM_LEFT = "\u2570";
+var FRAME_ROUND_BOTTOM_RIGHT = "\u256F";
+var FRAME_DIVIDER_LEFT = "\u251C";
+var FRAME_DIVIDER_RIGHT = "\u2524";
+function formatDisplayPath(targetPath, cwd) {
+  if (!targetPath) return "";
+  if (!cwd) return targetPath;
+  try {
+    const absTarget = resolve(cwd, targetPath);
+    const absCwd = resolve(cwd);
+    const rel = relative(absCwd, absTarget);
+    if (!rel.startsWith("..") && !rel.startsWith("/") && !/^[A-Za-z]:/.test(rel)) {
+      return rel.replace(/\\/g, "/") || ".";
+    }
+  } catch {
+  }
+  return targetPath;
+}
+function hasToolResult(context) {
+  if (!context) return false;
+  return Boolean(context.state?.hasResult);
+}
+function isFramedContext(context) {
+  if (!context) return false;
+  return Boolean(context.toolCallId || context.state);
+}
+function renderFrameTop(theme, title, width, borderColor = "accent") {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth <= 0) return [];
+  if (safeWidth <= 4) {
+    return [truncateToWidth2(title, safeWidth)];
+  }
+  const innerWidth = Math.max(1, safeWidth - 2);
+  const rawTitle = ` ${title} `;
+  const maxTitleWidth = Math.max(1, innerWidth - 4);
+  const fitTitle = visibleWidth2(rawTitle) > maxTitleWidth ? ` ${truncateToWidth2(title, Math.max(1, maxTitleWidth - 2))} ` : rawTitle;
+  const titleWidth = visibleWidth2(fitTitle);
+  const remainingDashes = Math.max(1, innerWidth - 2 - titleWidth);
+  const top = `${theme.fg(borderColor, `${FRAME_ROUND_TOP_LEFT}${FRAME_HORIZONTAL}${FRAME_HORIZONTAL}`)}${fitTitle}${theme.fg(
+    borderColor,
+    `${FRAME_HORIZONTAL.repeat(remainingDashes)}${FRAME_ROUND_TOP_RIGHT}`
+  )}`;
+  return [truncateToWidth2(top, safeWidth)];
+}
+function renderFrameRow(theme, line, width, borderColor = "accent") {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth <= 0) return [];
+  if (safeWidth <= 4) {
+    return [truncateToWidth2(line, safeWidth)];
+  }
+  const innerWidth = Math.max(1, safeWidth - 2);
+  const contentWidth = Math.max(1, innerWidth - 2);
+  const truncated = truncateToWidth2(line, contentWidth);
+  const pad = Math.max(0, contentWidth - visibleWidth2(truncated));
+  const framed = `${theme.fg(borderColor, `${FRAME_VERTICAL} `)}${truncated}${" ".repeat(pad)}${theme.fg(borderColor, ` ${FRAME_VERTICAL}`)}`;
+  return [truncateToWidth2(framed, safeWidth)];
+}
+function renderFrameDivider(theme, title, width, borderColor = "accent") {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth <= 0) return [];
+  if (safeWidth <= 4) {
+    return [truncateToWidth2(title, safeWidth)];
+  }
+  const innerWidth = Math.max(1, safeWidth - 2);
+  const rawTitle = ` ${title} `;
+  const maxTitleWidth = Math.max(1, innerWidth - 4);
+  const fitTitle = visibleWidth2(rawTitle) > maxTitleWidth ? ` ${truncateToWidth2(title, Math.max(1, maxTitleWidth - 2))} ` : rawTitle;
+  const titleWidth = visibleWidth2(fitTitle);
+  const remainingDashes = Math.max(1, innerWidth - 2 - titleWidth);
+  const divider = `${theme.fg(borderColor, `${FRAME_DIVIDER_LEFT}${FRAME_HORIZONTAL}${FRAME_HORIZONTAL}`)}${theme.fg("dim", fitTitle)}${theme.fg(
+    borderColor,
+    `${FRAME_HORIZONTAL.repeat(remainingDashes)}${FRAME_DIVIDER_RIGHT}`
+  )}`;
+  return [truncateToWidth2(divider, safeWidth)];
+}
+function renderFrameBottom(theme, footer, width, borderColor = "accent") {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth <= 0) return [];
+  if (safeWidth <= 4) {
+    return footer ? [truncateToWidth2(footer, safeWidth)] : [];
+  }
+  const innerWidth = Math.max(1, safeWidth - 2);
+  if (footer) {
+    const rawFooter = ` ${footer} `;
+    const maxFooterWidth = Math.max(1, innerWidth - 4);
+    const fitFooter = visibleWidth2(rawFooter) > maxFooterWidth ? ` ${truncateToWidth2(footer, Math.max(1, maxFooterWidth - 2))} ` : rawFooter;
+    const footerWidth = visibleWidth2(fitFooter);
+    const remainingDashes = Math.max(1, innerWidth - 2 - footerWidth);
+    const bottom2 = `${theme.fg(borderColor, `${FRAME_ROUND_BOTTOM_LEFT}${FRAME_HORIZONTAL}${FRAME_HORIZONTAL}`)}${fitFooter}${theme.fg(
+      borderColor,
+      `${FRAME_HORIZONTAL.repeat(remainingDashes)}${FRAME_ROUND_BOTTOM_RIGHT}`
+    )}`;
+    return [truncateToWidth2(bottom2, safeWidth)];
+  }
+  const bottom = `${theme.fg(
+    borderColor,
+    `${FRAME_ROUND_BOTTOM_LEFT}${FRAME_HORIZONTAL.repeat(innerWidth)}${FRAME_ROUND_BOTTOM_RIGHT}`
+  )}`;
+  return [truncateToWidth2(bottom, safeWidth)];
+}
+
+// src/tools/ticker.ts
+var tickerStates = /* @__PURE__ */ new Map();
+var activeOwner;
+function activateElapsedTickerOwner(owner) {
+  activeOwner = owner;
+}
+function releaseElapsedTickerOwner(owner) {
+  if (activeOwner === owner) activeOwner = void 0;
+}
+function legacyElapsedOverride(state) {
+  return typeof state?.completedElapsedMs === "number" && !Number.isFinite(state.completedElapsedMs) ? 0 : void 0;
+}
+function stopElapsedTicker(state) {
+  if (state.elapsedTicker !== void 0) clearInterval(state.elapsedTicker);
+  delete state.elapsedTicker;
+  tickerStates.delete(state);
+}
+function stopElapsedTickers(owner) {
+  for (const [state, stateOwner] of tickerStates) {
+    if (stateOwner !== owner) continue;
+    getToolElapsedMs({ status: "interrupted", context: { state } });
+    stopElapsedTicker(state);
+  }
+}
+function syncElapsedTicker(context, owner = activeOwner, status) {
+  const state = context?.state;
+  if (!state) return;
+  const resolvedStatus = status ?? (context.isPartial ? "running" : context.isError ? "failed" : "completed");
+  getToolElapsedMs({
+    status: resolvedStatus,
+    context,
+    elapsedMs: status === void 0 ? legacyElapsedOverride(state) : void 0
+  });
+  if (!context.executionStarted || resolvedStatus !== "running" && resolvedStatus !== "in_progress" || state.completedElapsedMs !== void 0) {
+    stopElapsedTicker(state);
+    return;
+  }
+  if (owner === activeOwner && owner !== void 0 && context.invalidate && state.elapsedTicker === void 0) {
+    state.elapsedTicker = setInterval(context.invalidate, 1e3);
+    tickerStates.set(state, owner);
+  }
+}
+
+// src/render-kit/working.ts
+function workingFrame(elapsedMs = 0, mode = "nerd") {
+  const elapsed = Number.isFinite(elapsedMs) ? Math.max(0, elapsedMs) : 0;
+  const working = frames("workingFrames", mode);
+  return working[Math.floor(elapsed / 1e3) % working.length];
+}
+function runningFooter(theme, elapsedMs, mode) {
+  return [
+    theme.fg("accent", workingFrame(elapsedMs, mode)),
+    elapsedMs === void 0 ? "" : theme.fg("dim", formatDuration(Math.floor(elapsedMs / 1e3) * 1e3))
+  ].filter(Boolean).join(theme.fg("dim", ` ${icon("separator", mode)} `));
+}
+
+// src/render-kit/index.ts
+var STATUS_ROLE = {
+  pending: "dim",
+  queued: "dim",
+  in_progress: "accent",
+  running: "accent",
+  completed: "success",
+  failed: "error",
+  cancelled: "muted",
+  interrupted: "warning",
+  stopping: "warning",
+  deleted: "muted",
+  blocked: "warning",
+  unknown: "dim"
+};
+var TOOL_FOOTER_STATUS = {
+  completed: "completed",
+  deleted: "completed",
+  failed: "failed",
+  cancelled: "failed",
+  interrupted: "failed",
+  blocked: "failed"
+};
+function startsWithFooterGlyph(footer, mode) {
+  const plain = stripTerminalSequences(footer);
+  return ["completed", "failed"].some((status) => {
+    const glyph = statusIcon(status, mode);
+    return plain.startsWith(glyph) && (plain.length === glyph.length || /^\s/u.test(plain.slice(glyph.length)));
+  });
+}
+function isRunning(status) {
+  return status === "running" || status === "in_progress";
+}
+function statusGlyph(theme, status, mode) {
+  return theme.fg(STATUS_ROLE[status], statusIcon(status, mode));
+}
+function indicatorStatus(context) {
+  if (context.executionStarted && context.isPartial) return "running";
+  if (context.isError) return "failed";
+  return context.executionStarted ? "completed" : "pending";
+}
+function indicatorLabel(status) {
+  if (status === "completed") return "Done";
+  if (status === "failed") return "Error";
+  return status;
+}
+function card(theme, options, width, toolFooter2, mode) {
+  const safeWidth = Math.max(0, Math.floor(width));
+  if (safeWidth <= 0) return [];
+  const bodyWidth = safeWidth <= 4 ? safeWidth : Math.max(1, safeWidth - 4);
+  const rows = (source) => {
+    const resolved = typeof source === "function" ? source(bodyWidth) : source;
+    return (resolved ?? []).flatMap(
+      (row) => options.wrap ? wrapTextWithAnsi(row, bodyWidth) : [row]
+    );
+  };
+  let footer = options.footer ?? "";
+  if (options.footer === void 0 && options.status) {
+    footer = options.context ? toolFooter2(theme, {
+      status: options.status,
+      context: options.context,
+      summary: options.summary
+    }) : statusGlyph(theme, options.status, mode);
+  } else if (options.status && !isRunning(options.status) && !(TOOL_FOOTER_STATUS[options.status] && startsWithFooterGlyph(footer, mode))) {
+    footer = [statusGlyph(theme, options.status, mode), footer].filter(Boolean).join(" ");
+  }
+  const body = rows(options.body);
+  const borderState = {
+    isError: options.isError,
+    isSuccess: options.isSuccess === true
+  };
+  if (!options.sections?.length && (!options.part || options.part === "full")) {
+    return renderBox(theme, body, safeWidth, {
+      ...options,
+      ...borderState,
+      footer
+    });
+  }
+  const borderTone = getBorderTone(borderState);
+  return [
+    ...options.part === "end" ? [] : options.title ? renderFrameTop(theme, options.title, safeWidth, borderTone) : renderBox(theme, [], safeWidth, borderState).slice(0, 1),
+    ...body.flatMap((row) => renderFrameRow(theme, row, safeWidth, borderTone)),
+    ...(options.sections ?? []).flatMap((section) => [
+      ...renderFrameDivider(theme, section.title ?? "", safeWidth, borderTone),
+      ...rows(section.rows).flatMap(
+        (row) => renderFrameRow(theme, row, safeWidth, borderTone)
+      )
+    ]),
+    ...options.part === "start" ? [] : renderFrameBottom(theme, footer, safeWidth, borderTone)
+  ];
+}
+function toolFooter(theme, options, mode, owner) {
+  syncElapsedTicker(options.context ?? {}, owner, options.status);
+  const elapsedMs = getToolElapsedMs(options);
+  if (isRunning(options.status)) return runningFooter(theme, elapsedMs, mode);
+  const footerStatus = TOOL_FOOTER_STATUS[options.status];
+  const glyph = footerStatus ? statusIcon(footerStatus, mode) : void 0;
+  const summary = typeof options.summary === "string" ? [options.summary] : options.summary ?? [];
+  const parts = [
+    theme.fg(STATUS_ROLE[options.status], glyph ?? options.status)
+  ];
+  if (elapsedMs !== void 0) {
+    parts.push(
+      theme.fg("dim", formatDuration(Math.floor(elapsedMs / 1e3) * 1e3))
+    );
+  }
+  if (glyph) {
+    parts.push(...summary.filter(Boolean).map((part) => theme.fg("dim", part)));
+  }
+  return parts.join(theme.fg("dim", ` ${icon("separator", mode)} `));
+}
+function createRenderKit(owner, resolveToolRenderers, mode = "nerd") {
+  const separator2 = icon("separator", mode);
+  const ellipsis = icon("ellipsis", mode);
+  const ownedToolFooter = (theme, options) => toolFooter(theme, options, mode, owner);
+  return {
+    version: 1,
+    ...resolveToolRenderers ? { resolveToolRenderers } : {},
+    toolFooter: ownedToolFooter,
+    card(theme, options, width) {
+      if (options.footer !== void 0 && options.context && options.status) {
+        syncElapsedTicker(options.context, owner, options.status);
+      }
+      return card(theme, options, width, ownedToolFooter, mode);
+    },
+    collapse(theme, rows, options = {}) {
+      const budget = Math.max(0, Math.floor(options.budget ?? 8));
+      if (options.expanded || rows.length <= budget) return [...rows];
+      return [
+        ...rows.slice(0, budget),
+        theme.fg(
+          "dim",
+          `${ellipsis} ${rows.length - budget} more lines ${separator2} ${options.expandHint ?? "ctrl+o to expand"}`
+        )
+      ];
+    },
+    cachedComponent,
+    indicator(theme, context = {}, options = {}) {
+      const status = options.status ?? indicatorStatus(context);
+      syncElapsedTicker(context, owner, status);
+      const running = isRunning(status);
+      const elapsedMs = getToolElapsedMs({ ...options, status, context });
+      const elapsed = elapsedMs === void 0 ? "" : formatDuration(
+        running ? Math.floor(elapsedMs / 1e3) * 1e3 : elapsedMs
+      );
+      const frame = options.frame;
+      const spinner = frames("spinnerFrames", mode);
+      const workingGlyph = frame !== void 0 && Number.isFinite(frame) ? spinner[(Math.floor(frame) % spinner.length + spinner.length) % spinner.length] : workingFrame(elapsedMs, mode);
+      const glyph = running ? theme.fg("accent", workingGlyph) : statusGlyph(theme, status, mode);
+      const label = options.label ?? indicatorLabel(status);
+      const role = STATUS_ROLE[status];
+      return {
+        glyph,
+        elapsedMs,
+        elapsed,
+        text: running ? ownedToolFooter(theme, { status, elapsedMs }) : [theme.fg(role, label), elapsed ? theme.fg("dim", elapsed) : ""].filter(Boolean).join(theme.fg("dim", ` ${separator2} `))
+      };
+    },
+    icon(name) {
+      return name === "spinnerFrames" || name === "workingFrames" ? frames(name, mode) : icon(name, mode);
+    },
+    statusGlyph: (theme, status) => statusGlyph(theme, status, mode),
+    widgetHeading(theme, options, width) {
+      const title = theme.fg("toolTitle", options.title);
+      return truncateToWidth3(
+        [
+          options.status ? statusGlyph(theme, options.status, mode) : theme.fg("accent", icon("ready", mode)),
+          theme.bold ? theme.bold(title) : title,
+          options.counts ? theme.fg(
+            "dim",
+            `${options.counts.completed}/${options.counts.total}`
+          ) : "",
+          options.suffix ? theme.fg("dim", options.suffix) : ""
+        ].filter(Boolean).join(" "),
+        Math.max(0, Math.floor(width)),
+        ellipsis
+      );
+    },
+    treeRow(theme, options, width) {
+      const rail = `${"  ".repeat(Math.max(0, Math.floor(options.depth ?? 0)))}${options.last ? "\u2514\u2500" : "\u251C\u2500"} `;
+      return truncateToWidth3(
+        [
+          theme.fg(
+            options.selected ? "accent" : "dim",
+            `${options.selected ? `${icon("selection", mode)} ` : "  "}${rail}`
+          ),
+          options.status ? `${statusGlyph(theme, options.status, mode)} ` : "",
+          options.text
+        ].join(""),
+        Math.max(0, Math.floor(width)),
+        ellipsis
+      );
+    },
+    fg: (theme, role, text) => theme.fg(role, text)
+  };
+}
+
+// src/shared/config.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_RESPECT_PACKAGES = [
+  "thoth-agents",
+  "@thoth-agents/*",
+  "thoth-mem"
+];
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function moduleEnabled(value) {
+  const enabled = asObject(value).enabled;
+  return typeof enabled === "boolean" ? enabled : true;
+}
+function parseSubscriptionProviders(value) {
+  const obj = asObject(value);
+  const providers = obj.subscriptionProviders;
+  if (Array.isArray(providers)) {
+    return providers.filter(
+      (item) => typeof item === "string" && item.trim().length > 0
+    );
+  }
+  return ["claude-bridge"];
+}
+function parseRespectPackages(value) {
+  const packages = asObject(value).respectPackages;
+  return Array.isArray(packages) && packages.every(
+    (item) => typeof item === "string" && item.trim().length > 0
+  ) ? packages : [...DEFAULT_RESPECT_PACKAGES];
+}
+function loadConfig(configPath = join(
+  process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent"),
+  "pi-thoth-theme.json"
+)) {
+  let config = {};
+  try {
+    config = asObject(JSON.parse(readFileSync(configPath, "utf8")));
+  } catch {
+  }
+  return {
+    icons: config.icons === "ascii" || config.icons === "unicode" ? config.icons : "nerd",
+    ...config.inputBox === void 0 ? {} : { inputBox: { enabled: moduleEnabled(config.inputBox) } },
+    statusLine: {
+      enabled: moduleEnabled(config.statusLine),
+      subscriptionProviders: parseSubscriptionProviders(config.statusLine)
+    },
+    tools: {
+      enabled: moduleEnabled(config.tools),
+      respectPackages: parseRespectPackages(config.tools)
+    },
+    welcome: { enabled: moduleEnabled(config.welcome) }
+  };
+}
+
+// src/input-box/decorate.ts
+import {
+  truncateToWidth as truncateToWidth6,
+  visibleWidth as visibleWidth5
+} from "@earendil-works/pi-tui";
+
+// src/status-line/layout.ts
+import { isAbsolute, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { truncateToWidth as truncateToWidth4, visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
+function themeFg(theme, token, text) {
+  return theme?.fg ? theme.fg(token, text) : text;
+}
+function formatCwd(cwd, home) {
+  if (!home) return cwd;
+  const relativeToHome = relative2(resolve2(home), resolve2(cwd));
+  if (relativeToHome === ".." || relativeToHome.startsWith(`..${sep}`) || isAbsolute(relativeToHome)) {
+    return cwd;
+  }
+  return relativeToHome === "" ? "~" : `~${sep}${relativeToHome}`;
+}
+function formatTokens(count) {
+  if (count < 1e3) return count.toString();
+  if (count < 1e6) {
+    const k = (count / 1e3).toFixed(1).replace(/\.0$/, "");
+    return `${k}K`;
+  }
+  const m = (count / 1e6).toFixed(1).replace(/\.0$/, "");
+  return `${m}M`;
+}
+function thinkingToken(level) {
+  const cap = level.charAt(0).toUpperCase() + level.slice(1);
+  return `thinking${cap}`;
+}
+function formatBranchSegment(data, { mode = "nerd", theme } = {}) {
+  if (!data.gitBranch) return "";
+  return `${themeFg(theme, "dim", icon("separator", mode))} ${themeFg(
+    theme,
+    "success",
+    `${icon("branch", mode)} ${data.gitBranch}`
+  )}`;
+}
+function formatModelSegments(data, { mode = "nerd", theme } = {}) {
+  const pieces = [];
+  const model = data.modelName || data.modelId;
+  if (model) {
+    pieces.push(themeFg(theme, "mdLink", `${icon("model", mode)} ${model}`));
+  }
+  const level = data.thinkingLevel;
+  if (level && level !== "off") {
+    const label = level === "minimal" ? "min" : level === "medium" ? "med" : level;
+    const effort = themeFg(
+      theme,
+      thinkingToken(level),
+      `${icon("effort", mode)} ${label}`
+    );
+    pieces.push(
+      model ? `${themeFg(theme, "dim", icon("separator", mode))} ${effort}` : effort
+    );
+  }
+  return pieces;
+}
+function formatCwdSegments(data, { mode = "nerd", theme } = {}) {
+  const cwd = data.cwd;
+  if (!cwd) return [];
+  const folder = icon("folder", mode);
+  const variants = [`${folder} ${cwd}`];
+  const leaf = cwd.split(/[/\\]/).filter(Boolean).pop();
+  const separator2 = cwd.includes("\\") && !cwd.includes("/") ? "\\" : "/";
+  const isDriveRoot = leaf !== void 0 && /^[A-Za-z]:$/.test(leaf);
+  if (leaf && leaf !== cwd && leaf !== "~" && !isDriveRoot) {
+    variants.push(`${folder} ${icon("ellipsis", mode)}${separator2}${leaf}`);
+  }
+  return variants.map((text) => themeFg(theme, "muted", text));
+}
+function contextBar(percent, isAscii, theme) {
+  let token = "success";
+  if (percent >= 90) token = "error";
+  else if (percent >= 70) token = "warning";
+  const filled = Math.min(10, Math.max(0, Math.round(percent / 100 * 10)));
+  const fillChar = isAscii ? "#" : "\u2588";
+  const emptyChar = isAscii ? "-" : "\u2591";
+  const dim = (text) => themeFg(theme, "dim", text);
+  return {
+    bar: `${dim("[")}${themeFg(theme, token, fillChar.repeat(filled))}${dim(
+      emptyChar.repeat(10 - filled)
+    )}${dim("]")}`,
+    pct: themeFg(theme, token, `${Math.round(percent)}%`)
+  };
+}
+function formatContextSegments(data, { mode = "nerd", theme } = {}) {
+  const contextIcon = themeFg(theme, "muted", icon("context", mode));
+  const windowText = data.contextWindow ? `/${formatTokens(data.contextWindow)}` : "";
+  const hasTokens = data.contextTokens !== null && data.contextTokens !== void 0;
+  const hasPercent = data.contextPercent !== null && data.contextPercent !== void 0;
+  const tokens = themeFg(
+    theme,
+    "muted",
+    `${hasTokens ? formatTokens(data.contextTokens) : "\u2014"}${windowText}`
+  );
+  if (!hasPercent) {
+    const hasAny = hasTokens || windowText !== "" || data.contextPercent !== void 0 || data.contextTokens !== void 0;
+    return hasAny ? [`${contextIcon} ${tokens}`] : [themeFg(theme, "muted", "\u2014")];
+  }
+  const { bar, pct } = contextBar(
+    data.contextPercent,
+    mode === "ascii",
+    theme
+  );
+  return [
+    `${contextIcon} ${bar} ${pct} ${tokens}`,
+    `${contextIcon} ${pct} ${tokens}`,
+    `${contextIcon} ${tokens}`
+  ];
+}
+function formatRate(rate) {
+  if (rate === null || !Number.isFinite(rate)) return "\u2014";
+  return rate < 10 ? rate.toFixed(1) : Math.round(rate).toString();
+}
+function renderStatusLine(data, options) {
+  const { width, mode, theme } = options;
+  if (width <= 0) return "";
+  const sep2 = ` ${themeFg(theme, "border", icon("separator", mode))} `;
+  const segments = [];
+  if (data.cost !== void 0) {
+    const total = data.cost + (data.subagentCost ?? 0);
+    segments.push(
+      themeFg(
+        theme,
+        "accent",
+        `${icon("cost", mode)}${mode === "ascii" ? "" : " "}${total.toFixed(3)}${data.isSubscription ? " (sub)" : ""}`
+      )
+    );
+  }
+  const totals = data.tokenTotals;
+  if (totals) {
+    const totalInput = totals.input + totals.cacheRead + totals.cacheWrite;
+    const cacheHitRatio = totalInput === 0 ? "\u2014" : `${Math.round(totals.cacheRead / totalInput * 100)}%`;
+    const up = icon("tokensIn", mode);
+    const down = icon("tokensOut", mode);
+    segments.push(
+      themeFg(
+        theme,
+        "muted",
+        `${up}${formatTokens(totalInput)} ${down}${formatTokens(totals.output)}`
+      ),
+      themeFg(theme, "muted", `${icon("cache", mode)} ${cacheHitRatio}`)
+    );
+  }
+  if (data.tokensPerSecond !== void 0) {
+    segments.push(
+      themeFg(
+        theme,
+        "muted",
+        mode === "ascii" ? `${formatRate(data.tokensPerSecond)} ${icon("throughput", mode)}` : `${icon("throughput", mode)} ${formatRate(data.tokensPerSecond)} tok/s`
+      )
+    );
+  }
+  for (let count = segments.length; count >= 1; count--) {
+    const line = segments.slice(0, count).join(sep2);
+    if (visibleWidth3(line) <= width) return line;
+  }
+  return segments.length ? truncateToWidth4(segments[0], width, "") : "";
+}
+
+// src/input-box/frame.ts
+import { truncateToWidth as truncateToWidth5, visibleWidth as visibleWidth4 } from "@earendil-works/pi-tui";
+
+// src/input-box/gradient.ts
+import {
+  foregroundAnsi,
+  getTerminalColorMode,
+  mixColors,
+  parseColor,
+  stripTerminalSequences as stripTerminalSequences2,
+  styleText
+} from "@earendil-works/pi-tui";
+var GOLD = parseColor("#D4AF37");
+var BRIGHT_GOLD = parseColor("#F2C94C");
+var DIM = parseColor("#736850");
+var MUTED = parseColor("#A89A78");
+var BREATHING_CYCLE_MS = 2400;
+var SHIMMER_LAP_MS = 2400;
+var SHIMMER_BAND_CELLS = 3;
+function createBreathingFrame(now, mode = getTerminalColorMode()) {
+  const phase = now % BREATHING_CYCLE_MS / BREATHING_CYCLE_MS * 2 * Math.PI;
+  const intensity = (1 - Math.cos(phase)) / 2;
+  const color2 = intensity <= 0.5 ? mixColors(DIM, GOLD, intensity * 2, "srgb") : mixColors(GOLD, BRIGHT_GOLD, (intensity - 0.5) * 2, "srgb");
+  return { now, foreground: foregroundAnsi(color2, mode), mode };
+}
+function colorBreathingBorder(text, frame) {
+  return `${frame.foreground}${text}\x1B[39m`;
+}
+function renderWorkingIndicator(native, frame, styleMuted, glyphs = frames("workingFrames", "nerd")) {
+  const plain = stripTerminalSequences2(native);
+  const glyph = glyphs.find(
+    (candidate) => plain.startsWith(candidate) && (plain.length === candidate.length || /^\s/u.test(plain.slice(candidate.length)))
+  );
+  const spacing = glyph === void 0 ? "" : /^\s*/u.exec(plain.slice(glyph.length))?.[0] ?? "";
+  const prefix = glyph === void 0 ? "" : `${frame.foreground}${glyph}\x1B[39m${spacing}`;
+  const letters = Array.from(
+    plain.slice(glyph === void 0 ? 0 : glyph.length + spacing.length)
+  );
+  const head = frame.now % SHIMMER_LAP_MS / SHIMMER_LAP_MS * (letters.length + SHIMMER_BAND_CELLS * 2) - SHIMMER_BAND_CELLS;
+  const label = letters.map((letter, index) => {
+    const intensity = Math.max(
+      0,
+      1 - Math.abs(index - head) / SHIMMER_BAND_CELLS
+    );
+    return intensity === 0 ? styleMuted(letter) : styleText(
+      letter,
+      {
+        fg: mixColors(MUTED, BRIGHT_GOLD, intensity, "srgb"),
+        bold: intensity >= 0.65
+      },
+      frame.mode
+    );
+  }).join("");
+  return prefix + label;
+}
+
+// src/input-box/frame.ts
+function muted(theme, text) {
+  return theme.fg?.("muted", text) ?? text;
+}
+function colorBorder(theme, text, frame) {
+  return frame ? colorBreathingBorder(text, frame) : muted(theme, text);
+}
+function scrollLabel(direction, hiddenLineCount, mode = "nerd") {
+  const arrow = icon(direction === "up" ? "scrollUp" : "scrollDown", mode);
+  return `${arrow} ${hiddenLineCount} more`;
+}
+function inputLabelWidth(width, hiddenLineCount = 0, mode = "nerd") {
+  const overflowWidth = hiddenLineCount > 0 ? visibleWidth4(scrollLabel("up", hiddenLineCount, mode)) + 3 : 0;
+  return Math.max(0, Math.floor(width) - 6 - overflowWidth);
+}
+var LEFT_ONLY_OVERHEAD = 6;
+var LEFT_RIGHT_OVERHEAD = 9;
+var RIGHT_ONLY_OVERHEAD = 6;
+function renderBorder(width, theme, regions, overflow, capLeft, capRight, frame) {
+  width = Math.max(0, Math.floor(width));
+  const border = (text) => colorBorder(theme, text, frame);
+  const pieces = (regions.left ?? []).filter((piece) => visibleWidth4(piece));
+  const rights = (regions.right ?? []).filter((piece) => visibleWidth4(piece));
+  const plain = () => truncateToWidth5(
+    border(`${capLeft}${"\u2500".repeat(Math.max(0, width - 2))}${capRight}`),
+    width,
+    ""
+  );
+  if (width <= 5 || !pieces.length && !overflow && !rights.length)
+    return plain();
+  const withOverflow = (text) => !overflow ? text : !text ? muted(theme, overflow) : frame ? `${text}${border(" \u2500 ")}${muted(theme, overflow)}` : `${text}${muted(theme, ` \u2500 ${overflow}`)}`;
+  const leftWith = (count) => withOverflow(pieces.slice(0, count).join(" "));
+  const full = leftWith(pieces.length);
+  const fullWidth = visibleWidth4(full);
+  for (const right of rights) {
+    const rightWidth = visibleWidth4(right);
+    if (!full) {
+      if (rightWidth > width - RIGHT_ONLY_OVERHEAD) continue;
+      const dashes3 = width - 5 - rightWidth;
+      return `${border(`${capLeft}${"\u2500".repeat(dashes3)} `)}${right}${border(` \u2500${capRight}`)}`;
+    }
+    if (fullWidth + rightWidth > width - LEFT_RIGHT_OVERHEAD) continue;
+    const dashes2 = width - 8 - fullWidth - rightWidth;
+    return `${border(`${capLeft}\u2500 `)}${full}${border(` ${"\u2500".repeat(dashes2)} `)}${right}${border(` \u2500${capRight}`)}`;
+  }
+  if (!full) return plain();
+  const labelWidth = width - LEFT_ONLY_OVERHEAD;
+  let label;
+  for (let count = pieces.length; count >= 1; count--) {
+    const candidate = leftWith(count);
+    if (visibleWidth4(candidate) <= labelWidth) {
+      label = candidate;
+      break;
+    }
+  }
+  if (label === void 0) {
+    if (overflow) {
+      const statusWidth = labelWidth - visibleWidth4(overflow) - 3;
+      const status = statusWidth > 0 && pieces.length ? truncateToWidth5(pieces[0], statusWidth, "") : "";
+      label = withOverflow(visibleWidth4(status) ? status : "");
+    } else {
+      label = truncateToWidth5(pieces[0], labelWidth, "");
+    }
+  }
+  const fitted = truncateToWidth5(label, labelWidth, "");
+  const dashes = width - visibleWidth4(fitted) - 5;
+  return `${border(`${capLeft}\u2500 `)}${fitted}${border(` ${"\u2500".repeat(dashes)}${capRight}`)}`;
+}
+function renderInputTop(width, theme, regions, hiddenLineCount = 0, frame, mode = "nerd") {
+  const overflow = hiddenLineCount > 0 ? scrollLabel("up", hiddenLineCount, mode) : "";
+  return renderBorder(width, theme, regions, overflow, "\u256D", "\u256E", frame);
+}
+function renderInputBottom(width, theme, regions, hiddenLineCount = 0, frame, mode = "nerd") {
+  const overflow = hiddenLineCount > 0 ? scrollLabel("down", hiddenLineCount, mode) : "";
+  return renderBorder(width, theme, regions, overflow, "\u2570", "\u256F", frame);
+}
+function wrapContentRow(line, width, theme, frame) {
+  width = Math.max(0, Math.floor(width));
+  if (width < 2)
+    return truncateToWidth5(colorBorder(theme, "\u2502\u2502", frame), width, "");
+  const content = truncateToWidth5(line, width - 2, "", true);
+  const side = colorBorder(theme, "\u2502", frame);
+  return `${side}${content}${side}`;
+}
+function renderPlaceholder(line, width, theme, text) {
+  if (text !== "") return line;
+  const cursor = "\x1B[7m \x1B[0m";
+  const cursorStart = line.indexOf(cursor);
+  if (cursorStart < 0) return line;
+  const prefix = line.slice(0, cursorStart + cursor.length);
+  const available = Math.max(0, width - visibleWidth4(prefix));
+  const placeholder = truncateToWidth5("type or / for commands", available, "");
+  const padding = " ".repeat(available - visibleWidth4(placeholder));
+  return prefix + (theme.fg?.("dim", placeholder) ?? placeholder) + padding;
+}
+
+// src/input-box/decorate.ts
+var MIN_INPUT_BOX_WIDTH = 16;
+var decoratedEditors = /* @__PURE__ */ new WeakSet();
+var decorations = /* @__PURE__ */ new WeakMap();
+var methodNames = [
+  "render",
+  "renderTopBorder",
+  "renderBottomBorder",
+  "getText",
+  "getPaddingX",
+  "handleMouse",
+  "borderColor"
+];
+function method(editor, name) {
+  for (let owner = editor; owner; owner = Reflect.getPrototypeOf(owner)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(owner, name);
+    if (descriptor)
+      return typeof descriptor.value === "function" ? descriptor.value : void 0;
+  }
+  return void 0;
+}
+function isEditorLike(editor) {
+  if (!editor || typeof editor !== "object") return false;
+  if (decoratedEditors.has(editor)) return true;
+  try {
+    return methodNames.every((name) => method(editor, name) !== void 0);
+  } catch {
+    return false;
+  }
+}
+function decorateEditor(editor, deps) {
+  if (!isEditorLike(editor)) return void 0;
+  if (decoratedEditors.has(editor)) return decorations.get(editor);
+  const names = [
+    "render",
+    "renderTopBorder",
+    "renderBottomBorder",
+    "handleMouse",
+    "borderColor"
+  ];
+  if (!Reflect.isExtensible(editor) || names.some(
+    (name) => Reflect.getOwnPropertyDescriptor(editor, name)?.configurable === false
+  ))
+    return void 0;
+  const originals = Object.fromEntries(
+    methodNames.map((name) => [name, method(editor, name)])
+  );
+  const descriptors = new Map(
+    names.map((name) => [name, Reflect.getOwnPropertyDescriptor(editor, name)])
+  );
+  let active = true;
+  let outerWidth;
+  let fallback = false;
+  let top;
+  let bottom;
+  let renderFrame;
+  let boxRendered = false;
+  const muted2 = (text) => deps.theme.fg?.("muted", text) ?? text;
+  function nativeRender(receiver, width) {
+    fallback = true;
+    try {
+      return originals.render.call(receiver, width);
+    } finally {
+      fallback = false;
+    }
+  }
+  const patches = {
+    render: {
+      configurable: true,
+      writable: true,
+      value(width) {
+        boxRendered = false;
+        if (!active || width < MIN_INPUT_BOX_WIDTH)
+          return nativeRender(this, width);
+        const boxWidth = Math.floor(width);
+        const innerWidth = boxWidth - 2;
+        const maxPadding = Math.max(0, Math.floor((innerWidth - 1) / 2));
+        const paddingX = Math.min(originals.getPaddingX.call(this), maxPadding);
+        const contentWidth = Math.max(1, innerWidth - paddingX * 2);
+        const layoutWidth = Math.max(1, contentWidth - (paddingX ? 0 : 1));
+        if (layoutWidth < 2) return nativeRender(this, width);
+        const frame = deps.working.isWorking ? createBreathingFrame(Date.now()) : void 0;
+        renderFrame = frame;
+        outerWidth = boxWidth;
+        top = void 0;
+        bottom = void 0;
+        let lines;
+        try {
+          lines = originals.render.call(this, outerWidth - 2);
+        } finally {
+          outerWidth = void 0;
+          renderFrame = void 0;
+        }
+        const bottomIndex = bottom === void 0 ? -1 : lines.indexOf(bottom, 1);
+        if (top === void 0 || lines[0] !== top || bottomIndex < 2)
+          return nativeRender(this, width);
+        const text = originals.getText.call(this);
+        lines = lines.map((line, index) => {
+          if (index === 0 || index === bottomIndex) return line;
+          if (index > bottomIndex)
+            return ` ${truncateToWidth6(line, width - 2, "", true)} `;
+          return wrapContentRow(
+            renderPlaceholder(line, width - 2, deps.theme, text),
+            width,
+            deps.theme,
+            frame
+          );
+        });
+        boxRendered = true;
+        return lines;
+      }
+    },
+    renderTopBorder: {
+      configurable: true,
+      writable: true,
+      value(width, hidden) {
+        if (outerWidth === void 0 || hidden > 0 && visibleWidth5(scrollLabel("up", hidden, deps.iconMode)) > outerWidth - 6)
+          return originals.renderTopBorder.call(this, width, hidden);
+        const status = deps.working.status(
+          this.workingStatusIndicator,
+          inputLabelWidth(outerWidth, hidden, deps.iconMode),
+          muted2,
+          renderFrame,
+          deps.iconMode
+        );
+        const data = active ? deps.getStatusSnapshot?.() : void 0;
+        const options = { mode: deps.iconMode, theme: deps.theme };
+        top = renderInputTop(
+          outerWidth,
+          deps.theme,
+          {
+            left: [status, data ? formatBranchSegment(data, options) : ""],
+            right: data ? formatCwdSegments(data, options) : []
+          },
+          hidden,
+          renderFrame,
+          deps.iconMode
+        );
+        return top;
+      }
+    },
+    renderBottomBorder: {
+      configurable: true,
+      writable: true,
+      value(width, hidden) {
+        if (outerWidth === void 0 || hidden > 0 && visibleWidth5(scrollLabel("down", hidden, deps.iconMode)) > outerWidth - 6)
+          return originals.renderBottomBorder.call(this, width, hidden);
+        const data = active ? deps.getStatusSnapshot?.() : void 0;
+        const options = { mode: deps.iconMode, theme: deps.theme };
+        bottom = renderInputBottom(
+          outerWidth,
+          deps.theme,
+          {
+            left: data ? formatModelSegments(data, options) : [],
+            right: data ? formatContextSegments(data, options) : []
+          },
+          hidden,
+          renderFrame,
+          deps.iconMode
+        );
+        return bottom;
+      }
+    },
+    handleMouse: {
+      configurable: true,
+      writable: true,
+      value(event) {
+        const translated = active && boxRendered ? { ...event, x: event.x - 1, width: event.width - 2 } : event;
+        return originals.handleMouse.call(this, translated);
+      }
+    },
+    borderColor: {
+      configurable: true,
+      get: () => fallback ? originals.borderColor : muted2,
+      set: () => {
+      }
+    }
+  };
+  Object.defineProperties(editor, patches);
+  const decoration = {
+    getStatusSnapshot: () => active ? deps.getStatusSnapshot?.() : void 0,
+    dispose() {
+      if (!active) return;
+      active = false;
+      for (const name of names) {
+        const current = Reflect.getOwnPropertyDescriptor(editor, name);
+        const patch = patches[name];
+        if (current?.value !== patch.value || current?.get !== patch.get || current?.set !== patch.set)
+          continue;
+        const descriptor = descriptors.get(name);
+        if (descriptor) Object.defineProperty(editor, name, descriptor);
+        else Reflect.deleteProperty(editor, name);
+      }
+      decoratedEditors.delete(editor);
+      decorations.delete(editor);
+    }
+  };
+  decoratedEditors.add(editor);
+  decorations.set(editor, decoration);
+  return decoration;
+}
+
+// src/input-box/state.ts
+import { truncateToWidth as truncateToWidth7, visibleWidth as visibleWidth6 } from "@earendil-works/pi-tui";
+function createWorkingState(requestRender) {
+  let startedAt;
+  let ticker;
+  let disposed = false;
+  function stop() {
+    if (ticker !== void 0) clearInterval(ticker);
+    ticker = void 0;
+    startedAt = void 0;
+  }
+  return {
+    get isWorking() {
+      return startedAt !== void 0;
+    },
+    start() {
+      if (disposed) return;
+      stop();
+      startedAt = Date.now();
+      ticker = setInterval(requestRender, 50);
+      ticker.unref?.();
+      requestRender();
+    },
+    end() {
+      if (disposed) return;
+      stop();
+      requestRender();
+    },
+    status(indicator, width, styleMuted = (text) => text, frame, mode = "nerd") {
+      const ready = `${icon("ready", mode)} ready`;
+      const separator2 = icon("separator", mode);
+      if (!indicator || typeof indicator !== "object" || !("renderInBorder" in indicator) || typeof indicator.renderInBorder !== "function") {
+        return styleMuted(truncateToWidth7(ready, width, ""));
+      }
+      const working = "kind" in indicator && indicator.kind === "working";
+      const now = frame?.now ?? Date.now();
+      const elapsed = working && startedAt !== void 0 ? ` ${separator2} ${formatDuration(Math.floor((now - startedAt) / 1e3) * 1e3)}` : "";
+      const nativeWidth = Math.max(1, width - visibleWidth6(elapsed));
+      const native = indicator.renderInBorder(nativeWidth);
+      if (typeof native !== "string" || visibleWidth6(native) === 0) {
+        return styleMuted(truncateToWidth7(ready, width, ""));
+      }
+      const fitted = truncateToWidth7(native, nativeWidth, "");
+      const label = working && startedAt !== void 0 ? renderWorkingIndicator(
+        fitted,
+        frame ?? createBreathingFrame(now),
+        styleMuted,
+        frames("workingFrames", mode)
+      ) : fitted;
+      return truncateToWidth7(
+        `${label}${elapsed ? styleMuted(elapsed) : ""}`,
+        width,
+        ""
+      );
+    },
+    dispose() {
+      disposed = true;
+      stop();
+    }
+  };
+}
+
+// src/status-line/cost.ts
+function calculateSessionCost(source) {
+  if (!source) return 0;
+  const entries = Array.isArray(source) ? source : typeof source.getEntries === "function" ? source.getEntries() : [];
+  let totalCost = 0;
+  for (const entry of entries) {
+    if (!entry) continue;
+    if (entry.type === "message") {
+      const msg = entry.message;
+      if ((msg?.role === "assistant" || msg?.role === "toolResult") && "usage" in msg && msg.usage?.cost?.total) {
+        totalCost += msg.usage.cost.total;
+      }
+    } else if ((entry.type === "branch_summary" || entry.type === "compaction" || entry.type === "usage") && "usage" in entry && entry.usage?.cost?.total) {
+      totalCost += entry.usage.cost.total;
+    }
+  }
+  return totalCost;
+}
+
+// src/status-line/throughput.ts
+function createThroughputTracker() {
+  let pending;
+  let outputTokens = 0;
+  let generationMs = 0;
+  const startedIds = /* @__PURE__ */ new Set();
+  const endedIds = /* @__PURE__ */ new Set();
+  let startedMessages = /* @__PURE__ */ new WeakSet();
+  let endedMessages = /* @__PURE__ */ new WeakSet();
+  return {
+    observe(event, observedAt = Date.now()) {
+      if (event.message.role !== "assistant") return;
+      const id = event.message.id;
+      if (event.type === "message_start") {
+        if (startedMessages.has(event.message) || id && startedIds.has(id))
+          return;
+        startedMessages.add(event.message);
+        if (id) startedIds.add(id);
+        pending = { at: observedAt, id };
+        return;
+      }
+      if (endedMessages.has(event.message) || id && endedIds.has(id)) return;
+      const start = pending;
+      if (!start || start.id && id && start.id !== id) return;
+      pending = void 0;
+      endedMessages.add(event.message);
+      if (id) endedIds.add(id);
+      const elapsed = observedAt - start.at;
+      if (!Number.isFinite(elapsed) || elapsed <= 0) return;
+      const output = event.message.usage?.output;
+      if (typeof output !== "number" || !Number.isFinite(output) || output < 0)
+        return;
+      outputTokens += output;
+      generationMs += elapsed;
+    },
+    reset() {
+      pending = void 0;
+      outputTokens = 0;
+      generationMs = 0;
+      startedIds.clear();
+      endedIds.clear();
+      startedMessages = /* @__PURE__ */ new WeakSet();
+      endedMessages = /* @__PURE__ */ new WeakSet();
+    },
+    get tokensPerSecond() {
+      if (!Number.isFinite(generationMs) || generationMs <= 0) return null;
+      const speed = outputTokens * 1e3 / generationMs;
+      return Number.isFinite(speed) ? speed : null;
+    }
+  };
+}
+
+// src/status-line/tokens.ts
+function calculateSessionTokens(source) {
+  const entries = Array.isArray(source) ? source : source && typeof source.getEntries === "function" ? source.getEntries() : [];
+  const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  for (const entry of entries) {
+    if (!entry) continue;
+    const usage = entry.type === "message" ? (entry.message?.role === "assistant" || entry.message?.role === "toolResult") && "usage" in entry.message ? entry.message.usage : void 0 : (entry.type === "branch_summary" || entry.type === "compaction" || entry.type === "usage") && "usage" in entry ? entry.usage : void 0;
+    if (!usage) continue;
+    for (const field of [
+      "input",
+      "output",
+      "cacheRead",
+      "cacheWrite"
+    ]) {
+      const value = usage[field];
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+        totals[field] += value;
+      }
+    }
+  }
+  return totals;
+}
+
+// src/status-line/index.ts
+function registerStatusLine(pi, ctx, config) {
+  const subscriptionProviders = config.statusLine.subscriptionProviders ?? [
+    "claude-bridge"
+  ];
+  const inputBoxEnabled = config.inputBox?.enabled !== false;
+  ctx.ui.setFooter((tui, theme, footerData) => {
+    const unsubs = [];
+    let disposed = false;
+    const throughput = createThroughputTracker();
+    let sessionLeafId = ctx.sessionManager.getLeafId();
+    let session = readSession();
+    let sessionDirty = false;
+    let subagentCost = 0;
+    let cachedKey = "";
+    let cachedLines = [];
+    let snapshotKey = "";
+    let snapshot;
+    const getStatusSnapshot = () => {
+      if (!disposed) {
+        const leafId = ctx.sessionManager.getLeafId();
+        if (sessionDirty || leafId !== sessionLeafId) {
+          session = readSession();
+          sessionLeafId = leafId;
+          sessionDirty = false;
+        }
+      }
+      const data = {
+        modelName: ctx.model?.name,
+        modelId: ctx.model?.id,
+        thinkingLevel: ctx.thinkingLevel,
+        gitBranch: footerData?.getGitBranch?.() ?? null,
+        cwd: formatCwd(ctx.cwd, process.env.HOME || process.env.USERPROFILE),
+        ...session,
+        subagentCost,
+        tokensPerSecond: throughput.tokensPerSecond
+      };
+      const key = JSON.stringify(data);
+      if (key !== snapshotKey) {
+        snapshotKey = key;
+        snapshot = data;
+      }
+      return snapshot;
+    };
+    function readSession() {
+      const usage = ctx.getContextUsage?.();
+      const provider = ctx.model?.provider;
+      const entries = ctx.sessionManager.getEntries();
+      return {
+        cost: calculateSessionCost(entries),
+        tokenTotals: calculateSessionTokens(entries),
+        isSubscription: provider !== void 0 && subscriptionProviders.includes(provider),
+        contextTokens: usage?.tokens ?? null,
+        contextPercent: usage?.percent ?? null,
+        contextWindow: usage?.contextWindow
+      };
+    }
+    const requestRender = () => {
+      if (!disposed) tui.requestRender?.();
+    };
+    const invalidateRender = () => {
+      if (disposed) return;
+      cachedKey = "";
+      requestRender();
+    };
+    const working = createWorkingState(invalidateRender);
+    const editorDecorations = /* @__PURE__ */ new Set();
+    const refreshSession = () => {
+      if (disposed) return;
+      sessionDirty = true;
+      invalidateRender();
+    };
+    unsubs.push(
+      pi.events.on("thoth:subagent-usage", (data) => {
+        if (disposed || !data || typeof data !== "object") return;
+        const { parentSessionId, totalCost } = data;
+        if (parentSessionId !== ctx.sessionManager.getSessionId() || typeof totalCost !== "number" || !Number.isFinite(totalCost) || totalCost < 0)
+          return;
+        subagentCost = totalCost;
+        requestRender();
+      })
+    );
+    if (footerData?.onBranchChange) {
+      unsubs.push(footerData.onBranchChange(invalidateRender));
+    }
+    const requestSubagentUsage = () => {
+      pi.events.emit("thoth:subagent-usage:request", {
+        parentSessionId: ctx.sessionManager.getSessionId()
+      });
+    };
+    if (pi?.on) {
+      unsubs.push(
+        pi.on("session_start", () => {
+          if (disposed) return;
+          subagentCost = 0;
+          throughput.reset();
+          if (inputBoxEnabled) working.end();
+          refreshSession();
+          requestSubagentUsage();
+        })
+      );
+      if (inputBoxEnabled) {
+        unsubs.push(pi.on("agent_start", working.start));
+        unsubs.push(pi.on("agent_end", working.end));
+      }
+      unsubs.push(
+        pi.on("message_start", (event) => {
+          if (!disposed && event) throughput.observe(event);
+        })
+      );
+      unsubs.push(
+        pi.on("message_end", (event) => {
+          if (disposed) return;
+          if (event) throughput.observe(event);
+          refreshSession();
+        })
+      );
+      unsubs.push(pi.on("turn_end", refreshSession));
+      unsubs.push(pi.on("agent_end", refreshSession));
+      unsubs.push(pi.on("session_compact", refreshSession));
+      unsubs.push(pi.on("model_select", refreshSession));
+      unsubs.push(pi.on("thinking_level_select", invalidateRender));
+    }
+    requestSubagentUsage();
+    return {
+      getStatusSnapshot,
+      render(width) {
+        if (!disposed && inputBoxEnabled) {
+          const focusedTui = tui;
+          const editor = focusedTui.getFocusedComponent?.();
+          const decoration = decorateEditor(editor, {
+            theme,
+            working,
+            getStatusSnapshot,
+            get iconMode() {
+              return config.icons;
+            }
+          });
+          if (decoration && !editorDecorations.has(decoration)) {
+            editorDecorations.add(decoration);
+            requestRender();
+          }
+        }
+        if (width <= 0) return [];
+        const data = getStatusSnapshot();
+        const key = `${width}\0${JSON.stringify(data)}`;
+        if (key === cachedKey) return cachedLines;
+        const line = renderStatusLine(data, {
+          width,
+          mode: config.icons,
+          theme
+        });
+        cachedKey = key;
+        if (line !== cachedLines[0]) cachedLines = line ? [line] : [];
+        return cachedLines;
+      },
+      invalidate: invalidateRender,
+      dispose() {
+        disposed = true;
+        working.dispose();
+        for (const decoration of editorDecorations) decoration.dispose();
+        editorDecorations.clear();
+        for (const unsub of unsubs) {
+          try {
+            unsub();
+          } catch {
+          }
+        }
+        unsubs.length = 0;
+      }
+    };
+  });
+}
+
+// src/tools/file-icons.ts
+import { basename, extname } from "node:path";
+var NERD_FILE_ICONS = {
+  ts: "\uE628",
+  tsx: "\uE7BA",
+  js: "\uE74E",
+  jsx: "\uE7BA",
+  mjs: "\uE74E",
+  cjs: "\uE74E",
+  py: "\uE73C",
+  rs: "\uE7A8",
+  go: "\uE724",
+  java: "\uE738",
+  c: "\uE61E",
+  cpp: "\uE61D",
+  h: "\uE61E",
+  hpp: "\uE61D",
+  cs: "\uE648",
+  html: "\uE736",
+  htm: "\uE736",
+  css: "\uE749",
+  scss: "\uE749",
+  sass: "\uE749",
+  less: "\uE749",
+  vue: "\uE6A0",
+  svelte: "\uE697",
+  json: "\uE60B",
+  yaml: "\uE6A8",
+  yml: "\uE6A8",
+  toml: "\uE6B2",
+  xml: "\uE619",
+  md: "\uE73E",
+  mdx: "\uE73E",
+  sql: "\uE706",
+  sh: "\uE795",
+  bash: "\uE795",
+  zsh: "\uE795",
+  ps1: "\uE70F",
+  psm1: "\uE70F",
+  lua: "\uE620",
+  php: "\uE73D",
+  dart: "\uE798",
+  png: "\uF1C5",
+  jpg: "\uF1C5",
+  jpeg: "\uF1C5",
+  svg: "\uF1C5",
+  webp: "\uF1C5",
+  gif: "\uF1C5",
+  lock: "\uF023",
+  env: "\uE615",
+  dockerfile: "\uE7B0"
+};
+var NERD_NAME_ICONS = {
+  "package.json": "\uE71E",
+  "package-lock.json": "\uE71E",
+  "tsconfig.json": "\uE628",
+  ".gitignore": "\uE702",
+  ".gitattributes": "\uE702",
+  ".env": "\uE615",
+  dockerfile: "\uE7B0",
+  makefile: "\uE615",
+  "readme.md": "\uE73E",
+  license: "\uE60A"
+};
+var ASCII_FILE_ICONS = {
+  ts: "[ts]",
+  tsx: "[ts]",
+  js: "[js]",
+  jsx: "[js]",
+  mjs: "[js]",
+  cjs: "[js]",
+  py: "[py]",
+  rs: "[rs]",
+  go: "[go]",
+  json: "{ }",
+  yaml: "{ }",
+  yml: "{ }",
+  toml: "{ }",
+  xml: "< >",
+  md: "[md]",
+  mdx: "[md]",
+  html: "< >",
+  htm: "< >",
+  css: "{ }",
+  sh: "$",
+  bash: "$",
+  zsh: "$",
+  ps1: "PS",
+  psm1: "PS",
+  png: "[img]",
+  jpg: "[img]",
+  jpeg: "[img]",
+  svg: "[img]",
+  gif: "[img]",
+  webp: "[img]",
+  lock: "[lock]",
+  env: "[env]"
+};
+function getFileIcon(filePath, mode) {
+  if (filePath.endsWith("/") || filePath.endsWith("\\")) {
+    return icon("folder", mode);
+  }
+  const name = basename(filePath).toLowerCase();
+  const ext = extname(name).replace(/^\./, "").toLowerCase();
+  if (mode === "ascii") {
+    if (ASCII_FILE_ICONS[ext]) return ASCII_FILE_ICONS[ext];
+    return icon("file", mode);
+  }
+  if (NERD_NAME_ICONS[name]) return NERD_NAME_ICONS[name];
+  if (NERD_FILE_ICONS[ext]) return NERD_FILE_ICONS[ext];
+  return icon("file", mode);
+}
+function getDirIcon(mode) {
+  return icon("folder", mode);
+}
+function getToolIcon(tool, mode) {
+  return icon(tool, mode);
+}
+
+// src/tools/bash.ts
+var COLLAPSED_OUTPUT_LINES = 5;
+var BASH_CONFIG = {
+  toolName: "bash",
+  title: "Bash",
+  prompt: "$ "
+};
+var POWERSHELL_CONFIG = {
+  toolName: "powershell",
+  title: "PowerShell",
+  prompt: "PS> "
+};
+function extractShellExitCode(result, textOutput, isErr) {
+  const structured = result.structuredContent;
+  if (typeof structured?.exit_code === "number") {
+    return structured.exit_code;
+  }
+  if (!isErr) return 0;
+  const lastLine = textOutput.trimEnd().split("\n").at(-1) ?? "";
+  const match = /^Command exited with code (\d+)$/.exec(lastLine);
+  return match ? Number.parseInt(match[1], 10) : 1;
+}
+function createCustomShellTool(shellConfig, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const command = String(args.command ?? "").trim();
+      const icon2 = getToolIcon(shellConfig.toolName, config.icons);
+      const borderTone = context?.isPartial ? "accent" : getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const cmdLines = command ? command.split("\n") : [""];
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", icon2)} ${theme.bold ? theme.bold(theme.fg("toolTitle", shellConfig.title)) : theme.fg("toolTitle", shellConfig.title)}`;
+        const preview = cmdLines.map(
+          (l) => `${theme.fg("dim", shellConfig.prompt)}${theme.fg("text", l)}`
+        );
+        if (hasToolResult(context)) {
+          return [
+            ...renderFrameTop(theme, title, safeWidth, borderTone),
+            ...preview.flatMap(
+              (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+            ),
+            ...renderFrameDivider(theme, "Output", safeWidth, borderTone)
+          ];
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...preview.flatMap(
+            (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const isPartial = Boolean(options?.isPartial);
+      const borderTone = isPartial ? "accent" : getToolBorderTone({ isError: isErr, isPartial });
+      syncElapsedTicker({ ...context, isPartial });
+      const textOutput = getResultText(result);
+      const allLines = textOutput ? textOutput.split("\n") : [];
+      const lineCount = allLines.length;
+      const exitNum = extractShellExitCode(result, textOutput, isErr);
+      const exitStr = `Exit ${exitNum}`;
+      const words = textOutput.trim() ? textOutput.trim().split(/\s+/).length : 0;
+      const wordsStr = words > 0 ? `~${words} words` : "";
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(
+          theme,
+          {
+            status: isPartial ? "running" : isErr ? "failed" : "completed",
+            context: { ...context, isPartial },
+            summary: [
+              exitStr,
+              `${lineCount} ${lineCount === 1 ? "line" : "lines"}`,
+              wordsStr
+            ]
+          },
+          config.icons
+        );
+        if (allLines.length === 0) {
+          const emptyBody = [theme.fg("dim", "(no output)")];
+          return [
+            ...emptyBody.flatMap(
+              (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const visibleLines = options?.expanded ? allLines : allLines.slice(0, COLLAPSED_OUTPUT_LINES);
+        const bodyLines = visibleLines.map((l) => {
+          const sanitized = escapeOutputRow(l);
+          return isErr ? theme.fg("error", sanitized) : theme.fg("toolOutput", sanitized);
+        });
+        if (!options?.expanded && allLines.length > COLLAPSED_OUTPUT_LINES) {
+          const remaining = allLines.length - COLLAPSED_OUTPUT_LINES;
+          bodyLines.push(
+            theme.fg(
+              "dim",
+              `${icon("ellipsis", config.icons)} ${remaining} more lines ${icon("separator", config.icons)} ctrl+o to expand`
+            )
+          );
+        }
+        return [
+          ...bodyLines.flatMap(
+            (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+function createCustomBashTool(_cwd, config) {
+  return createCustomShellTool(BASH_CONFIG, config);
+}
+function createCustomPowerShellTool(_cwd, config) {
+  return createCustomShellTool(POWERSHELL_CONFIG, config);
+}
+
+// src/tools/edit.ts
+var COLLAPSED_DIFF_LINES = 6;
+function parseDiffStats(diffText) {
+  let additions = 0;
+  let removals = 0;
+  const lines = diffText.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("+")) additions++;
+    else if (line.startsWith("-")) removals++;
+  }
+  return { additions, removals };
+}
+function colorDiffLine(line, theme) {
+  if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@")) {
+    return theme.fg("dim", line);
+  }
+  if (line.startsWith("+")) {
+    return theme.fg("toolDiffAdded", line);
+  }
+  if (line.startsWith("-")) {
+    return theme.fg("toolDiffRemoved", line);
+  }
+  return theme.fg("toolDiffContext", line);
+}
+function createCustomEditTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const rawPath = String(args.path ?? args.file_path ?? "");
+      const filePath = formatDisplayPath(rawPath, context?.cwd ?? cwd);
+      const icon2 = getFileIcon(filePath, config.icons);
+      const editIcon = getToolIcon("edit", config.icons);
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", editIcon)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "Edit")) : theme.fg("toolTitle", "Edit")} ${theme.fg("accent", icon2)} ${theme.fg("text", filePath)}`;
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const details = result.details;
+      const diffText = details?.diff ?? getResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", diffText || "Edit failed")}`;
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(
+              theme,
+              toolFooter(theme, footerOptions, config.icons),
+              safeWidth,
+              borderTone
+            )
+          ];
+        });
+      }
+      const { additions, removals } = parseDiffStats(diffText);
+      const diffLines = diffText ? diffText.split("\n") : [];
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const addedStr = additions > 0 ? theme.fg("toolDiffAdded", `+${additions}`) : theme.fg("dim", "+0");
+        const removedStr = removals > 0 ? theme.fg("toolDiffRemoved", `-${removals}`) : theme.fg("dim", "-0");
+        const footer = toolFooter(
+          theme,
+          {
+            ...footerOptions,
+            summary: [`${addedStr} ${removedStr}`, "1 file"]
+          },
+          config.icons
+        );
+        if (diffLines.length === 0) {
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", "(no changes)"),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const visibleLines = options?.expanded ? diffLines : diffLines.slice(0, COLLAPSED_DIFF_LINES);
+        const bodyLines = visibleLines.map(
+          (l) => colorDiffLine(l, theme)
+        );
+        if (!options?.expanded && diffLines.length > COLLAPSED_DIFF_LINES) {
+          const remaining = diffLines.length - COLLAPSED_DIFF_LINES;
+          bodyLines.push(
+            theme.fg(
+              "dim",
+              `${icon("ellipsis", config.icons)} ${remaining} more lines ${icon("separator", config.icons)} ctrl+o to expand`
+            )
+          );
+        }
+        return [
+          ...bodyLines.flatMap(
+            (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/find.ts
+import { truncateToWidth as truncateToWidth8 } from "@earendil-works/pi-tui";
+var COLLAPSED_ENTRY_LIMIT = 8;
+function parseFindOutput(text, details) {
+  const output = splitResultNotice(text, details, "find");
+  return {
+    entries: output.text.split("\n").filter((line) => line.length > 0),
+    notices: output.notices
+  };
+}
+function createCustomFindTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const pattern = escapeControlCharacters(String(args.pattern ?? "*"));
+      const rawPath = String(args.path ?? ".");
+      const searchPath = escapeControlCharacters(
+        formatDisplayPath(rawPath, context?.cwd ?? cwd)
+      );
+      const icon2 = getToolIcon("search", config.icons);
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", icon2)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "Find")) : theme.fg("toolTitle", "Find")} ${theme.fg("syntaxString", `"${pattern}"`)} ${theme.fg("dim", "in")} ${theme.fg("text", searchPath)}`;
+        if (!isFramedContext(context)) {
+          return renderBox(theme, [], safeWidth, {
+            title,
+            footer,
+            isError: borderTone === "error",
+            isSuccess: borderTone === "success"
+          });
+        }
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const textOutput = getRawResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", escapeControlCharacters(textOutput || "Find failed"))}`;
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth8(errText, safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        });
+      }
+      const { entries, notices } = parseFindOutput(textOutput, result.details);
+      const total = entries.length;
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (safeWidth === 0) return [];
+        if (total === 0 && notices.length === 0) {
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth8(theme.fg("dim", "no matches found"), safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", "no matches found"),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const rawLines = [];
+        const visible = options?.expanded ? entries : entries.slice(0, COLLAPSED_ENTRY_LIMIT);
+        const remaining = total - visible.length;
+        for (let i = 0; i < visible.length; i++) {
+          const entry = visible[i];
+          const isLast = i === visible.length - 1 && remaining === 0;
+          const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
+          const icon2 = getFileIcon(entry, config.icons);
+          const line = `${theme.fg("dim", branch)} ${theme.fg("accent", icon2)} ${theme.fg("toolOutput", escapeControlCharacters(entry))}`;
+          rawLines.push(line);
+        }
+        if (remaining > 0) {
+          const more = `${theme.fg("dim", "\u2514\u2500")} ${theme.fg("dim", `${icon("ellipsis", config.icons)} ${remaining} more matches ${icon("separator", config.icons)} ctrl+o to expand`)}`;
+          rawLines.push(more);
+        }
+        for (const notice of notices) {
+          rawLines.push(theme.fg("warning", notice));
+        }
+        if (!isFramedContext(context)) {
+          return [
+            ...rawLines.map((line) => truncateToWidth8(`  ${line}`, safeWidth)),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        return [
+          ...rawLines.flatMap(
+            (line) => renderFrameRow(theme, line, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/generic.ts
+var COLLAPSED_OUTPUT_LINES2 = 8;
+var MAX_ARGS_SUMMARY_LENGTH = 500;
+var NESTED_KEYS_SHOWN = 4;
+function formatValue(value) {
+  if (typeof value === "string") return JSON.stringify(value) ?? '""';
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function summarizeValue(value, mode) {
+  if (Array.isArray(value)) return `[${value.length} items]`;
+  if (value !== null && typeof value === "object") {
+    const keys = Object.keys(value);
+    const shown = keys.slice(0, NESTED_KEYS_SHOWN).join(", ");
+    return `{${keys.length > NESTED_KEYS_SHOWN ? `${shown}, ${icon("ellipsis", mode)}` : shown}}`;
+  }
+  return formatValue(value);
+}
+function prettifyJson(text) {
+  const trimmed = text.trim();
+  const first = trimmed[0];
+  if (first !== "{" && first !== "[") return text;
+  try {
+    return JSON.stringify(JSON.parse(trimmed), null, 2);
+  } catch {
+    return text;
+  }
+}
+function summarizeArgs(args, mode = "nerd") {
+  if (args === void 0 || args === null) return "";
+  let summary;
+  if (typeof args === "object" && !Array.isArray(args)) {
+    summary = Object.entries(args).map(([key, value]) => `${key}=${summarizeValue(value, mode)}`).join(" ");
+  } else {
+    summary = formatValue(args);
+  }
+  return escapeControlCharacters(summary.slice(0, MAX_ARGS_SUMMARY_LENGTH));
+}
+function createGenericTool(toolName, config) {
+  const toolIcon = icon("tool", config.icons);
+  const name = escapeControlCharacters(toolName);
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const borderTone = context?.isPartial ? "accent" : getToolBorderTone(context);
+      const argsSummary = summarizeArgs(rawArgs, config.icons);
+      const comp = createComponent((width) => {
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", toolIcon)} ${theme.bold ? theme.bold(theme.fg("toolTitle", name)) : theme.fg("toolTitle", name)}`;
+        const lines = [
+          ...renderFrameTop(theme, title, width, borderTone),
+          ...argsSummary ? renderFrameRow(
+            theme,
+            theme.fg("dim", argsSummary),
+            width,
+            borderTone
+          ) : []
+        ];
+        if (hasToolResult(context)) return lines;
+        return [
+          ...lines,
+          ...renderFrameBottom(theme, footer, width, borderTone)
+        ];
+      });
+      if (context?.state) context.state.callComponent = comp;
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        context.state.callComponent?.invalidate?.();
+      }
+      context?.lastComponent?.invalidate?.();
+      const isErr = Boolean(context?.isError);
+      const isPartial = Boolean(options?.isPartial);
+      const borderTone = isPartial ? "accent" : getToolBorderTone({ isError: isErr, isPartial });
+      syncElapsedTicker({ ...context, isPartial });
+      const text = prettifyJson(getResultText(result));
+      const allLines = text ? text.split("\n") : [];
+      const lineCount = allLines.length;
+      const hasImage = hasImageContent(result);
+      return createComponent((width) => {
+        const footer = toolFooter(
+          theme,
+          {
+            status: isPartial ? "running" : isErr ? "failed" : "completed",
+            context: { ...context, isPartial },
+            summary: `${lineCount} ${lineCount === 1 ? "line" : "lines"}`
+          },
+          config.icons
+        );
+        const visible = options?.expanded ? allLines : allLines.slice(0, COLLAPSED_OUTPUT_LINES2);
+        const body = visible.map((line) => {
+          const sanitized = escapeControlCharacters(line);
+          return isErr ? theme.fg("error", sanitized) : theme.fg("toolOutput", sanitized);
+        });
+        if (!options?.expanded && allLines.length > COLLAPSED_OUTPUT_LINES2) {
+          body.push(
+            theme.fg(
+              "dim",
+              `${icon("ellipsis", config.icons)} ${allLines.length - COLLAPSED_OUTPUT_LINES2} more lines ${icon("separator", config.icons)} ctrl+o to expand`
+            )
+          );
+        }
+        if (body.length === 0 && !hasImage) {
+          body.push(theme.fg("dim", "(no output)"));
+        }
+        return [
+          ...body.flatMap(
+            (line) => renderFrameRow(theme, line, width, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, width, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/grep.ts
+import { truncateToWidth as truncateToWidth9 } from "@earendil-works/pi-tui";
+function getGrepCandidates(rawLine, isContext) {
+  const candidates = [];
+  const delimiterPattern = isContext ? /(?=-(\d+)-)/g : /(?=:(\d+):)/g;
+  for (const delimiter of rawLine.matchAll(delimiterPattern)) {
+    const file = rawLine.slice(0, delimiter.index);
+    if (!file) continue;
+    candidates.push({
+      file,
+      line: delimiter[1],
+      content: rawLine.slice(delimiter.index + delimiter[1].length + 2),
+      isContext
+    });
+  }
+  return candidates;
+}
+function parseGrepOutput(text, details) {
+  const output = splitResultNotice(text, details, "grep");
+  const lines = output.text || output.notices.length > 0 ? output.text.split("\n") : [];
+  const metadata = details && typeof details === "object" ? details : void 0;
+  const rawResult = {
+    raw: true,
+    rawLines: lines,
+    notices: output.notices
+  };
+  if (typeof metadata?.matchLimitReached === "number" || metadata?.truncation?.truncated === true || metadata?.linesTruncated === true) {
+    return rawResult;
+  }
+  const matches = [];
+  for (const rawLine of lines) {
+    const candidates = [
+      ...getGrepCandidates(rawLine, false),
+      ...getGrepCandidates(rawLine, true)
+    ];
+    if (candidates.length !== 1) return rawResult;
+    matches.push(candidates[0]);
+  }
+  return { raw: false, matches };
+}
+function groupMatches(matches) {
+  const groups = [];
+  for (const m of matches) {
+    const previous = groups.at(-1);
+    if (previous?.[0] === m.file) {
+      previous[1].push(m);
+    } else {
+      groups.push([m.file, [m]]);
+    }
+  }
+  return groups;
+}
+function createCustomGrepTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const pattern = escapeControlCharacters(String(args.pattern ?? ""));
+      const rawPath = args.path ? String(args.path) : "";
+      const searchPath = rawPath ? ` in ${escapeControlCharacters(formatDisplayPath(rawPath, context?.cwd ?? cwd))}` : "";
+      const icon2 = getToolIcon("search", config.icons);
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", icon2)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "Grep")) : theme.fg("toolTitle", "Grep")} ${theme.fg("syntaxString", `"${pattern}"`)}${theme.fg("dim", searchPath)}`;
+        if (!isFramedContext(context)) {
+          return renderBox(theme, [], safeWidth, {
+            title,
+            footer,
+            isError: borderTone === "error",
+            isSuccess: borderTone === "success"
+          });
+        }
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const textOutput = getRawResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", escapeControlCharacters(textOutput || "Grep failed"))}`;
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth9(errText, safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        });
+      }
+      const output = parseGrepOutput(textOutput, result.details);
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (safeWidth === 0) return [];
+        if (output.raw) {
+          const { rawLines: rawLines2, notices } = output;
+          const visibleRawLines = options?.expanded ? rawLines2 : rawLines2.slice(0, 8);
+          const lines = visibleRawLines.map(
+            (rawLine) => theme.fg("toolOutput", escapeControlCharacters(rawLine))
+          );
+          if (visibleRawLines.length < rawLines2.length) {
+            lines.push(
+              theme.fg(
+                "dim",
+                `${icon("ellipsis", config.icons)} ${rawLines2.length - visibleRawLines.length} more lines ${icon("separator", config.icons)} ctrl+o to expand`
+              )
+            );
+          }
+          if (notices.length > 0) lines.push("");
+          for (const notice of notices) {
+            lines.push(theme.fg("warning", notice));
+          }
+          if (!isFramedContext(context)) {
+            const rawWithPrefix = lines.map((l) => l ? `  ${l}` : "  ");
+            return renderBox(theme, rawWithPrefix, safeWidth, {
+              footer,
+              isSuccess: borderTone === "success"
+            });
+          }
+          return [
+            ...lines.flatMap(
+              (l) => renderFrameRow(theme, l ? `  ${l}` : "  ", safeWidth, borderTone)
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const { matches } = output;
+        const totalItems = matches.length;
+        if (totalItems === 0) {
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth9(theme.fg("dim", "no matches found"), safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", "no matches found"),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const groupEntries = groupMatches(matches);
+        const rawLines = [];
+        const maxGroups = options?.expanded ? groupEntries.length : 3;
+        const visibleGroups = groupEntries.slice(0, maxGroups);
+        let renderedItemCount = 0;
+        for (let gi = 0; gi < visibleGroups.length; gi++) {
+          const [file, fileMatches] = visibleGroups[gi];
+          const isLastGroup = gi === visibleGroups.length - 1 && visibleGroups.length === groupEntries.length;
+          const groupBranch = isLastGroup ? "\u2514\u2500" : "\u251C\u2500";
+          const fileIcon = getFileIcon(file, config.icons);
+          const actualMatches = fileMatches.filter((m) => !m.isContext).length;
+          const matchCountLabel = `(${actualMatches} ${actualMatches === 1 ? "match" : "matches"})`;
+          const fileHeader = `${theme.fg("dim", groupBranch)} ${theme.fg("accent", fileIcon)} ${theme.fg("toolTitle", escapeControlCharacters(file))} ${theme.fg("dim", matchCountLabel)}`;
+          rawLines.push(fileHeader);
+          const maxMatches = options?.expanded ? fileMatches.length : 2;
+          const visibleMatches = fileMatches.slice(0, maxMatches);
+          renderedItemCount += visibleMatches.length;
+          const matchBranchPrefix = isLastGroup ? "     " : `  ${theme.fg("dim", "\u2502")}  `;
+          for (const m of visibleMatches) {
+            const separator2 = m.isContext ? "- " : ": ";
+            const lineNum = theme.fg(
+              "dim",
+              `${m.line.padStart(4, " ")}${separator2}`
+            );
+            const content = theme.fg(
+              m.isContext ? "dim" : "toolOutput",
+              escapeControlCharacters(m.content)
+            );
+            rawLines.push(`${matchBranchPrefix}${lineNum}${content}`);
+          }
+          if (fileMatches.length > visibleMatches.length && !options?.expanded) {
+            const moreFileMatches = fileMatches.length - visibleMatches.length;
+            rawLines.push(
+              `${matchBranchPrefix}${theme.fg("dim", `${icon("ellipsis", config.icons)} ${moreFileMatches} more`)}`
+            );
+          }
+        }
+        const remainingItems = totalItems - renderedItemCount;
+        if (!options?.expanded && (groupEntries.length > maxGroups || remainingItems > 0)) {
+          const hiddenFiles = groupEntries.length - visibleGroups.length;
+          const summary = `${theme.fg("dim", "\u2514\u2500")} ${theme.fg("dim", `${icon("ellipsis", config.icons)} ${remainingItems} more matches across ${hiddenFiles} files ${icon("separator", config.icons)} ctrl+o to expand`)}`;
+          rawLines.push(summary);
+        }
+        if (!isFramedContext(context)) {
+          return [
+            ...rawLines.map((line) => truncateToWidth9(`  ${line}`, safeWidth)),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        return [
+          ...rawLines.flatMap(
+            (line) => renderFrameRow(theme, line, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/ls.ts
+import { truncateToWidth as truncateToWidth10 } from "@earendil-works/pi-tui";
+var COLLAPSED_ENTRY_LIMIT2 = 8;
+function parseLsOutput(text, details) {
+  if (text === "(empty directory)") return { entries: [], notices: [] };
+  const output = splitResultNotice(text, details, "ls");
+  return {
+    entries: output.text.split("\n").filter((line) => line.length > 0),
+    notices: output.notices
+  };
+}
+function createCustomLsTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const rawPath = String(args.path ?? ".");
+      const dirPath = escapeControlCharacters(
+        formatDisplayPath(rawPath, context?.cwd ?? cwd)
+      );
+      const icon2 = getDirIcon(config.icons);
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", icon2)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "List")) : theme.fg("toolTitle", "List")} ${theme.fg("text", dirPath)}`;
+        if (!isFramedContext(context)) {
+          return renderBox(theme, [], safeWidth, {
+            title,
+            footer,
+            isError: borderTone === "error",
+            isSuccess: borderTone === "success"
+          });
+        }
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const textOutput = getRawResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", escapeControlCharacters(textOutput || "Failed to list directory"))}`;
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth10(errText, safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        });
+      }
+      const { entries, notices } = parseLsOutput(textOutput, result.details);
+      const total = entries.length;
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (safeWidth === 0) return [];
+        if (total === 0 && notices.length === 0) {
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth10(theme.fg("dim", "empty directory"), safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+            ];
+          }
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", "empty directory"),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const rawLines = [];
+        const visible = options?.expanded ? entries : entries.slice(0, COLLAPSED_ENTRY_LIMIT2);
+        const remaining = total - visible.length;
+        for (let i = 0; i < visible.length; i++) {
+          const entry = visible[i];
+          const isLast = i === visible.length - 1 && remaining === 0;
+          const branch = isLast ? "\u2514\u2500" : "\u251C\u2500";
+          const isDir = entry.endsWith("/") || entry.endsWith("\\");
+          const icon2 = isDir ? getDirIcon(config.icons) : getFileIcon(entry, config.icons);
+          const line = `${theme.fg("dim", branch)} ${theme.fg("accent", icon2)} ${theme.fg("toolOutput", escapeControlCharacters(entry))}`;
+          rawLines.push(line);
+        }
+        if (remaining > 0) {
+          const more = `${theme.fg("dim", "\u2514\u2500")} ${theme.fg("dim", `${icon("ellipsis", config.icons)} ${remaining} more files ${icon("separator", config.icons)} ctrl+o to expand`)}`;
+          rawLines.push(more);
+        }
+        for (const notice of notices) {
+          rawLines.push(theme.fg("warning", notice));
+        }
+        if (!isFramedContext(context)) {
+          return [
+            ...rawLines.map((line) => truncateToWidth10(`  ${line}`, safeWidth)),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        return [
+          ...rawLines.flatMap(
+            (line) => renderFrameRow(theme, line, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/ownership.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function isOwnedName(name, respectPackages) {
+  return typeof name === "string" && respectPackages.some((pattern) => {
+    if (name === pattern) return true;
+    if (!pattern.endsWith("/*") || pattern.indexOf("*") !== pattern.length - 1) {
+      return false;
+    }
+    const prefix = pattern.slice(0, -1);
+    return name.startsWith(prefix) && name.length > prefix.length;
+  });
+}
+function isMissing(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function createOwnershipResolver(respectPackages, read = (path) => readFileSync2(path, "utf8")) {
+  const cache = /* @__PURE__ */ new Map();
+  return (baseDir) => {
+    const visited = [];
+    let dir = baseDir;
+    let owned = false;
+    for (; ; ) {
+      const hit = cache.get(dir);
+      if (hit !== void 0) {
+        owned = hit;
+        break;
+      }
+      visited.push(dir);
+      try {
+        const manifest = JSON.parse(read(join2(dir, "package.json")));
+        owned = isOwnedName(
+          manifest?.name,
+          respectPackages
+        );
+        break;
+      } catch (error) {
+        if (!(error instanceof Error) || !isMissing(error)) break;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    for (const entry of visited) cache.set(entry, owned);
+    return owned;
+  };
+}
+
+// src/tools/read.ts
+function createCustomReadTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const rawPath = String(args.path ?? args.file_path ?? "");
+      const filePath = formatDisplayPath(rawPath, context?.cwd ?? cwd);
+      const icon2 = getFileIcon(filePath, config.icons);
+      let range = "";
+      if (args.offset !== void 0 || args.limit !== void 0) {
+        const start = args.offset ?? 1;
+        const end = args.limit !== void 0 ? Number(start) + Number(args.limit) - 1 : "";
+        range = `:${start}${end ? `-${end}` : ""}`;
+      }
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", icon2)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "Read")) : theme.fg("toolTitle", "Read")} ${theme.fg("text", `${filePath}${range}`)}`;
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const textOutput = getResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", textOutput || "Failed to read file")}`;
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        });
+      }
+      if (hasImageContent(result)) {
+        const firstTextBlock = result.content?.find(
+          (c) => c && typeof c === "object" && c.type === "text"
+        );
+        const note = firstTextBlock?.text ?? "Read image file";
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", note),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        });
+      }
+      const lines = textOutput ? textOutput.split("\n") : [];
+      const lineCount = lines.length;
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (!options?.expanded) {
+          const summary = `${lineCount} ${lineCount === 1 ? "line" : "lines"} ${icon("separator", config.icons)} ctrl+o to expand`;
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", summary),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        if (lines.length === 0) {
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("dim", "(empty file)"),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        return [
+          ...lines.flatMap(
+            (line) => renderFrameRow(theme, line, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/write.ts
+var COLLAPSED_WRITE_LINES = 6;
+function createCustomWriteTool(cwd, config) {
+  return {
+    renderShell: "self",
+    renderCall(rawArgs, theme, context) {
+      syncElapsedTicker(context);
+      const args = rawArgs ?? {};
+      const rawPath = String(args.path ?? args.file_path ?? "");
+      const filePath = formatDisplayPath(rawPath, context?.cwd ?? cwd);
+      const icon2 = getFileIcon(filePath, config.icons);
+      const writeIcon = getToolIcon("write", config.icons);
+      const borderTone = getToolBorderTone(context);
+      const comp = createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const footer = context?.executionStarted && context.isPartial ? toolFooter(theme, { status: "running", context }, config.icons) : void 0;
+        const title = `${theme.fg("accent", writeIcon)} ${theme.bold ? theme.bold(theme.fg("toolTitle", "Write")) : theme.fg("toolTitle", "Write")} ${theme.fg("accent", icon2)} ${theme.fg("text", filePath)}`;
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+    renderResult(result, options, theme, context) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (context.state.callComponent && typeof context.state.callComponent.invalidate === "function") {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (context?.lastComponent && typeof context.lastComponent.invalidate === "function") {
+        context.lastComponent.invalidate();
+      }
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial ? "running" : isErr ? "failed" : "completed";
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial }
+      };
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial
+      });
+      const textOutput = getResultText(result);
+      if (isErr) {
+        return createComponent((width) => {
+          const safeWidth = Math.max(0, width);
+          const errText = `${theme.fg("error", `${statusIcon("warning", config.icons)} `)}${theme.fg("error", textOutput || "Write failed")}`;
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(
+              theme,
+              toolFooter(theme, footerOptions, config.icons),
+              safeWidth,
+              borderTone
+            )
+          ];
+        });
+      }
+      const writeArgs = context?.args;
+      const content = String(writeArgs?.content ?? "");
+      const contentLines = content ? content.split("\n") : [];
+      const lineCount = contentLines.length || 1;
+      return createComponent((width) => {
+        const safeWidth = Math.max(0, width);
+        const addedStr = theme.fg("toolDiffAdded", `+${lineCount} lines`);
+        const footer = toolFooter(
+          theme,
+          {
+            ...footerOptions,
+            summary: [addedStr, "1 file"]
+          },
+          config.icons
+        );
+        if (contentLines.length === 0) {
+          const defaultMsg = textOutput || "File written";
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg("toolOutput", defaultMsg),
+              safeWidth,
+              borderTone
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+          ];
+        }
+        const visibleLines = options?.expanded ? contentLines : contentLines.slice(0, COLLAPSED_WRITE_LINES);
+        const bodyLines = visibleLines.map(
+          (l) => theme.fg("toolOutput", l)
+        );
+        if (!options?.expanded && contentLines.length > COLLAPSED_WRITE_LINES) {
+          const remaining = contentLines.length - COLLAPSED_WRITE_LINES;
+          bodyLines.push(
+            theme.fg(
+              "dim",
+              `${icon("ellipsis", config.icons)} ${remaining} more lines ${icon("separator", config.icons)} ctrl+o to expand`
+            )
+          );
+        }
+        return [
+          ...bodyLines.flatMap(
+            (l) => renderFrameRow(theme, l, safeWidth, borderTone)
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone)
+        ];
+      });
+    }
+  };
+}
+
+// src/tools/index.ts
+function createToolRendererResolver(pi, config, cwd = process.cwd()) {
+  const renderers = /* @__PURE__ */ new Map([
+    ["read", createCustomReadTool(cwd, config)],
+    ["bash", createCustomBashTool(cwd, config)],
+    ["powershell", createCustomPowerShellTool(cwd, config)],
+    ["ls", createCustomLsTool(cwd, config)],
+    ["grep", createCustomGrepTool(cwd, config)],
+    ["find", createCustomFindTool(cwd, config)],
+    ["edit", createCustomEditTool(cwd, config)],
+    ["write", createCustomWriteTool(cwd, config)]
+  ]);
+  const genericRenderers = /* @__PURE__ */ new Map();
+  const isOwnedBaseDir = createOwnershipResolver(
+    config.tools.respectPackages ?? DEFAULT_RESPECT_PACKAGES
+  );
+  const canRespectDownstream = (toolName) => {
+    const tool = typeof pi.getAllTools === "function" ? pi.getAllTools().find((t) => t.name === toolName) : void 0;
+    if (!tool) return true;
+    const baseDir = tool.sourceInfo?.baseDir;
+    return baseDir ? isOwnedBaseDir(baseDir) : false;
+  };
+  return (toolName, next) => {
+    const builtIn = renderers.get(toolName);
+    if (builtIn) return builtIn;
+    const downstream = next();
+    if ((downstream?.renderCall || downstream?.renderResult) && canRespectDownstream(toolName)) {
+      return downstream;
+    }
+    let generic = genericRenderers.get(toolName);
+    if (!generic) {
+      generic = createGenericTool(toolName, config);
+      genericRenderers.set(toolName, generic);
+    }
+    return generic;
+  };
+}
+function registerTools(pi, config, cwd = process.cwd(), owner = {}, resolveToolRenderers) {
+  if (!config.tools.enabled || typeof pi?.registerToolRenderer !== "function") {
+    return () => {
+    };
+  }
+  pi.registerToolRenderer(
+    resolveToolRenderers ?? createToolRendererResolver(pi, config, cwd)
+  );
+  const unsubs = [];
+  if (typeof pi?.on === "function") {
+    unsubs.push(
+      pi.on("agent_end", (_event, ctx) => {
+        if (ctx.hasUI) stopElapsedTickers(owner);
+      })
+    );
+    unsubs.push(
+      pi.on("session_shutdown", (_event, ctx) => {
+        if (!ctx.hasUI) return;
+        stopElapsedTickers(owner);
+        releaseElapsedTickerOwner(owner);
+      })
+    );
+    unsubs.push(
+      pi.on("session_start", (_event, ctx) => {
+        if (!ctx.hasUI) return;
+        stopElapsedTickers(owner);
+        activateElapsedTickerOwner(owner);
+      })
+    );
+  }
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    stopElapsedTickers(owner);
+    releaseElapsedTickerOwner(owner);
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+  };
+}
+
+// src/welcome/index.ts
+import { VERSION as PI_VERSION2 } from "@earendil-works/pi-coding-agent";
+
+// src/welcome/render.ts
+import { truncateToWidth as truncateToWidth11, visibleWidth as visibleWidth7 } from "@earendil-works/pi-tui";
+
+// src/welcome/logo.ts
+var THOTH_LOGO_NERD = [
+  "     \u2584\u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2584\u2584     ",
+  "   \u2584\u2588\u2588\u2580\u2580    \u2580\u2580\u2588\u2588\u2584   ",
+  "  \u2588\u2588\u2588  \u2584\u2588\u2588\u2588\u2588\u2584  \u2588\u2588\u2588  ",
+  " \u2590\u2588\u2588\u258C \u2590\u2588\u2588\u2588\u2588\u2588\u2588\u258C \u2590\u2588\u2588\u258C ",
+  "  \u2588\u2588\u2588  \u2580\u2588\u2588\u2588\u2588\u2580  \u2588\u2588\u2588  ",
+  "   \u2580\u2588\u2588\u2584\u2584 \u2580\u2580 \u2584\u2584\u2588\u2588\u2580   ",
+  "     \u2580\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2580\u2580     ",
+  "         \u2588\u2588 \u2580\u2584      ",
+  "         \u2588\u2588   \u2580\u2584    "
+];
+var THOTH_LOGO_ASCII = [
+  "      .-------.     ",
+  "     /  .---.  \\    ",
+  "   ,-' ( (o) )  `-. ",
+  "  <____ `---'  ____>",
+  "       `-------'    ",
+  "           | \\      ",
+  "           |  \\     "
+];
+function getThothLogoLines(mode) {
+  return mode === "ascii" ? THOTH_LOGO_ASCII : THOTH_LOGO_NERD;
+}
+
+// src/welcome/render.ts
+function color(theme, token, text) {
+  if (!text) return "";
+  if (theme?.fg) {
+    try {
+      return theme.fg(token, text);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+function bold(theme, text) {
+  if (!text) return "";
+  if (theme?.bold) {
+    try {
+      return theme.bold(text);
+    } catch {
+      return text;
+    }
+  }
+  return text;
+}
+function separator(mode) {
+  const pad = mode === "ascii" ? " " : "  ";
+  return `${pad}${icon("separator", mode)}${pad}`;
+}
+function padEnd(text, width, ellipsis) {
+  const current = visibleWidth7(text);
+  if (current > width) return truncateToWidth11(text, width, ellipsis);
+  return text + " ".repeat(Math.max(0, width - current));
+}
+function center(text, width, ellipsis) {
+  const current = visibleWidth7(text);
+  if (current > width) return truncateToWidth11(text, width, ellipsis);
+  const left = Math.floor((width - current) / 2);
+  const right = width - current - left;
+  return " ".repeat(left) + text + " ".repeat(right);
+}
+function formatResourceSummary(theme, resources, sep2) {
+  const parts = [];
+  const cText = (s) => color(theme, "text", s);
+  const cSuccess = (s) => color(theme, "success", s);
+  const cDim = (s) => color(theme, "dim", s);
+  if (typeof resources.tools === "number") {
+    parts.push(cText("tools ") + cSuccess(String(resources.tools)));
+  }
+  if (typeof resources.skills === "number") {
+    parts.push(cText("skills ") + cSuccess(String(resources.skills)));
+  }
+  if (typeof resources.extensions === "number") {
+    parts.push(cText("exts ") + cSuccess(String(resources.extensions)));
+  }
+  return parts.join(cDim(sep2));
+}
+function buildTips(theme, mode) {
+  const bullet = mode === "ascii" ? "*" : "\u2022";
+  const sep2 = separator(mode);
+  const cDim = (s) => color(theme, "dim", s);
+  const cMuted = (s) => color(theme, "muted", s);
+  return [
+    ` ${cDim(bullet)} ${cMuted("/ for commands")}${cDim(sep2)}${cMuted("! for bash")}`
+  ];
+}
+function buildProviderRows(theme, providers, mode, maxWidth) {
+  const bullet = mode === "ascii" ? "*" : "\u25CF";
+  const cSuccess = (s) => color(theme, "success", s);
+  const cMuted = (s) => color(theme, "muted", s);
+  const cDim = (s) => color(theme, "dim", s);
+  if (providers.length === 0) {
+    return [` ${cDim("No tool providers")}`];
+  }
+  return providers.slice(0, 4).map((p) => {
+    const mark = cSuccess(bullet);
+    const name = cMuted(p.name);
+    const prefixWidth = visibleWidth7(` ${bullet} ${p.name}: `);
+    const detailWidth = Math.max(1, maxWidth - prefixWidth);
+    const detail = cDim(
+      truncateToWidth11(p.detail, detailWidth, icon("ellipsis", mode))
+    );
+    return ` ${mark} ${name} ${detail}`;
+  });
+}
+function buildSessionRows(theme, sessions, mode, maxWidth) {
+  const bullet = mode === "ascii" ? "*" : "\u2022";
+  const cDim = (s) => color(theme, "dim", s);
+  const cMuted = (s) => color(theme, "muted", s);
+  if (sessions.length === 0) {
+    return [` ${cDim("No recent sessions")}`];
+  }
+  return sessions.slice(0, 4).map((s) => {
+    const age = ` (${s.timeAgo})`;
+    const ageWidth = visibleWidth7(age);
+    const bulletPrefix = ` ${bullet} `;
+    const maxNameWidth = Math.max(
+      1,
+      maxWidth - visibleWidth7(bulletPrefix) - ageWidth
+    );
+    const name = cMuted(
+      truncateToWidth11(s.name, maxNameWidth, icon("ellipsis", mode))
+    );
+    return ` ${cDim(bullet)} ${name}${cDim(age)}`;
+  });
+}
+function renderWelcomeHeader(theme, data, width, mode = "nerd") {
+  if (width <= 0) return [];
+  const isAscii = mode === "ascii";
+  const cAccent = (s) => color(theme, "accent", s);
+  const cDim = (s) => color(theme, "dim", s);
+  const cMuted = (s) => color(theme, "muted", s);
+  const cText = (s) => color(theme, "text", s);
+  const bTl = isAscii ? "+" : "\u256D";
+  const bTr = isAscii ? "+" : "\u256E";
+  const bBl = isAscii ? "+" : "\u2570";
+  const bBr = isAscii ? "+" : "\u256F";
+  const bV = isAscii ? "|" : "\u2502";
+  const bH = isAscii ? "-" : "\u2500";
+  const sep2 = separator(mode);
+  const ellipsis = icon("ellipsis", mode);
+  const mark = isAscii ? "*" : "\u25C6";
+  if (width >= 64) {
+    const boxWidth = width;
+    const contentWidth = boxWidth - 3;
+    const logoLines = getThothLogoLines(mode);
+    const logoWidth = Math.max(...logoLines.map((l) => visibleWidth7(l)));
+    const leftColumn = Math.max(logoWidth + 2, 24);
+    const rightColumn = contentWidth - leftColumn;
+    if (rightColumn >= 30) {
+      const leftRows = [
+        "",
+        center(bold(theme, cAccent("T H O T H")), leftColumn, ellipsis),
+        "",
+        ...logoLines.map((line) => center(cAccent(line), leftColumn, ellipsis)),
+        "",
+        center(cText(data.model || "pi-coding-agent"), leftColumn, ellipsis),
+        center(cDim(data.provider || ""), leftColumn, ellipsis)
+      ];
+      const resourceSummary = formatResourceSummary(theme, data.resources, sep2);
+      const rightDivider = ` ${cDim(bH.repeat(Math.max(1, rightColumn - 2)))}`;
+      const resourceHeader = resourceSummary ? ` ${cAccent(mark)} ${bold(theme, cAccent("Resources"))}  ${resourceSummary}` : ` ${cAccent(mark)} ${bold(theme, cAccent("Resources"))}`;
+      const rightRows = [
+        resourceHeader,
+        rightDivider,
+        ` ${cAccent(mark)} ${bold(theme, cAccent("Tool Providers"))}`,
+        ...buildProviderRows(theme, data.providers, mode, rightColumn),
+        rightDivider,
+        ` ${cAccent(mark)} ${bold(theme, cAccent("Recent Sessions"))}`,
+        ...buildSessionRows(theme, data.sessions, mode, rightColumn),
+        rightDivider,
+        ...buildTips(theme, mode)
+      ];
+      const maxRows = Math.max(leftRows.length, rightRows.length);
+      while (leftRows.length < maxRows) leftRows.push("");
+      while (rightRows.length < maxRows) rightRows.push("");
+      const label = ` v${data.version} `;
+      const lead = bH.repeat(3);
+      const remainingFill = Math.max(
+        0,
+        boxWidth - 2 - visibleWidth7(lead) - visibleWidth7(label)
+      );
+      const topBorder = `${cDim(bTl)}${cDim(lead)}${cAccent(label)}${cDim(bH.repeat(remainingFill))}${cDim(bTr)}`;
+      const bottomBorder = `${cDim(bBl)}${cDim(bH.repeat(boxWidth - 2))}${cDim(bBr)}`;
+      const out = [topBorder];
+      for (let i = 0; i < maxRows; i++) {
+        const leftCell = padEnd(leftRows[i] ?? "", leftColumn, ellipsis);
+        const rightCell = padEnd(rightRows[i] ?? "", rightColumn, ellipsis);
+        out.push(`${cDim(bV)}${leftCell}${cDim(bV)}${rightCell}${cDim(bV)}`);
+      }
+      out.push(bottomBorder);
+      return out.map(
+        (line) => visibleWidth7(line) <= width ? line : truncateToWidth11(line, width, ellipsis)
+      );
+    }
+  }
+  if (width >= 42) {
+    const boxWidth = width;
+    const innerWidth = boxWidth - 2;
+    const label = ` Thoth v${data.version} `;
+    const lead = bH.repeat(2);
+    const remainingFill = Math.max(
+      0,
+      boxWidth - 2 - visibleWidth7(lead) - visibleWidth7(label)
+    );
+    const topBorder = `${cDim(bTl)}${cDim(lead)}${cAccent(label)}${cDim(bH.repeat(remainingFill))}${cDim(bTr)}`;
+    const bottomBorder = `${cDim(bBl)}${cDim(bH.repeat(boxWidth - 2))}${cDim(bBr)}`;
+    const divider = `${cDim(bV)} ${cDim(bH.repeat(Math.max(1, innerWidth - 2)))} ${cDim(bV)}`;
+    const resourceSummary = formatResourceSummary(theme, data.resources, sep2);
+    const content = [
+      center(bold(theme, cAccent("T H O T H")), innerWidth, ellipsis),
+      center(cText(data.model || "pi-coding-agent"), innerWidth, ellipsis),
+      divider,
+      ...resourceSummary ? [` ${cAccent(mark)} ${resourceSummary}`, divider] : [],
+      ` ${cAccent(mark)} ${bold(theme, cAccent("Recent Sessions"))}`,
+      ...buildSessionRows(theme, data.sessions, mode, innerWidth)
+    ];
+    const out = [topBorder];
+    for (const row of content) {
+      if (row === divider) {
+        out.push(divider);
+      } else {
+        out.push(`${cDim(bV)}${padEnd(row, innerWidth, ellipsis)}${cDim(bV)}`);
+      }
+    }
+    out.push(bottomBorder);
+    return out.map(
+      (line) => visibleWidth7(line) <= width ? line : truncateToWidth11(line, width, ellipsis)
+    );
+  }
+  const lines = [
+    cAccent(bold(theme, `Thoth v${data.version}`)),
+    cText(truncateToWidth11(data.model || "ready", width, ellipsis))
+  ];
+  const narrowParts = [];
+  if (typeof data.resources.tools === "number") {
+    narrowParts.push(`tools:${data.resources.tools}`);
+  }
+  if (typeof data.resources.skills === "number") {
+    narrowParts.push(`skills:${data.resources.skills}`);
+  }
+  if (typeof data.resources.extensions === "number") {
+    narrowParts.push(`exts:${data.resources.extensions}`);
+  }
+  if (narrowParts.length > 0) {
+    lines.push(cDim(narrowParts.join(" ")));
+  }
+  if (data.sessions.length > 0) {
+    const s = data.sessions[0];
+    if (s) {
+      lines.push(cMuted(truncateToWidth11(`* ${s.name}`, width, ellipsis)));
+    }
+  }
+  return lines.map(
+    (line) => visibleWidth7(line) <= width ? line : truncateToWidth11(line, width, ellipsis)
+  );
+}
+
+// src/welcome/resources.ts
+import {
+  VERSION as PI_VERSION,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+
+// src/welcome/age.ts
+function formatAge(fromMs, nowMs = Date.now()) {
+  const seconds = Math.max(0, Math.round((nowMs - fromMs) / 1e3));
+  if (seconds < 60) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  return `${Math.round(days / 30)}mo ago`;
+}
+
+// src/welcome/resources.ts
+function toolSourceLabel(sourceInfo) {
+  if (!sourceInfo || typeof sourceInfo !== "object") return "core";
+  const source = typeof sourceInfo.source === "string" ? sourceInfo.source : "";
+  if (source === "builtin" || source === "core") return "core";
+  if (source === "sdk") return "sdk";
+  if (source.startsWith("npm:")) return source.slice("npm:".length) || source;
+  if (source.startsWith("git:")) return source.replace(/\.git(?:#.*)?$/i, "");
+  const baseDir = typeof sourceInfo.baseDir === "string" ? sourceInfo.baseDir : "";
+  if (baseDir) {
+    const parts = baseDir.replace(/\\/g, "/").split("/").filter(Boolean);
+    return parts[parts.length - 1] || "extension";
+  }
+  const path = typeof sourceInfo.path === "string" ? sourceInfo.path : "";
+  if (path) {
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    const last = parts[parts.length - 1] || "extension";
+    return last.replace(/\.(?:ts|js|mjs|cjs)$/i, "");
+  }
+  return source || "extension";
+}
+function groupToolDetails(tools) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    if (!tool || typeof tool.name !== "string") continue;
+    const name = tool.name.trim();
+    if (!name) continue;
+    const label = toolSourceLabel(tool.sourceInfo);
+    let list = groups.get(label);
+    if (!list) {
+      list = [];
+      groups.set(label, list);
+    }
+    list.push(name);
+  }
+  const result = [];
+  const sortedKeys = Array.from(groups.keys()).sort((a, b) => {
+    if (a === "core") return -1;
+    if (b === "core") return 1;
+    return a.localeCompare(b);
+  });
+  for (const key of sortedKeys) {
+    const toolNames = (groups.get(key) || []).sort();
+    const sample = toolNames.slice(0, 3).join("  ");
+    const remaining = toolNames.length > 3 ? `  +${toolNames.length - 3}` : "";
+    result.push({
+      name: key,
+      detail: `${sample}${remaining}`
+    });
+  }
+  return result.slice(0, 4);
+}
+async function fetchRecentSessions(cwd, limit = 4, mode = "nerd") {
+  try {
+    const sessions = await SessionManager.list(cwd);
+    const sorted = [...sessions].sort(
+      (a, b) => (b.modified?.getTime?.() ?? 0) - (a.modified?.getTime?.() ?? 0)
+    );
+    const out = [];
+    for (const session of sorted) {
+      if (out.length >= limit) break;
+      const rawTitle = session.name?.trim() || session.firstMessage?.trim() || "Untitled session";
+      const cleanTitle = Array.from(rawTitle).map((c) => {
+        const code = c.charCodeAt(0);
+        return code < 32 || code === 127 ? " " : c;
+      }).join("").replace(/\s+/g, " ").trim();
+      const title = cleanTitle.length > 45 ? `${cleanTitle.slice(0, 44)}${icon("ellipsis", mode)}` : cleanTitle;
+      const timeAgo = formatAge(
+        session.modified ? session.modified.getTime() : Date.now()
+      );
+      out.push({ name: title, timeAgo });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function collectStartupResources(pi, ctx, options) {
+  let tools = [];
+  let toolsCount;
+  if (typeof pi.getAllTools === "function") {
+    try {
+      tools = pi.getAllTools() ?? [];
+      toolsCount = tools.length;
+    } catch {
+    }
+  } else if (typeof pi.getActiveTools === "function") {
+    try {
+      const active = pi.getActiveTools() ?? [];
+      toolsCount = active.length;
+    } catch {
+    }
+  }
+  const providers = groupToolDetails(tools);
+  const loader = options?.resourceLoader ?? ctx?.resourceLoader ?? pi?.resourceLoader ?? ctx?.session?.resourceLoader;
+  let skillsCount;
+  if (options?.skillCountLister) {
+    skillsCount = options.skillCountLister(ctx.cwd);
+  } else if (loader?.getSkills) {
+    try {
+      const skillsRes = loader.getSkills();
+      if (skillsRes && Array.isArray(skillsRes.skills)) {
+        skillsCount = skillsRes.skills.length;
+      }
+    } catch {
+    }
+  } else if (typeof pi.getCommands === "function") {
+    try {
+      const commands = pi.getCommands();
+      if (Array.isArray(commands)) {
+        const skillCommands = commands.filter(
+          (c) => c?.source === "skill" || typeof c?.name === "string" && c.name.startsWith("skill:")
+        );
+        skillsCount = skillCommands.length;
+      }
+    } catch {
+    }
+  }
+  let extensionsCount;
+  if (options?.extensionCountLister) {
+    extensionsCount = options.extensionCountLister(ctx.cwd);
+  } else if (loader?.getExtensions) {
+    try {
+      const extRes = loader.getExtensions();
+      if (extRes && Array.isArray(extRes.extensions)) {
+        extensionsCount = extRes.extensions.length;
+      }
+    } catch {
+    }
+  }
+  let sessions = [];
+  if (options?.sessionLister) {
+    sessions = await options.sessionLister(ctx.cwd);
+  } else {
+    sessions = await fetchRecentSessions(ctx.cwd, 4, options?.iconMode);
+  }
+  const modelName = ctx.model?.name || ctx.model?.id;
+  const provider = ctx.model?.provider;
+  return {
+    version: PI_VERSION,
+    model: modelName,
+    provider,
+    resources: {
+      tools: toolsCount,
+      skills: skillsCount,
+      extensions: extensionsCount
+    },
+    providers,
+    sessions
+  };
+}
+
+// src/welcome/index.ts
+var WelcomeComponent = class {
+  data;
+  renderCache;
+  _disposed = false;
+  constructor(theme, config, initialData) {
+    this.data = initialData;
+    this.renderCache = cachedComponent(
+      (width) => renderWelcomeHeader(theme, this.data, width, config.icons)
+    );
+  }
+  get isDisposed() {
+    return this._disposed;
+  }
+  updateData(newData) {
+    if (this._disposed) return;
+    this.data = newData;
+    this.invalidate();
+  }
+  invalidate() {
+    this.renderCache.invalidate();
+  }
+  dispose() {
+    this._disposed = true;
+  }
+  render(width) {
+    return this.renderCache.render(width);
+  }
+};
+function registerWelcome(pi, ctx, config, options) {
+  if (!ctx.hasUI || !ctx.ui?.setHeader) return;
+  const initialData = {
+    version: PI_VERSION2,
+    model: ctx.model?.name || ctx.model?.id,
+    provider: ctx.model?.provider,
+    resources: {
+      tools: typeof pi.getAllTools === "function" ? pi.getAllTools()?.length ?? 0 : typeof pi.getActiveTools === "function" ? pi.getActiveTools()?.length ?? 0 : void 0,
+      skills: typeof pi.getCommands === "function" ? pi.getCommands()?.filter(
+        (c) => c?.source === "skill" || typeof c?.name === "string" && c.name.startsWith("skill:")
+      )?.length ?? void 0 : void 0,
+      extensions: void 0
+    },
+    providers: [],
+    sessions: []
+  };
+  let activeComponent;
+  ctx.ui.setHeader((tui, theme) => {
+    if (activeComponent && !activeComponent.isDisposed) {
+      activeComponent.dispose();
+    }
+    const activeTheme = theme;
+    const component = new WelcomeComponent(activeTheme, config, initialData);
+    activeComponent = component;
+    void collectStartupResources(pi, ctx, {
+      ...options,
+      iconMode: options?.iconMode ?? config.icons
+    }).then((fullData) => {
+      if (!component.isDisposed && activeComponent === component) {
+        component.updateData(fullData);
+        tui?.requestRender?.();
+      }
+    }).catch(() => {
+    });
+    return component;
+  });
+}
+
+// src/index.ts
+function thothTheme(pi) {
+  const config = loadConfig();
+  const owner = {};
+  const cwd = process.cwd();
+  const resolveToolRenderers = config.tools.enabled ? createToolRendererResolver(pi, config, cwd) : void 0;
+  let kitToken;
+  if (resolveToolRenderers) {
+    registerTools(pi, config, cwd, owner, resolveToolRenderers);
+  }
+  pi.on("session_shutdown", (_event, ctx) => {
+    if (!ctx.hasUI || kitToken === void 0) return;
+    withdrawRenderKit(kitToken);
+    kitToken = void 0;
+  });
+  pi.on("session_start", (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    if (config.tools.enabled) {
+      kitToken = registerRenderKit(
+        createRenderKit(owner, resolveToolRenderers, config.icons),
+        owner
+      );
+    }
+    if (!ctx.ui) return;
+    if (config.statusLine.enabled) {
+      if (config.inputBox?.enabled !== false) {
+        ctx.ui.setWorkingIndicator?.({
+          frames: [...frames("workingFrames", config.icons)],
+          intervalMs: 200
+        });
+        ctx.ui.setWorkingMessage?.(`working${icon("ellipsis", config.icons)}`);
+      }
+      registerStatusLine(pi, ctx, config);
+    }
+    if (config.welcome.enabled) registerWelcome(pi, ctx, config);
+  });
+}
+export {
+  thothTheme as default
+};