@ziamana/bruine 0.1.0

package/dist/plugins/render.js

@@ -0,0 +1,3723 @@
+// src/compat.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+function appEnv(suffix, env = process.env) {
+  return env[`BRUINE_${suffix}`] ?? env[`KUMO_${suffix}`];
+}
+function appHome(env = process.env, userHome = homedir(), pathMod = path, exists2 = existsSync) {
+  const explicit = appEnv("HOME", env);
+  if (explicit !== void 0) return explicit;
+  const current = pathMod.join(userHome, ".bruine");
+  const legacy = pathMod.join(userHome, ".kumo");
+  return exists2(current) ? current : exists2(legacy) ? legacy : current;
+}
+function runtimeHome(env = process.env, pathMod = path) {
+  return appEnv("HOME", env) ?? env.DSH_HOME ?? appHome(env, homedir(), pathMod);
+}
+function compatReadPath(currentPath, legacyPath) {
+  return existsSync(currentPath) || !existsSync(legacyPath) ? currentPath : legacyPath;
+}
+function configWritePath(home) {
+  return path.join(home, "bruine.json");
+}
+function configReadPath(home) {
+  return compatReadPath(configWritePath(home), path.join(home, "kumo.json"));
+}
+
+// src/plugins/render.ts
+import { Text as Text4 } from "@earendil-works/pi-tui";
+import { readFileSync as readFileSync14 } from "fs";
+
+// src/plugins/suggest.ts
+import { createAssistantMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
+var MainRequestMemory = class {
+  #last;
+  /**
+   * Look at a request on its way to the model. Only the main conversation's own loop request
+   * counts: it carries the session, it has no auxiliary purpose (titles, compaction), and it
+   * has tools. A request this module builds itself carries no session, so it is never mistaken
+   * for one.
+   */
+  see(options, sessionId) {
+    if (sessionId === void 0 || options.sessionId !== sessionId || options.purpose !== void 0) return;
+    if (typeof options.provider !== "string" || typeof options.model !== "string") return;
+    if (!Array.isArray(options.messages) || options.messages.length === 0) return;
+    this.#last = {
+      provider: options.provider,
+      model: options.model,
+      messages: [...options.messages],
+      ...Array.isArray(options.tools) && options.tools.length > 0 ? { tools: [...options.tools] } : {},
+      ...options.reasoningEffort !== void 0 ? { reasoningEffort: options.reasoningEffort } : {}
+    };
+  }
+  get last() {
+    return this.#last;
+  }
+  /** A new conversation (`/new`, `/resume`) starts from nothing. */
+  clear() {
+    this.#last = void 0;
+  }
+};
+var SUGGEST_INSTRUCTION = "Suggest the user's most likely next message, max 8 words, same language as the user. Reply with the message only.";
+function standaloneInstruction(lastUser, answerExcerpt) {
+  return `${SUGGEST_INSTRUCTION}
+
+Last user prompt: ${lastUser}
+Last answer (excerpt): ${answerExcerpt}`;
+}
+var SOURCE = { kind: "plugin", plugin: "bruine-suggest" };
+function sharedPrefixRequest(last, answer, opts = {}) {
+  const effort = opts.effort ?? last.reasoningEffort;
+  return {
+    provider: last.provider,
+    model: last.model,
+    messages: [
+      ...last.messages,
+      createAssistantMessage({ content: [{ type: "text", text: answer }], source: { provider: last.provider, model: last.model } }),
+      createUserMessage({ content: [{ type: "text", text: SUGGEST_INSTRUCTION }], source: SOURCE })
+    ],
+    ...last.tools !== void 0 ? { tools: last.tools } : {},
+    maxTokens: opts.maxTokens ?? 24,
+    ...effort !== void 0 ? { reasoningEffort: effort } : {}
+  };
+}
+function standaloneRequest(route, lastUser, answerExcerpt, opts = {}) {
+  return {
+    provider: route.provider,
+    model: route.model,
+    messages: [createUserMessage({ content: [{ type: "text", text: standaloneInstruction(lastUser, answerExcerpt) }], source: SOURCE })],
+    maxTokens: opts.maxTokens ?? 24,
+    ...opts.effort !== void 0 ? { reasoningEffort: opts.effort } : {}
+  };
+}
+function shouldSuggest(state2) {
+  return state2.enabled && !state2.plan && state2.lastUser.trim() !== "" && state2.answer.trim() !== "";
+}
+function sameRoute(a, b) {
+  return a.provider === b.provider && a.model === b.model;
+}
+
+// src/ui/palette.ts
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { release as osRelease } from "os";
+
+// src/shared-state.ts
+function sharedState(key, init) {
+  const store = globalThis;
+  const id = /* @__PURE__ */ Symbol.for(`bruine.${key}`);
+  return store[id] ??= init();
+}
+
+// src/ui/palette.ts
+function detectColorDepth(env = process.env, platform3 = process.platform, release = osRelease()) {
+  const forced = appEnv("COLOR", env);
+  if (forced === "truecolor" || forced === "256" || forced === "basic" || forced === "none") return forced;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return "none";
+  if (appEnv("ASCII", env) === "1") return "basic";
+  const ct = (env.COLORTERM ?? "").toLowerCase();
+  if (ct === "truecolor" || ct === "24bit") return "truecolor";
+  if (env.WT_SESSION !== void 0 || env.TERM_PROGRAM === "vscode") return "truecolor";
+  if ((env.TERM ?? "").includes("256color")) return "256";
+  if (platform3 === "win32" && env.TERM === void 0) {
+    const [major, , build] = release.split(".").map(Number);
+    if ((major ?? 0) >= 10 && (build ?? 0) >= 14931) return "truecolor";
+    if ((major ?? 0) >= 10 && (build ?? 0) >= 10586) return "256";
+  }
+  return "basic";
+}
+var NUAGE = {
+  sky: { hex: "#7dcfff", basic: 36 },
+  skyDeep: { hex: "#4aa8e0", basic: 34 },
+  lavender: { hex: "#b4a7ff", basic: 35 },
+  mint: { hex: "#8fe3a3", basic: 32 },
+  amber: { hex: "#f2cf73", basic: 33 },
+  rose: { hex: "#ff7a90", basic: 31 },
+  pink: { hex: "#ff9ed2", basic: 35 },
+  text: { hex: "#e6e9f2", basic: 37 },
+  // 4.8:1 on `chip`, the brightest dark surface it is read on (it was #8a90a6,
+  // 4.37:1 there and 4.41:1 on a One Dark background).
+  muted: { hex: "#9298ae", basic: 90 },
+  // 3.20:1 on `surface`, the AA floor for a border or control. It was #5b6178
+  // (2.64:1), under the floor, and it drew the editor border and the dock
+  // divider. Structure only: anything a user has to read is `muted` (5.10:1).
+  faint: { hex: "#676e87", basic: 90 },
+  // Painted surfaces (the console band and the prompt band). These are the
+  // authored values for a dark terminal; setTerminalBackdrop re-derives them
+  // from the background the terminal reports.
+  surface: { hex: "#1c2030", basic: 40 },
+  chip: { hex: "#262c3f", basic: 40 },
+  // Transcript surfaces: muted text remains above 4.5:1 on every block.
+  userBlock: { hex: "#152a36", basic: 40 },
+  toolOk: { hex: "#152b1e", basic: 40 },
+  toolPending: { hex: "#252830", basic: 40 },
+  toolErr: { hex: "#3a1820", basic: 40 },
+  railActive: { hex: "#afe3ff", basic: 36 },
+  railActiveEnd: { hex: "#8fd4ff", basic: 36 },
+  railErrorEnd: { hex: "#c04a5e", basic: 31 },
+  edge: { hex: "#4aa8e0", basic: 34 },
+  onSky: { hex: "#0c2b3d", basic: 30 },
+  // The two diff bands, on a NEUTRAL block: an added line and a removed line are
+  // the same kind of fact, so they get the same weight. The green is as strong as
+  // the red (it used to be so quiet it vanished into a green card).
+  addBg: { hex: "#17361f", basic: 40 },
+  delBg: { hex: "#3a1820", basic: 40 },
+  addFg: { hex: "#b8f0c6", basic: 32 },
+  delFg: { hex: "#ffb3c0", basic: 31 }
+};
+var INK_FLOOR = {
+  text: 7,
+  muted: 4.5,
+  // Structure only (borders, rules, dots): the 3:1 floor for a mark, not text.
+  faint: 3,
+  sky: 4.5,
+  skyDeep: 4.5,
+  lavender: 4.5,
+  mint: 4.5,
+  amber: 4.5,
+  rose: 4.5,
+  pink: 4.5,
+  railActive: 3,
+  railActiveEnd: 3,
+  railErrorEnd: 3,
+  addFg: 4.5,
+  delFg: 4.5
+};
+var INK_ROLES = Object.keys(INK_FLOOR);
+function rgb(hex) {
+  const n = Number.parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+var state = sharedState("palette", () => ({
+  probed: {},
+  inked: {},
+  depth: void 0
+}));
+var probed = state.probed;
+var inked = state.inked;
+function inkHex(role) {
+  return inked[role] ?? NUAGE[role].hex;
+}
+var CUBE = [0, 95, 135, 175, 215, 255];
+function distance(a, b) {
+  return 2 * (a[0] - b[0]) ** 2 + 4 * (a[1] - b[1]) ** 2 + 3 * (a[2] - b[2]) ** 2;
+}
+function to256(hex, hue = false) {
+  const c2 = rgb(hex);
+  const nearest = (v) => {
+    let best = 0;
+    for (let i = 1; i < CUBE.length; i += 1) if (Math.abs(CUBE[i] - v) < Math.abs(CUBE[best] - v)) best = i;
+    return best;
+  };
+  const [qr, qg, qb] = [nearest(c2[0]), nearest(c2[1]), nearest(c2[2])];
+  const cube = 16 + 36 * qr + 6 * qg + qb;
+  const cubeRgb = [CUBE[qr], CUBE[qg], CUBE[qb]];
+  const level = Math.max(0, Math.min(23, Math.round(((c2[0] + c2[1] + c2[2]) / 3 - 8) / 10)));
+  const grayRgb = [8 + 10 * level, 8 + 10 * level, 8 + 10 * level];
+  const isGray = Math.abs(c2[0] - c2[1]) < 12 && Math.abs(c2[1] - c2[2]) < 12;
+  if (hue && !isGray) {
+    if (cube === 16) return c2[0] >= c2[1] && c2[0] >= c2[2] ? 52 : c2[1] >= c2[2] ? 22 : 17;
+    return cube;
+  }
+  return distance(c2, grayRgb) <= distance(c2, cubeRgb) ? 232 + level : cube;
+}
+var HUE_ROLES = /* @__PURE__ */ new Set(["addBg", "delBg", "toolErr", "sky", "edge"]);
+function fgCode(role, depth) {
+  const sw = typeof role === "string" && role.startsWith("#") ? { hex: role, basic: 37 } : { hex: inkHex(role), basic: NUAGE[role].basic };
+  if (depth === "none") return "";
+  if (depth === "truecolor") {
+    const [r, g, b] = rgb(sw.hex);
+    return `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+  }
+  if (depth === "256") return `\x1B[38;5;${String(to256(sw.hex))}m`;
+  return `\x1B[${String(sw.basic)}m`;
+}
+function bgCode(role, depth) {
+  if (typeof role === "string" && role.startsWith("#")) return bgEscape(role, 40, depth);
+  const sw = NUAGE[role];
+  return bgEscape(probed[role] ?? sw.hex, sw.basic, depth, HUE_ROLES.has(role));
+}
+function bgEscape(hex, basic, depth, hue = false) {
+  if (depth === "none") return "";
+  if (depth === "truecolor") {
+    const [r, g, b] = rgb(hex);
+    return `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
+  }
+  if (depth === "256") return `\x1B[48;5;${String(to256(hex, hue))}m`;
+  return `\x1B[${String(basic + 10)}m`;
+}
+function bgOptOut(env = process.env) {
+  const v = (appEnv("BG", env) ?? "").toLowerCase();
+  return v === "0" || v === "none" || v === "off" || v === "false";
+}
+function bgEnabled(depth = colorDepth()) {
+  if (bgOptOut()) return false;
+  return depth === "truecolor" || depth === "256";
+}
+function colorDepth() {
+  state.depth ??= detectColorDepth();
+  return state.depth;
+}
+function paint(role, s) {
+  const d = colorDepth();
+  if (d === "none") return s;
+  return `${fgCode(role, d)}${s}\x1B[39m`;
+}
+function onBg(role, s) {
+  const d = colorDepth();
+  if (!bgEnabled(d)) return s;
+  return `${bgCode(role, d)}${s}\x1B[49m`;
+}
+
+// src/ui/rain.ts
+var effortState = sharedState("effort", () => ({ level: 0.45, effort: void 0 }));
+function rainLevel() {
+  return effortState.level;
+}
+var DROP_DOTS = ["\u2801", "\u2802", "\u2804", "\u2840"];
+var DROP_ASCII = ["'", "`", ",", "."];
+var DROP_REST = "\u2800";
+var DROP_REST_ASCII = ".";
+function dropSpinner(elapsed, level, ascii = false) {
+  const lv = Math.max(0, Math.min(1, level));
+  const fall = 4;
+  const cycle = fall + Math.round((1 - lv) * 7);
+  const step = Math.floor(Math.max(0, elapsed) / (140 - 60 * lv));
+  const frames = ascii ? DROP_ASCII : DROP_DOTS;
+  let out = "";
+  for (let cell = 0; cell < 3; cell += 1) {
+    const at = (step + cell * 3) % cycle;
+    out += at < fall ? frames[at] : ascii ? DROP_REST_ASCII : DROP_REST;
+  }
+  return out;
+}
+
+// src/render/reasoning.ts
+import stringWidth from "string-width";
+
+// src/render/chars.ts
+var UNICODE_ICONS = {
+  think: "\u2234",
+  prompt: "\u203A",
+  ok: "\u2713",
+  fail: "\u2717",
+  bullet: "\u25CF",
+  spark: "",
+  folder: "\u25B8"
+};
+var ASCII_ICONS = {
+  think: "*",
+  prompt: ">",
+  ok: "v",
+  fail: "x",
+  bullet: ">",
+  spark: "",
+  folder: ">"
+};
+var UTF8_RE = /utf-?8/i;
+var UNICODE_TERMINALS = /* @__PURE__ */ new Set(["vscode", "WezTerm", "ghostty", "iTerm.app", "Apple_Terminal", "Hyper", "Tabby"]);
+function iconsFor(env = process.env, platform3 = process.platform) {
+  if (appEnv("ASCII", env) === "1") return ASCII_ICONS;
+  const locale = `${env.LC_ALL ?? ""}${env.LC_CTYPE ?? ""}${env.LANG ?? ""}`;
+  if (UTF8_RE.test(locale)) return UNICODE_ICONS;
+  if (env.WT_SESSION !== void 0 || UNICODE_TERMINALS.has(env.TERM_PROGRAM ?? "")) return UNICODE_ICONS;
+  if (platform3 === "darwin") return locale === "" ? UNICODE_ICONS : ASCII_ICONS;
+  return ASCII_ICONS;
+}
+function isAscii(icons = iconsFor()) {
+  return icons.think === "*";
+}
+var cached;
+function bruineIcons() {
+  if (cached === void 0) cached = iconsFor();
+  return cached;
+}
+function withoutEmoji(text) {
+  return text.replace(
+    /[\p{Extended_Pictographic}\p{Emoji_Modifier}][\uFE0F\u200D]*(?:[\p{Extended_Pictographic}\p{Emoji_Modifier}][\uFE0F\u200D]*)* ?|[\uFE0F\u200D]/gu,
+    ""
+  );
+}
+
+// src/render/reasoning.ts
+function dim(s) {
+  return `\x1B[2m${s}\x1B[22m`;
+}
+function sanitize(s) {
+  return withoutEmoji(s).replace(/[\x00-\x09\x0b-\x1f\x7f\x80-\x9f]/g, " ");
+}
+function splitReasoningSegments(current, lastFinished, delta) {
+  const input = current + sanitize(delta);
+  let start = 0;
+  let finished = lastFinished;
+  let finishedAny = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const newline = ch === "\n";
+    const punctuation = /[.!?…]/.test(ch) && /\s/.test(input[i + 1] ?? "");
+    if (!newline && !punctuation) continue;
+    const candidate = input.slice(start, newline ? i : i + 1).trim();
+    if (!newline && /\b(?:e\.g|i\.e)\.$/i.test(candidate)) continue;
+    if (candidate !== "") {
+      finished = candidate;
+      finishedAny = true;
+    }
+    start = i + 1;
+  }
+  return { current: input.slice(start).trimStart(), lastFinished: finished, finishedAny };
+}
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function clipCells(text, width, ellipsis = "\u2026") {
+  if (width <= 0) return "";
+  if (stringWidth(text) <= width) return text;
+  const suffix = width >= stringWidth(ellipsis) ? ellipsis : ".".repeat(width);
+  let out = "";
+  let used = 0;
+  for (const { segment } of segmenter.segment(text)) {
+    const cells = stringWidth(segment);
+    if (used + cells > width - stringWidth(suffix)) break;
+    out += segment;
+    used += cells;
+  }
+  return out + suffix;
+}
+var SPINNER_FRAMES = ["\xB7", "\u2722", "\u273A", "\u2736", "\u273B", "\u273D", "\u273B", "\u2736", "\u273A", "\u2722"];
+var ASCII_SPINNER_FRAMES = ["-", "\\", "|", "/"];
+function spinnerFrame(elapsed, icons) {
+  const frames = icons.think === "*" ? ASCII_SPINNER_FRAMES : SPINNER_FRAMES;
+  return frames[Math.floor(Math.max(0, elapsed) / 100) % frames.length];
+}
+function completeWords(current) {
+  if (current.trim() === "") return [];
+  const endsWithSpace = /\s$/.test(current);
+  const parts = current.split(/\s+/).filter((p) => p !== "");
+  if (endsWithSpace) return parts;
+  return parts.slice(0, -1);
+}
+function thinkingWords(words, columns, elapsed, icons) {
+  const prefix = `${dropSpinner(elapsed, rainLevel(), icons.think === "*")} Thinking`;
+  const ellipsis = icons.think === "*" ? "..." : "\u2026";
+  if (words.length === 0) return clipCells(prefix, columns, ellipsis);
+  for (let i = 0; i < words.length; i++) {
+    const candidate = words.slice(i).join(" ");
+    if (stringWidth(`${prefix}  ${candidate}`) <= columns) {
+      return `${prefix}  ${candidate}`;
+    }
+  }
+  const last = words.at(-1) ?? "";
+  const avail = Math.max(0, columns - stringWidth(`${prefix}  `));
+  return `${prefix}  ${clipCells(last, avail, ellipsis)}`;
+}
+var ReasoningLine = class {
+  constructor(screen, now = Date.now, icons = bruineIcons()) {
+    this.screen = screen;
+    this.now = now;
+    this.icons = icons;
+  }
+  screen;
+  now;
+  icons;
+  #active = false;
+  #current = "";
+  #lastFinished = "";
+  #startTime = 0;
+  get active() {
+    return this.#active;
+  }
+  push(delta) {
+    if (delta === "") return;
+    if (!this.#active) {
+      this.#active = true;
+      this.#startTime = this.now();
+    }
+    const split = splitReasoningSegments(this.#current, this.#lastFinished, delta);
+    this.#current = split.current;
+    this.#lastFinished = split.lastFinished;
+  }
+  end() {
+    if (!this.#active) return;
+    const seconds = (this.now() - this.#startTime) / 1e3;
+    this.screen.write(`Thought for ${seconds.toFixed(1)}s
+`);
+    this.#active = false;
+    this.#current = "";
+    this.#lastFinished = "";
+  }
+};
+
+// src/render/text.ts
+var TextStream = class {
+  #screen;
+  #first = true;
+  #lastChar = "";
+  constructor(screen) {
+    this.#screen = screen;
+  }
+  push(delta) {
+    if (delta === "") return;
+    this.#first = false;
+    this.#screen.write(delta);
+    this.#lastChar = delta[delta.length - 1] ?? "";
+  }
+  end() {
+    if (this.#first) return;
+    if (this.#lastChar !== "\n") {
+      this.#screen.write("\n");
+    }
+    this.#first = true;
+    this.#lastChar = "";
+  }
+};
+
+// src/render/tools.ts
+var SUMMARY_KEYS = [
+  "command",
+  "cmd",
+  "path",
+  "file_path",
+  "url",
+  "query",
+  "pattern"
+];
+var MAX_OUTPUT_LINES = 5;
+function truncate(s, max) {
+  if (max <= 1) return "\u2026";
+  if (s.length <= max) return s;
+  return `${s.slice(0, max - 1)}\u2026`;
+}
+function toolSummary(rawArgs, tool, columns) {
+  const max = columns - tool.length - 6;
+  if (rawArgs === "") return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(rawArgs);
+  } catch {
+    return "\u2026";
+  }
+  let text;
+  if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const obj = parsed;
+    const key = SUMMARY_KEYS.find((k) => k in obj);
+    text = key !== void 0 ? String(obj[key]) : JSON.stringify(parsed);
+  } else {
+    text = JSON.stringify(parsed);
+  }
+  return truncate(text, max);
+}
+var ToolCallView = class {
+  #screen;
+  #now;
+  #icons;
+  #calls = /* @__PURE__ */ new Map();
+  constructor(screen, now = Date.now, icons = bruineIcons()) {
+    this.#screen = screen;
+    this.#now = now;
+    this.#icons = icons;
+  }
+  start(id, toolName) {
+    this.#calls.set(id, { tool: toolName, rawArgs: "", startTime: this.#now() });
+  }
+  args(id, jsonDelta) {
+    const call = this.#calls.get(id);
+    if (!call) return;
+    call.rawArgs += jsonDelta;
+  }
+  result(id, ok, output) {
+    const call = this.#calls.get(id);
+    if (!call) return;
+    const seconds = (this.#now() - call.startTime) / 1e3;
+    const summary = this.#summary(call);
+    const mark = ok ? this.#icons.ok : this.#icons.fail;
+    const head = `${mark} ${call.tool}` + (summary !== "" ? `  ${summary}` : "") + `  ${seconds.toFixed(1)}s
+`;
+    this.#screen.write(head);
+    const lines = output.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    for (const line of lines.slice(0, MAX_OUTPUT_LINES)) {
+      this.#screen.write(`  ${line}
+`);
+    }
+    const rest = lines.length - MAX_OUTPUT_LINES;
+    if (rest > 0) {
+      this.#screen.write(`  \u2026 ${rest} more lines
+`);
+    }
+    this.#calls.delete(id);
+  }
+  /** Current header info for a tracked call; used by the approval prompt. */
+  describe(id) {
+    const call = this.#calls.get(id);
+    if (!call) return void 0;
+    return { tool: call.tool, summary: this.#summary(call) };
+  }
+  #summary(call) {
+    return toolSummary(call.rawArgs, call.tool, this.#screen.columns);
+  }
+  #header(call, summary) {
+    return `\u25CF ${call.tool}  ${summary}`;
+  }
+};
+
+// src/render/elapsed.ts
+function formatElapsed(ms) {
+  const seconds = Math.floor(Math.max(0, Number.isFinite(ms) ? ms : 0) / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}min ${String(seconds % 60).padStart(2, "0")}s`;
+  return `${Math.floor(minutes / 60)}h ${String(minutes % 60).padStart(2, "0")}min`;
+}
+
+// src/ui/reasoning-component.ts
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+// src/ui/highlight.ts
+import hljs from "highlight.js/lib/core";
+import bash from "highlight.js/lib/languages/bash";
+import c from "highlight.js/lib/languages/c";
+import cpp from "highlight.js/lib/languages/cpp";
+import css from "highlight.js/lib/languages/css";
+import diff from "highlight.js/lib/languages/diff";
+import go from "highlight.js/lib/languages/go";
+import java from "highlight.js/lib/languages/java";
+import javascript from "highlight.js/lib/languages/javascript";
+import json from "highlight.js/lib/languages/json";
+import markdown from "highlight.js/lib/languages/markdown";
+import python from "highlight.js/lib/languages/python";
+import rust from "highlight.js/lib/languages/rust";
+import sql from "highlight.js/lib/languages/sql";
+import typescript from "highlight.js/lib/languages/typescript";
+import xml from "highlight.js/lib/languages/xml";
+import yaml from "highlight.js/lib/languages/yaml";
+var LANGS = {
+  bash,
+  c,
+  cpp,
+  css,
+  diff,
+  go,
+  java,
+  javascript,
+  json,
+  markdown,
+  python,
+  rust,
+  sql,
+  typescript,
+  xml,
+  yaml
+};
+for (const [name2, lang] of Object.entries(LANGS)) hljs.registerLanguage(name2, lang);
+var ALIASES = {
+  sh: "bash",
+  shell: "bash",
+  zsh: "bash",
+  fish: "bash",
+  console: "bash",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  ts: "typescript",
+  tsx: "typescript",
+  mts: "typescript",
+  py: "python",
+  rs: "rust",
+  yml: "yaml",
+  html: "xml",
+  htm: "xml",
+  svg: "xml",
+  md: "markdown",
+  "c++": "cpp",
+  h: "c",
+  hpp: "cpp"
+};
+var SCOPES = [
+  ["comment", "faint"],
+  ["quote", "faint"],
+  ["keyword", "pink"],
+  ["built_in", "pink"],
+  ["literal", "pink"],
+  ["selector-tag", "pink"],
+  ["string", "mint"],
+  ["regexp", "mint"],
+  ["addition", "mint"],
+  ["deletion", "rose"],
+  ["number", "amber"],
+  ["type", "amber"],
+  ["title.class", "amber"],
+  ["title", "sky"],
+  ["function", "sky"],
+  ["section", "sky"],
+  ["meta", "lavender"],
+  ["symbol", "lavender"],
+  ["attr", "lavender"],
+  ["attribute", "lavender"],
+  ["variable", "text"],
+  ["params", "text"],
+  ["property", "text"]
+];
+function roleFor(classes) {
+  for (let i = classes.length - 1; i >= 0; i--) {
+    const scope = classes[i].replace(/^hljs-/, "").replace(/_+$/, "");
+    for (const [prefix, role] of SCOPES) if (scope === prefix || scope.startsWith(`${prefix}.`) || scope.startsWith(prefix)) return role;
+  }
+  return void 0;
+}
+function unescapeHtml(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#x27;/g, "'").replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+function resolveLanguage(lang) {
+  if (lang === void 0) return void 0;
+  const l = lang.trim().toLowerCase().split(/\s+/)[0] ?? "";
+  if (l === "") return void 0;
+  const name2 = ALIASES[l] ?? l;
+  return hljs.getLanguage(name2) !== void 0 ? name2 : void 0;
+}
+function highlightCode(code, lang) {
+  const language = resolveLanguage(lang);
+  const plainLines = code.split("\n");
+  if (language === void 0 || colorDepth() === "none") return plainLines;
+  let html;
+  try {
+    html = hljs.highlight(code, { language, ignoreIllegals: true }).value;
+  } catch {
+    return plainLines;
+  }
+  const out = [];
+  let line = "";
+  const stack = [];
+  const emit = (text) => {
+    const parts = unescapeHtml(text).split("\n");
+    parts.forEach((part, i) => {
+      if (i > 0) {
+        out.push(line);
+        line = "";
+      }
+      if (part === "") return;
+      const role = roleFor(stack.flat());
+      line += role === void 0 ? part : paint(role, part);
+    });
+  };
+  const re = /<span class="([^"]*)">|<\/span>|([^<]+)/g;
+  let m;
+  while ((m = re.exec(html)) !== null) {
+    if (m[1] !== void 0) stack.push(m[1].split(/\s+/));
+    else if (m[0] === "</span>") stack.pop();
+    else if (m[2] !== void 0) emit(m[2]);
+  }
+  out.push(line);
+  return out;
+}
+
+// src/ui/theme.ts
+var ansi = {
+  dim: (s) => `\x1B[2m${s}\x1B[22m`,
+  gray: (s) => paint("muted", s),
+  faint: (s) => paint("faint", s),
+  cyan: (s) => paint("sky", s),
+  blue: (s) => paint("skyDeep", s),
+  violet: (s) => paint("lavender", s),
+  pink: (s) => paint("pink", s),
+  green: (s) => paint("mint", s),
+  red: (s) => paint("rose", s),
+  yellow: (s) => paint("amber", s),
+  text: (s) => paint("text", s),
+  bold: (s) => `\x1B[1m${s}\x1B[22m`,
+  italic: (s) => `\x1B[3m${s}\x1B[23m`,
+  chip: (s) => bgEnabled() ? onBg("sky", paint("onSky", s)) : paint("sky", s),
+  surface: (s) => onBg("surface", s),
+  chipBg: (s) => onBg("chip", s),
+  /** The 1-column accent that opens every painted surface. */
+  edge: (s) => onBg("edge", s)
+};
+var markdownThemeFor = (icons = bruineIcons()) => {
+  const rule = isAscii(icons) ? "|" : "\u258F";
+  const gutter = `${ansi.faint(rule)} `;
+  return {
+    // skyDeep, and not the sky the links wear: a title and a link are different
+    // jobs, and one accent at a time is what keeps a screen readable.
+    heading: (s) => ansi.bold(ansi.blue(s)),
+    link: (s) => ansi.cyan(s),
+    linkUrl: (s) => ansi.gray(s),
+    code: (s) => ansi.yellow(s),
+    codeBlock: (s) => s,
+    codeBlockBorder: (s) => {
+      const lang = s.replace(/^```/, "").trim();
+      return lang === "" ? gutter : `${gutter}${ansi.gray(lang)}`;
+    },
+    codeBlockIndent: gutter,
+    highlightCode,
+    quote: (s) => ansi.gray(s),
+    quoteBorder: (s) => ansi.gray(s),
+    hr: (s) => ansi.gray(s),
+    listBullet: (s) => ansi.violet(s),
+    bold: (s) => ansi.bold(ansi.text(s)),
+    italic: (s) => ansi.italic(s),
+    strikethrough: (s) => ansi.gray(s),
+    underline: (s) => ansi.cyan(s)
+  };
+};
+
+// src/ui/reasoning-component.ts
+var ReasoningComponent = class {
+  constructor(now = Date.now, icons = bruineIcons()) {
+    this.now = now;
+    this.icons = icons;
+  }
+  now;
+  icons;
+  transcriptStyle = "reasoning";
+  onActivityChange;
+  #current = "";
+  #lastFinished = "";
+  /** Everything the model has said in this thought, kept so it can be read back. */
+  #thought = "";
+  #expanded = false;
+  #startTime = 0;
+  #started = false;
+  #ended = false;
+  #endTime = 0;
+  get active() {
+    return this.#started && !this.#ended;
+  }
+  /** True when a press on this block does something: a finished thought only. */
+  get clickable() {
+    return this.#ended;
+  }
+  /** Open or close the thought. A press on a live thought changes nothing. */
+  click() {
+    if (this.#ended) this.#expanded = !this.#expanded;
+  }
+  push(delta) {
+    if (!delta || this.#ended) return;
+    if (!this.#started) {
+      this.#started = true;
+      this.#startTime = this.now();
+      this.onActivityChange?.(true);
+    }
+    this.#thought += sanitize(delta);
+    const split = splitReasoningSegments(this.#current, this.#lastFinished, delta);
+    this.#current = split.current;
+    this.#lastFinished = split.lastFinished;
+  }
+  end() {
+    if (!this.active) return;
+    this.#ended = true;
+    this.#endTime = this.now();
+    this.onActivityChange?.(false);
+  }
+  render(width) {
+    if (!this.#started) return [];
+    const words = completeWords(this.#current);
+    if (!this.#ended) return [ansi.violet(dim(thinkingWords(words, width, this.now() - this.#startTime, this.icons)))];
+    const head = ansi.gray(dim(clipCells(`${this.icons.think} Thought for ${this.#endTime - this.#startTime < 1e3 ? "<1s" : formatElapsed(this.#endTime - this.#startTime)}`, width)));
+    if (!this.#expanded) return [head];
+    const indent = " ".repeat(2);
+    const body = this.#thought.trim();
+    if (body === "") return [head];
+    const room = Math.max(1, width - indent.length);
+    return [
+      head,
+      ...wrapTextWithAnsi(body, room).map((line) => `${indent}${ansi.gray(ansi.italic(line))}`)
+    ];
+  }
+  invalidate() {
+  }
+};
+
+// src/ui/tool-call-component.ts
+import stringWidth4 from "string-width";
+import { isAbsolute as isAbsolute2, relative, resolve as resolve2 } from "path";
+
+// src/ui/tool-group.ts
+import stringWidth2 from "string-width";
+function formatDurationParts(seconds) {
+  if (!(seconds >= 0.05)) return void 0;
+  if (seconds < 10) return { value: seconds.toFixed(1), unit: "s" };
+  if (seconds < 60) return { value: String(Math.round(seconds)), unit: "s" };
+  const m = Math.floor(seconds / 60);
+  return { value: `${String(m)}m${String(Math.round(seconds % 60)).padStart(2, "0")}`, unit: "s" };
+}
+function formatDuration(seconds) {
+  const parts = formatDurationParts(seconds);
+  return parts === void 0 ? void 0 : `${parts.value}${parts.unit}`;
+}
+
+// src/ui/links.ts
+import { isAbsolute } from "path";
+import { pathToFileURL } from "url";
+function canLink() {
+  return appEnv("NO_LINKS") !== "1";
+}
+function fileLink(text, absolutePath) {
+  if (!canLink() || text === "" || absolutePath === "" || !isAbsolute(absolutePath)) return text;
+  let url;
+  try {
+    url = pathToFileURL(absolutePath).href;
+  } catch {
+    return text;
+  }
+  return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
+
+// src/ui/diff-view.ts
+import { diffLines } from "diff";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import stringWidth3 from "string-width";
+import { visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+var MAX_DIFF_LINES = 12;
+function splitKeep(s) {
+  const parts = s.split("\n");
+  if (parts.at(-1) === "") parts.pop();
+  return parts;
+}
+function lineOf(hay, needle) {
+  if (needle === "") return void 0;
+  const at = hay.indexOf(needle);
+  if (at < 0) return void 0;
+  return hay.slice(0, at).split("\n").length;
+}
+function readAfter(path7) {
+  if (path7 === void 0 || path7 === "") return void 0;
+  try {
+    return readFileSync(resolve(process.cwd(), path7), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function replacement(oldText, newText, start) {
+  const a = splitKeep(oldText);
+  const b = splitKeep(newText);
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head += 1;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail += 1;
+  const lines = [];
+  let added = 0;
+  let removed = 0;
+  let nNew = start;
+  let nOld = start;
+  const ctx = (text) => {
+    lines.push({
+      kind: "ctx",
+      text,
+      ...nNew !== void 0 ? { n: nNew } : {},
+      ...nOld !== void 0 ? { old: nOld } : {}
+    });
+    if (nNew !== void 0) nNew += 1;
+    if (nOld !== void 0) nOld += 1;
+  };
+  for (const text of b.slice(0, head)) ctx(text);
+  const midOld = a.slice(head, a.length - tail).join("\n");
+  const midNew = b.slice(head, b.length - tail).join("\n");
+  for (const part of diffLines(midOld === "" ? "" : `${midOld}
+`, midNew === "" ? "" : `${midNew}
+`)) {
+    for (const text of splitKeep(part.value)) {
+      if (part.added === true) {
+        lines.push({ kind: "add", text, ...nNew !== void 0 ? { n: nNew } : {} });
+        added += 1;
+        if (nNew !== void 0) nNew += 1;
+      } else if (part.removed === true) {
+        lines.push({ kind: "del", text, ...nOld !== void 0 ? { old: nOld } : {} });
+        removed += 1;
+        if (nOld !== void 0) nOld += 1;
+      } else {
+        ctx(text);
+      }
+    }
+  }
+  for (const text of b.slice(b.length - tail)) ctx(text);
+  return { lines, added, removed };
+}
+function diffForCall(tool, rawArgs) {
+  let args;
+  try {
+    const v = JSON.parse(rawArgs);
+    if (v === null || typeof v !== "object" || Array.isArray(v)) return void 0;
+    args = v;
+  } catch {
+    return void 0;
+  }
+  const path7 = typeof args.path === "string" ? args.path : typeof args.file_path === "string" ? args.file_path : void 0;
+  if (tool === "write" && typeof args.content === "string") {
+    const lines = splitKeep(args.content).map((text, i) => ({ kind: "add", text, n: i + 1 }));
+    return { lines, added: lines.length, removed: 0 };
+  }
+  if (tool === "edit" && typeof args.old_string === "string" && typeof args.new_string === "string") {
+    const after = readAfter(path7);
+    const start = after === void 0 ? void 0 : lineOf(after, args.new_string);
+    return replacement(args.old_string, args.new_string, start);
+  }
+  if (tool === "multi_edit" && Array.isArray(args.edits)) {
+    const after = readAfter(path7);
+    const all = { lines: [], added: 0, removed: 0 };
+    for (const e of args.edits) {
+      if (typeof e.old_string !== "string" || typeof e.new_string !== "string") continue;
+      const d = replacement(e.old_string, e.new_string, after === void 0 ? void 0 : lineOf(after, e.new_string));
+      all.lines.push(...d.lines);
+      all.added += d.added;
+      all.removed += d.removed;
+    }
+    return all.lines.length > 0 ? all : void 0;
+  }
+  return void 0;
+}
+function diffCounter(d) {
+  return `${paint("mint", `+${String(d.added)}`)} ${paint("rose", `-${String(d.removed)}`)}`;
+}
+function renderDiff(d, width, ascii = false) {
+  const shown = d.lines.slice(0, MAX_DIFF_LINES);
+  const digits = (n) => n > 0 ? String(n).length : 0;
+  let oldW = Math.max(0, ...shown.map((l) => digits(l.old ?? 0)));
+  const newW = Math.max(0, ...shown.map((l) => digits(l.n ?? 0)));
+  if (oldW + newW + 3 > Math.max(0, width - 8)) oldW = 0;
+  const gutter = " ";
+  const head = (l) => {
+    const parts = [oldW > 0 ? String(l.old ?? "").padStart(oldW) : "", newW > 0 ? String(l.n ?? "").padStart(newW) : ""];
+    const numbers = parts.filter((c2) => c2 !== "").join(" ");
+    return numbers === "" ? "" : `${numbers} `;
+  };
+  const ellipsis = ascii ? "..." : "\u2026";
+  const row = (l) => {
+    const prefix = head(l);
+    const sign = l.kind === "add" ? "+" : l.kind === "del" ? "-" : " ";
+    const room = Math.max(1, width - visibleWidth2(prefix) - sign.length - gutter.length);
+    const body = clipCells(l.text.replace(/\t/g, "  "), room, ellipsis);
+    const pad = " ".repeat(Math.max(0, room - stringWidth3(body)));
+    if (l.kind === "ctx") return `${paint("muted", prefix)}${paint("faint", sign)}${paint("muted", `${gutter}${body}${pad}`)}`;
+    const role = l.kind === "add" ? "mint" : "rose";
+    const ink = l.kind === "add" ? "addFg" : "delFg";
+    const line = `${paint("muted", prefix)}${paint(role, sign)}${paint(ink, `${gutter}${body}${pad}`)}`;
+    return bgEnabled() ? onBg(l.kind === "add" ? "addBg" : "delBg", line) : line;
+  };
+  const out = shown.map(row);
+  const rest = d.lines.length - shown.length;
+  if (rest > 0) out.push(paint("muted", `${" ".repeat(Math.min(width, 4))}${ellipsis} ${String(rest)} more lines`));
+  return out;
+}
+
+// src/ui/partial-json.ts
+function parsePartialJson(raw) {
+  const text = raw.trim();
+  if (text === "") return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+  }
+  let cut = text;
+  for (let pass = 0; pass < 64; pass += 1) {
+    try {
+      return JSON.parse(closeAt(cut));
+    } catch {
+      const back = lastSafePoint(cut);
+      if (back < 1) return void 0;
+      cut = cut.slice(0, back);
+    }
+  }
+  return void 0;
+}
+function closeAt(text) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  for (const ch of text) {
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{") stack.push("}");
+    else if (ch === "[") stack.push("]");
+    else if (ch === "}" || ch === "]") stack.pop();
+  }
+  let out = text;
+  if (inString) {
+    out = out.replace(/\\u[0-9a-fA-F]{0,3}$/, "").replace(/(?<!\\)(\\\\)*\\$/, "$1");
+    out += '"';
+  }
+  out = out.replace(/\s+$/, "");
+  if (out.endsWith(":")) out += "null";
+  else if (out.endsWith(",")) out = out.slice(0, -1);
+  return out + stack.reverse().join("");
+}
+function lastSafePoint(text) {
+  let inString = false;
+  let escaped = false;
+  let point = -1;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === ",") point = i;
+    else if ((ch === "{" || ch === "[") && i + 1 < text.length) point = i + 1;
+  }
+  return point === text.length ? -1 : point;
+}
+
+// src/ui/tool-summary.ts
+import { readFileSync as readFileSync2 } from "fs";
+function toolSummariesEnabled(env = process.env) {
+  if (appEnv("TOOL_SUMMARIES", env) === "0") return false;
+  if (appEnv("TOOL_SUMMARIES", env) === "1") return true;
+  if (!env.DSH_HOME) return true;
+  try {
+    const doc = JSON.parse(readFileSync2(configReadPath(env.DSH_HOME), "utf8"));
+    return doc?.toolSummaries !== false;
+  } catch {
+    return true;
+  }
+}
+function readableToolSummary(tool, args) {
+  if (!args) return void 0;
+  for (const key of ["description", "title"]) {
+    const value = args[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  if (tool === "subagent" || tool === "subagent_fork") {
+    const prompt = args.prompt;
+    if (typeof prompt === "string") return prompt.split(/\r?\n/).find((line) => line.trim())?.trim();
+  }
+  return void 0;
+}
+
+// src/ui/image-preview.ts
+import { readFileSync as readFileSync3, statSync } from "fs";
+import { createRequire } from "module";
+import { inflateSync } from "zlib";
+var MAX_PREVIEW_BYTES = 16 * 1024 * 1024;
+var MAX_PREVIEW_PIXELS = 4e7;
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function sniffImage(bytes) {
+  if (PNG_SIGNATURE.every((b, i) => bytes[i] === b)) return "image/png";
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return "image/jpeg";
+  const ascii = (from, n) => String.fromCharCode(...bytes.subarray(from, from + n));
+  if (ascii(0, 4) === "GIF8") return "image/gif";
+  if (ascii(0, 4) === "RIFF" && ascii(8, 4) === "WEBP") return "image/webp";
+  return void 0;
+}
+function imageSize(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const type = sniffImage(bytes);
+  try {
+    if (type === "image/png") return { width: view.getUint32(16), height: view.getUint32(20) };
+    if (type === "image/gif") return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+    if (type === "image/jpeg") {
+      let at = 2;
+      while (at + 9 < bytes.length) {
+        if (bytes[at] !== 255) return void 0;
+        const marker = bytes[at + 1];
+        const length = view.getUint16(at + 2);
+        if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+          return { height: view.getUint16(at + 5), width: view.getUint16(at + 7) };
+        }
+        at += 2 + length;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function decodePng(bytes) {
+  if (sniffImage(bytes) !== "image/png") return void 0;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let width = 0;
+  let height = 0;
+  let depth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  let palette;
+  let transparency;
+  const idat = [];
+  let at = 8;
+  while (at + 8 <= bytes.length) {
+    const length = view.getUint32(at);
+    const type = String.fromCharCode(...bytes.subarray(at + 4, at + 8));
+    const data2 = bytes.subarray(at + 8, at + 8 + length);
+    if (type === "IHDR") {
+      width = view.getUint32(at + 8);
+      height = view.getUint32(at + 12);
+      depth = bytes[at + 16];
+      colorType = bytes[at + 17];
+      interlace = bytes[at + 20];
+    } else if (type === "PLTE") palette = data2;
+    else if (type === "tRNS") transparency = data2;
+    else if (type === "IDAT") idat.push(data2);
+    else if (type === "IEND") break;
+    at += 12 + length;
+  }
+  if (width === 0 || height === 0 || interlace !== 0 || width * height > MAX_PREVIEW_PIXELS) return void 0;
+  const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[colorType];
+  if (channels === void 0 || ![1, 2, 4, 8, 16].includes(depth)) return void 0;
+  let raw;
+  try {
+    raw = inflateSync(Buffer.concat(idat));
+  } catch {
+    return void 0;
+  }
+  const bitsPerPixel = channels * depth;
+  const stride = Math.ceil(width * bitsPerPixel / 8);
+  const bpp = Math.max(1, bitsPerPixel >> 3);
+  if (raw.length < height * (stride + 1)) return void 0;
+  const rows = new Uint8Array(height * stride);
+  for (let y = 0; y < height; y += 1) {
+    const filter = raw[y * (stride + 1)];
+    const src = y * (stride + 1) + 1;
+    const out = y * stride;
+    for (let x = 0; x < stride; x += 1) {
+      const a = x >= bpp ? rows[out + x - bpp] : 0;
+      const b = y > 0 ? rows[out - stride + x] : 0;
+      const c2 = x >= bpp && y > 0 ? rows[out - stride + x - bpp] : 0;
+      let v = raw[src + x];
+      if (filter === 1) v += a;
+      else if (filter === 2) v += b;
+      else if (filter === 3) v += a + b >> 1;
+      else if (filter === 4) {
+        const p = a + b - c2;
+        const pa = Math.abs(p - a);
+        const pb = Math.abs(p - b);
+        const pc = Math.abs(p - c2);
+        v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c2;
+      }
+      rows[out + x] = v & 255;
+    }
+  }
+  const sample = (y, index) => {
+    if (depth === 16) return rows[y * stride + index * 2];
+    if (depth === 8) return rows[y * stride + index];
+    const bit = index * depth;
+    const byte = rows[y * stride + (bit >> 3)];
+    const value = byte >> 8 - depth - (bit & 7) & (1 << depth) - 1;
+    return colorType === 3 ? value : Math.round(value * 255 / ((1 << depth) - 1));
+  };
+  const data = new Uint8Array(width * height * 4);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const o = (y * width + x) * 4;
+      if (colorType === 3) {
+        const i = sample(y, x);
+        data[o] = palette?.[i * 3] ?? 0;
+        data[o + 1] = palette?.[i * 3 + 1] ?? 0;
+        data[o + 2] = palette?.[i * 3 + 2] ?? 0;
+        data[o + 3] = transparency?.[i] ?? 255;
+      } else if (colorType === 0 || colorType === 4) {
+        const g = sample(y, x * channels);
+        data[o] = data[o + 1] = data[o + 2] = g;
+        data[o + 3] = colorType === 4 ? sample(y, x * channels + 1) : 255;
+      } else {
+        data[o] = sample(y, x * channels);
+        data[o + 1] = sample(y, x * channels + 1);
+        data[o + 2] = sample(y, x * channels + 2);
+        data[o + 3] = colorType === 6 ? sample(y, x * channels + 3) : 255;
+      }
+    }
+  }
+  return { width, height, data };
+}
+function decodeJpeg(bytes) {
+  try {
+    const jpeg = createRequire(import.meta.url)("jpeg-js");
+    const img = jpeg.decode(bytes, { useTArray: true, formatAsRGBA: true, maxResolutionInMP: MAX_PREVIEW_PIXELS / 1e6, maxMemoryUsageInMB: 512 });
+    return { width: img.width, height: img.height, data: img.data };
+  } catch {
+    return void 0;
+  }
+}
+function decodeImage(bytes) {
+  const type = sniffImage(bytes);
+  if (type === "image/png") return decodePng(bytes);
+  if (type === "image/jpeg") return decodeJpeg(bytes);
+  return void 0;
+}
+function boxColor(img, x0, y0, x1, y1, bg) {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let n = 0;
+  const xa = Math.floor(x0);
+  const ya = Math.floor(y0);
+  const xb = Math.max(xa + 1, Math.ceil(x1));
+  const yb = Math.max(ya + 1, Math.ceil(y1));
+  for (let y = ya; y < Math.min(yb, img.height); y += 1) {
+    for (let x = xa; x < Math.min(xb, img.width); x += 1) {
+      const o = (y * img.width + x) * 4;
+      const a = img.data[o + 3] / 255;
+      r += img.data[o] * a + bg[0] * (1 - a);
+      g += img.data[o + 1] * a + bg[1] * (1 - a);
+      b += img.data[o + 2] * a + bg[2] * (1 - a);
+      n += 1;
+    }
+  }
+  return n === 0 ? bg : [r / n, g / n, b / n];
+}
+function previewSize(width, height, cols, rows) {
+  let w = Math.max(1, Math.min(cols, width));
+  let h = Math.max(1, Math.round(w * height / width / 2));
+  if (h > rows) {
+    h = rows;
+    w = Math.max(1, Math.min(cols, Math.round(rows * 2 * width / height)));
+  }
+  return { cols: w, rows: h };
+}
+var esc = (c2, depth, ground) => {
+  const [r, g, b] = c2.map((v) => Math.max(0, Math.min(255, Math.round(v))));
+  if (depth === "truecolor") return `\x1B[${String(ground)};2;${String(r)};${String(g)};${String(b)}m`;
+  const hex = `#${[r, g, b].map((v) => v.toString(16).padStart(2, "0")).join("")}`;
+  return `\x1B[${String(ground)};5;${String(to256(hex, true))}m`;
+};
+function halfBlocks(img, cols, rows, depth = colorDepth(), bg = [14, 16, 24]) {
+  if (depth !== "truecolor" && depth !== "256" || !bgEnabled(depth)) return void 0;
+  const size = previewSize(img.width, img.height, cols, rows);
+  const sx = img.width / size.cols;
+  const sy = img.height / (size.rows * 2);
+  const out = [];
+  for (let row = 0; row < size.rows; row += 1) {
+    let line = "";
+    for (let col = 0; col < size.cols; col += 1) {
+      const top = boxColor(img, col * sx, row * 2 * sy, (col + 1) * sx, (row * 2 + 1) * sy, bg);
+      const bottom = boxColor(img, col * sx, (row * 2 + 1) * sy, (col + 1) * sx, (row * 2 + 2) * sy, bg);
+      line += `${esc(top, depth, 38)}${esc(bottom, depth, 48)}\u2580`;
+    }
+    out.push(`${line}\x1B[39m\x1B[49m`);
+  }
+  return out;
+}
+function describeImage(bytes) {
+  const type = sniffImage(bytes)?.replace("image/", "").toUpperCase() ?? "image";
+  const size = imageSize(bytes);
+  return size === void 0 ? type : `${type} ${String(size.width)}\xD7${String(size.height)}`;
+}
+function previewImageFile(path7, cols, rows) {
+  try {
+    if (statSync(path7).size > MAX_PREVIEW_BYTES) return void 0;
+    const bytes = new Uint8Array(readFileSync3(path7));
+    const description = describeImage(bytes);
+    const img = decodeImage(bytes);
+    const lines = img === void 0 ? void 0 : halfBlocks(img, cols, rows);
+    return lines === void 0 ? { description } : { lines, description };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/ui/tool-call-component.ts
+var IMAGE_TOOLS = /* @__PURE__ */ new Set(["read_image", "view_image"]);
+var IMAGE_FILE = /\.(png|jpe?g|gif|webp)$/i;
+var IMAGE_PREVIEW_COLS = 64;
+var IMAGE_PREVIEW_ROWS = 16;
+var SUMMARY_KEYS2 = ["command", "cmd", "path", "file_path", "url", "query", "pattern", "name"];
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["write", "edit", "multi_edit", "notebook_edit"]);
+var MAX_OUTPUT_LINES2 = 5;
+var MAX_PENDING_COMMAND_ROWS = 4;
+var PREVIEW_ROWS = 10;
+var WRITTEN_TEXT_KEY = { write: "content", edit: "new_string" };
+function padCells(text, width) {
+  const w = stringWidth4(text);
+  if (w >= width) return text;
+  return text + " ".repeat(width - w);
+}
+function relCwd(p) {
+  if (p === "") return p;
+  try {
+    if (!isAbsolute2(p)) return p;
+    const rel = relative(process.cwd(), p);
+    if (rel === "") return ".";
+    if (rel.startsWith("..") || isAbsolute2(rel)) return p;
+    return rel;
+  } catch {
+    return p;
+  }
+}
+var ToolCallComponent = class {
+  constructor(tool, now = Date.now, icons = bruineIcons(), opts = {}) {
+    this.tool = tool;
+    this.now = now;
+    this.icons = icons;
+    this.#startTime = now();
+    this.#readableSummaries = opts.readableSummaries ?? toolSummariesEnabled();
+  }
+  tool;
+  now;
+  icons;
+  #rawArgs = "";
+  #startTime;
+  #done;
+  /** What a successful edit/write changed, shown instead of "file updated". */
+  #diff;
+  /** The image file a successful image read showed the model. */
+  #image;
+  #readableSummaries;
+  get active() {
+    return this.#done === void 0;
+  }
+  /** T55 P1c: a tool still in flight owns the rail, so the live edge is findable. */
+  get rail() {
+    return this.#done === void 0 ? "active" : this.#done.ok ? "blue" : "red";
+  }
+  /**
+   * A call that shows a diff asks for a NEUTRAL card.
+   *
+   * The transcript tints a finished call green, which was the right call for a tool
+   * that just says it worked. It was the wrong one here: the diff paints its own
+   * green band for an added line and its own red band for a removed one, so a green
+   * card left the addition with nothing of its own while the deletion shouted. Two
+   * bands of equal weight on a neutral block is a diff that can be read.
+   */
+  get diffCard() {
+    return this.#diff !== void 0 && this.#diff.lines.length > 0;
+  }
+  get doneOk() {
+    return this.#done?.ok;
+  }
+  get seconds() {
+    return this.#done?.seconds;
+  }
+  args(delta) {
+    this.#rawArgs += delta;
+    this.#settled = void 0;
+  }
+  /** The durable event replaces streamed JSON, it must never be appended twice. */
+  setArgs(json2) {
+    this.#rawArgs = json2;
+    this.#settled = void 0;
+  }
+  result(ok, output) {
+    const lines = sanitize(output).split("\n").filter((l) => !/^\s*(<(path|type)>.*<\/(path|type)>|<\/?content>)\s*$/.test(l)).filter((l) => !/^\s*\(End of file - total \d+ lines?\)\s*$/.test(l));
+    while (lines.length > 0 && lines.at(-1).trim() === "") lines.pop();
+    this.#diff = ok && WRITE_TOOLS.has(this.tool) ? diffForCall(this.tool, this.#rawArgs) : void 0;
+    const path7 = this.#arg("path") ?? this.#arg("file_path");
+    this.#image = ok && path7 !== void 0 && (IMAGE_TOOLS.has(this.tool) || this.tool === "read" && IMAGE_FILE.test(path7)) ? resolve2(process.cwd(), path7) : void 0;
+    if (lines.at(-1) === "") lines.pop();
+    this.#settled = void 0;
+    this.#done = { ok, seconds: (this.now() - this.#startTime) / 1e3, lines: lines.slice(0, MAX_OUTPUT_LINES2), rest: Math.max(0, lines.length - MAX_OUTPUT_LINES2) };
+  }
+  cancel() {
+    if (this.active) this.result(false, "Cancelled");
+  }
+  /**
+   * `link` is only for a call that has settled (T55 P2): a streaming line is
+   * replaced a frame later, so a link on it would be work thrown away.
+   */
+  /**
+   * One argument out of the streamed JSON, or undefined.
+   *
+   * The args arrive as deltas and are only valid JSON once the tool is done, so
+   * both the summary line and the turn's file list read them through here rather
+   * than each parsing the same string a second way.
+   */
+  #arg(key) {
+    try {
+      const parsed = JSON.parse(this.#rawArgs);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+      const value = parsed[key];
+      return typeof value === "string" && value !== "" ? value : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * T59: the file this call named, if it named one.
+   *
+   * Only the tools that write are asked: a `read` names a path too, and printing
+   * it as a change would be a lie the workspace can contradict.
+   */
+  touchedPath() {
+    if (!WRITE_TOOLS.has(this.tool)) return void 0;
+    return this.#arg("file_path") ?? this.#arg("path") ?? this.#arg("notebook_path");
+  }
+  /**
+   * What the arguments say so far. The args arrive as deltas and are only valid
+   * JSON at the end, so the line is read out of the partial text: a command is seen
+   * being written, word by word, instead of a bare ellipsis until it is whole.
+   */
+  #partialArgs() {
+    if (this.#parsedAt !== this.#rawArgs.length) {
+      const parsed = parsePartialJson(this.#rawArgs);
+      this.#parsed = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+      this.#parsedAt = this.#rawArgs.length;
+    }
+    return this.#parsed;
+  }
+  #parsed;
+  #parsedAt = -1;
+  /**
+   * The text of a file being written, as it arrives: its first lines are shown, numbered,
+   * and after them only a count of lines and bytes that keeps moving. Watching a hundred
+   * lines scroll by is noise; watching a number climb is proof that it is working.
+   */
+  #writtenPreview(width) {
+    const key = WRITTEN_TEXT_KEY[this.tool];
+    const text = key === void 0 ? void 0 : this.#partialArgs()?.[key];
+    if (typeof text !== "string" || text === "") return [];
+    const ascii = this.icons.think === "*";
+    const ellipsis = ascii ? "..." : "\u2026";
+    const rows = text.split("\n");
+    if (rows.at(-1) === "") rows.pop();
+    const count = rows.length;
+    const bar = ascii ? "|" : "\u2502";
+    const out = rows.slice(0, PREVIEW_ROWS).map((row, i) => {
+      const gutter = `${String(i + 1).padStart(4)} ${bar} `;
+      return ansi.gray(gutter) + ansi.gray(clipCells(sanitize(row).replace(/\t/g, "  "), Math.max(1, width - gutter.length), ellipsis));
+    });
+    if (count > PREVIEW_ROWS) {
+      const bytes = Buffer.byteLength(text, "utf8");
+      const size = bytes < 1024 ? `${String(bytes)} B` : bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
+      out.push(ansi.gray(clipCells(`     ${ellipsis} ${String(count)} lines ${ascii ? "-" : "\xB7"} ${size}`, width, ellipsis)));
+    }
+    return out;
+  }
+  summary(width = 60, link = false) {
+    if (!this.#rawArgs) return "";
+    const ellipsis = this.icons.think === "*" ? "..." : "\u2026";
+    const obj = this.#partialArgs();
+    if (obj === void 0) return ellipsis;
+    const key = SUMMARY_KEYS2.find((k) => typeof obj[k] === "string" && obj[k] !== "");
+    let text = key ? String(obj[key]) : Object.keys(obj).length > 0 ? JSON.stringify(obj) : "";
+    if (text === "") return ellipsis;
+    if (key === "path" || key === "file_path") text = relCwd(text);
+    const shown = clipCells(sanitize(text).replace(/\n/g, " "), Math.max(1, width), ellipsis);
+    return link && (key === "path" || key === "file_path") ? fileLink(shown, String(obj[key])) : shown;
+  }
+  /** The chat can show a description; approval still reads the actual command/path. */
+  #displaySummary(width, link = false) {
+    const text = this.#readableSummaries ? readableToolSummary(this.tool, this.#partialArgs()) : void 0;
+    if (text === void 0) return this.summary(width, link);
+    return clipCells(sanitize(text).replace(/\s+/g, " "), Math.max(1, width), this.icons.think === "*" ? "..." : "\u2026");
+  }
+  /** A command being written keeps its later lines visible while the call is in flight. */
+  #commandTail(width) {
+    const obj = this.#partialArgs();
+    const command = obj && (typeof obj.command === "string" ? obj.command : typeof obj.cmd === "string" ? obj.cmd : void 0);
+    if (command === void 0) return [];
+    const rows = sanitize(command).split("\n");
+    if (rows.length < 2) return [];
+    const shown = rows.slice(1, 1 + MAX_PENDING_COMMAND_ROWS);
+    const hidden = rows.length - 1 - shown.length;
+    const ellipsis = this.icons.think === "*" ? "..." : "\u2026";
+    return [
+      ...shown.map((row) => ansi.gray(clipCells(`    ${row}`, width, ellipsis))),
+      ...hidden > 0 ? [ansi.gray(clipCells(`    ${ellipsis} ${String(hidden)} more lines`, width))] : []
+    ];
+  }
+  /** A settled call at one width in one set of colours is the same lines every time it is asked for. */
+  #settled;
+  render(width) {
+    if (this.#done === void 0) return this.#draw(width);
+    const ink = `${ansi.gray("x")}${ansi.green("x")}${ansi.red("x")}${ansi.text("x")}`;
+    if (this.#settled?.width !== width || this.#settled.ink !== ink) this.#settled = { width, ink, lines: this.#draw(width) };
+    return this.#settled.lines;
+  }
+  #draw(width) {
+    const toolPad = padCells(this.tool, 7);
+    if (!this.#done) {
+      const fr = spinnerFrame(this.now() - this.#startTime, this.icons);
+      const room = Math.max(1, width - stringWidth4(`${fr} ${toolPad}  `));
+      const summary = this.#displaySummary(room);
+      const detail = summary ? `  ${summary}` : "";
+      const plainLine = clipCells(`${fr} ${toolPad}${detail}`, width);
+      const head2 = stringWidth4(plainLine) === stringWidth4(`${fr} ${toolPad}${detail}`) ? `${ansi.cyan(fr)} ${ansi.text(toolPad)}${ansi.gray(detail)}` : plainLine;
+      return [head2, ...this.#commandTail(width), ...this.#writtenPreview(width)];
+    }
+    const mark = this.#done.ok ? ansi.green(this.icons.ok) : ansi.red(this.icons.fail);
+    const dur = formatDuration(this.#done.seconds) ?? (this.#done.ok ? "0.0s" : void 0);
+    const counter = this.#diff === void 0 ? "" : `  ${diffCounter(this.#diff)}`;
+    const durCells = this.#diff === void 0 ? 0 : 2 + `+${String(this.#diff.added)} -${String(this.#diff.removed)}`.length;
+    const prefixCells = 1 + 1 + stringWidth4(toolPad) + 2;
+    const avail = Math.max(0, width - prefixCells - durCells);
+    const budget = Math.min(60, avail);
+    const durPart = counter;
+    const plainSummary = this.#displaySummary(budget);
+    const linkedPadded = padCells(this.#displaySummary(budget, true), avail);
+    const plainPadded = padCells(plainSummary, avail);
+    const plainHead = ` ${toolPad}  ${plainPadded}${durPart}`;
+    const fits = stringWidth4(plainHead) <= Math.max(0, width - 1);
+    const head = width <= 0 ? "" : fits ? `${mark} ${ansi.text(toolPad)}  ${ansi.gray(linkedPadded)}${durPart}` : mark + clipCells(plainHead, Math.max(0, width - 1));
+    const out = [head];
+    if (this.#diff !== void 0 && this.#diff.lines.length > 0) {
+      out.push(...renderDiff(this.#diff, Math.max(1, width - 2), this.icons.think === "*").map((l) => `  ${l}`));
+      if (dur !== void 0) out.push(ansi.gray(clipCells(`Took ${dur}`, width)));
+      return out;
+    }
+    if (this.#image !== void 0) {
+      const preview = previewImageFile(this.#image, Math.min(IMAGE_PREVIEW_COLS, Math.max(1, width - 6)), IMAGE_PREVIEW_ROWS);
+      if (preview !== void 0) {
+        if (preview.lines !== void 0) out.push(...preview.lines.map((l) => `    ${l}`));
+        out.push(ansi.gray(clipCells(`    ${preview.description}${dur === void 0 ? "" : ` ${this.icons.think === "*" ? "-" : "\xB7"} ${dur}`}`, width)));
+        return out;
+      }
+    }
+    const branch = this.icons.think === "*" ? ">" : "\u23BF";
+    this.#done.lines.forEach((line, i) => out.push(ansi.gray(clipCells(`${i === 0 ? `  ${branch} ` : "    "}${line}`, width))));
+    if (this.#done.rest > 0) out.push(ansi.gray(clipCells(`    ${this.icons.think === "*" ? "..." : "\u2026"} ${this.#done.rest} more lines`, width)));
+    if (dur !== void 0) out.push(ansi.gray(clipCells(`Took ${dur}`, width)));
+    return out;
+  }
+  invalidate() {
+  }
+};
+
+// src/ui/logo-motion.ts
+var LOGO = [
+  "\u250F\u2513 \u250F\u2501\u2513\u257B \u257B\u257B\u250F\u2513\u257B\u250F\u2501\u2578",
+  "\u2523\u253B\u2513\u2523\u2533\u251B\u2503 \u2503\u2503\u2503\u2517\u252B\u2523\u2578 ",
+  "\u2517\u2501\u251B\u2579\u2517\u2578\u2517\u2501\u251B\u2579\u2579 \u2579\u2517\u2501\u2578"
+];
+function terminalMotionAllowed(opts = {}) {
+  const env = opts.env ?? process.env;
+  const tty = opts.stdoutTTY ?? process.stdout.isTTY === true;
+  return tty && opts.ascii !== true && appEnv("ASCII", env) !== "1" && env.CI !== "1" && appEnv("NO_ANIMATION", env) !== "1" && env.TERM !== "dumb";
+}
+
+// src/ui/typewriter.ts
+var REVEAL_INTERVAL_MS = 40;
+var REVEAL_CATCH_UP = 0.18;
+var REVEAL_FLOOR = 1;
+var DELIMITER_WINDOW = 48;
+var MARKER_HOLD_TICKS = 4;
+var CLUSTER_LOOKAHEAD = 8;
+var SEGMENTER = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+var DELIMITERS = ["```", "**", "__", "~~", "*", "_", "`", "[", "("];
+function graphemeCut(text, from, limit) {
+  if (limit >= text.length) return text.length;
+  const slice = text.slice(from, limit + CLUSTER_LOOKAHEAD);
+  let cut = from;
+  for (const segment of SEGMENTER.segment(slice)) {
+    const end = from + segment.index + segment.segment.length;
+    if (end > limit) return Math.min(end, text.length);
+    cut = end;
+  }
+  return cut > from ? cut : Math.min(text.length, from + 1);
+}
+function countUnescaped(head, needle) {
+  let count = 0;
+  for (let at = head.indexOf(needle); at !== -1; at = head.indexOf(needle, at + needle.length)) {
+    if (head.at(at - 1) === "\\") continue;
+    count += 1;
+  }
+  return count;
+}
+var Typewriter = class {
+  #buffer = "";
+  /** Code units of the buffer already on screen. Always a grapheme boundary. */
+  #shown = 0;
+  #timer;
+  /** The marker the reveal is waiting on, and how many ticks it has cost. */
+  #heldAt;
+  #heldTicks = 0;
+  #onTick;
+  #intervalMs;
+  #catchUp;
+  #floor;
+  #setTimer;
+  #clearTimer;
+  constructor(opts = {}) {
+    this.#onTick = opts.onTick;
+    this.#intervalMs = REVEAL_INTERVAL_MS;
+    this.#catchUp = REVEAL_CATCH_UP;
+    this.#floor = REVEAL_FLOOR;
+    this.#setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.#clearTimer = opts.clearTimer ?? ((handle) => clearTimeout(handle));
+  }
+  /** True when text is being held back, so a repaint is worth asking for. */
+  get animating() {
+    return this.#shown < this.#buffer.length;
+  }
+  /** How much is waiting. */
+  get pending() {
+    return this.#buffer.length - this.#shown;
+  }
+  /** What to paint: the whole answer when nothing is held back. */
+  get text() {
+    return this.#buffer.slice(0, this.#shown);
+  }
+  push(delta) {
+    if (delta === "") return;
+    this.#buffer += delta;
+    if (this.#onTick === void 0) {
+      this.#shown = this.#buffer.length;
+      return;
+    }
+    this.#arm();
+  }
+  /** One step. Exposed so a test can drive time instead of waiting for it. */
+  tick() {
+    if (!this.animating) {
+      this.#disarm();
+      return;
+    }
+    const step = Math.max(this.#floor, Math.ceil(this.pending * this.#catchUp));
+    const limit = Math.min(this.#buffer.length, this.#shown + step);
+    const wait = this.#holdAt(limit);
+    const next = wait ?? graphemeCut(this.#buffer, this.#shown, limit);
+    if (next <= this.#shown) {
+      this.#disarm();
+      return;
+    }
+    this.#shown = next;
+    this.#onTick?.();
+    if (this.animating) this.#arm();
+    else this.#disarm();
+  }
+  /** Everything, now. Called on finish, on abort and before a re-render. */
+  flush() {
+    this.#shown = this.#buffer.length;
+    this.#heldAt = void 0;
+    this.#heldTicks = 0;
+    this.#disarm();
+  }
+  /**
+   * Throw the buffer away and reveal `text` from the start.
+   *
+   * For the case `push` cannot serve: what is on screen is not a prefix of what
+   * arrived, so the text changed shape rather than grew. `flush` is not it —
+   * flushing shows what is already buffered, and the buffer still holds the old
+   * text, which would then be painted twice.
+   */
+  reset(text) {
+    this.#buffer = text;
+    this.#heldAt = void 0;
+    this.#heldTicks = 0;
+    this.#shown = this.#onTick === void 0 ? text.length : 0;
+    if (this.animating) this.#arm();
+    else this.#disarm();
+  }
+  dispose() {
+    this.#disarm();
+    this.#onTick = void 0;
+  }
+  /**
+   * Where to wait instead of advancing, or undefined to go ahead.
+   *
+   * The pairing is judged on the revealed prefix, because the prefix is what
+   * the reader sees: "**b" whose pair is two characters further along the buffer
+   * still paints two literal asterisks.
+   */
+  #holdAt(limit) {
+    const cut = graphemeCut(this.#buffer, this.#shown, limit);
+    const head = this.#buffer.slice(0, cut);
+    let waiting;
+    for (const needle of DELIMITERS) {
+      if (countUnescaped(head, needle) % 2 !== 1) continue;
+      const at = head.lastIndexOf(needle);
+      if (at < this.#shown) continue;
+      if (cut - at > DELIMITER_WINDOW) continue;
+      if (this.#heldAt === at) {
+        if (this.#heldTicks < MARKER_HOLD_TICKS) {
+          this.#heldTicks += 1;
+          waiting = at;
+        }
+      } else {
+        this.#heldAt = at;
+        this.#heldTicks = 0;
+        waiting = at;
+      }
+      break;
+    }
+    if (waiting === void 0) {
+      this.#heldAt = void 0;
+      this.#heldTicks = 0;
+    }
+    return waiting;
+  }
+  #arm() {
+    if (this.#timer !== void 0 || this.#onTick === void 0) return;
+    this.#timer = this.#setTimer(() => {
+      this.#timer = void 0;
+      this.tick();
+    }, this.#intervalMs);
+    this.#timer.unref?.();
+  }
+  #disarm() {
+    if (this.#timer === void 0) return;
+    this.#clearTimer(this.#timer);
+    this.#timer = void 0;
+  }
+};
+function revealAllowed(icons, env = process.env) {
+  return terminalMotionAllowed({ ascii: icons.think === "*", env });
+}
+
+// src/ui/question-call-component.ts
+var QuestionCallComponent = class {
+  constructor(now = Date.now, icons = bruineIcons(), opts = {}) {
+    this.now = now;
+    this.icons = icons;
+    this.#start = now();
+    const animate = opts.animate ?? revealAllowed(icons);
+    this.#onTick = animate && opts.onTick !== void 0 ? opts.onTick : void 0;
+    this.#typewriter = opts.typewriter ?? {};
+  }
+  now;
+  icons;
+  tool = "ask_user_question";
+  #raw = "";
+  #start;
+  #answers;
+  #ended;
+  #tws = [];
+  /** What each reveal was last handed: a live line only ever grows. */
+  #fed = [];
+  #onTick;
+  #typewriter;
+  get active() {
+    return this.#ended === void 0;
+  }
+  get rail() {
+    return this.#ended === void 0 ? "active" : this.#ended.ok ? "blue" : "red";
+  }
+  get doneOk() {
+    return this.#ended?.ok;
+  }
+  get seconds() {
+    return this.#ended === void 0 ? void 0 : (this.now() - this.#start) / 1e3;
+  }
+  args(delta) {
+    this.#raw += delta;
+    this.#reveal();
+  }
+  /** The durable event replaces streamed JSON, it must never be appended twice. */
+  setArgs(json2) {
+    this.#raw = json2;
+    this.#reveal();
+  }
+  touchedPath() {
+    return void 0;
+  }
+  summary(width = 60) {
+    const first = this.#questions()[0]?.question ?? "";
+    return clipCells(sanitize(first).replace(/\n/g, " "), Math.max(1, width), this.icons.think === "*" ? "..." : "\u2026");
+  }
+  /** What the user picked in the form shown for these questions. */
+  answer(answers) {
+    if (this.#ended !== void 0) return;
+    this.#settle();
+    this.#answers = answers;
+    this.#ended = { ok: true };
+  }
+  /** The tool's own result: it only settles a call nobody answered through the form. */
+  result(ok, output) {
+    if (this.#ended !== void 0) return;
+    this.#settle();
+    this.#ended = ok ? { ok } : { ok, note: sanitize(output).split("\n")[0] ?? "" };
+  }
+  cancel() {
+    if (this.#ended === void 0) {
+      this.#settle();
+      this.#ended = { ok: false, note: "Cancelled" };
+    }
+  }
+  /** Nothing may stay hidden once the call is over: a record that reads short is a lie. */
+  #settle() {
+    for (const tw of this.#tws) tw.flush();
+  }
+  /**
+   * Hand every line's reveal what the partial JSON says now, and nothing twice.
+   *
+   * One reveal per line, because a line is what grows: the question text and the
+   * option summary both arrive a piece at a time, and each one only ever extends
+   * what is already on screen. A shared buffer would restart the question from its
+   * first word every time the option count changed, which reads as a glitch.
+   */
+  #reveal() {
+    const lines = this.#liveLines();
+    while (this.#tws.length < lines.length) {
+      this.#tws.push(new Typewriter({ ...this.#typewriter, onTick: this.#onTick }));
+      this.#fed.push("");
+    }
+    lines.forEach((line, i) => {
+      const tw = this.#tws[i];
+      const fed = this.#fed[i] ?? "";
+      if (line === fed) return;
+      if (line.startsWith(fed)) tw.push(line.slice(fed.length));
+      else tw.reset(line);
+      this.#fed[i] = line;
+    });
+    this.#tws.length = lines.length;
+    this.#fed.length = lines.length;
+    if (this.#complete()) this.#settle();
+  }
+  /** The questions the arguments describe so far; whatever has not arrived is absent. */
+  #questions() {
+    const parsed = parsePartialJson(this.#raw);
+    const list = parsed?.questions;
+    if (!Array.isArray(list)) return [];
+    return list.flatMap((item, index) => {
+      if (item === null || typeof item !== "object") return [];
+      const q = item;
+      const options = Array.isArray(q.options) ? q.options.flatMap((o) => {
+        const opt = o;
+        if (opt === null || typeof opt !== "object" || typeof opt.label !== "string") return [];
+        return [typeof opt.description === "string" ? { label: opt.label, description: opt.description } : { label: opt.label }];
+      }) : [];
+      const header = typeof q.header === "string" && q.header.trim() !== "" ? q.header : void 0;
+      return [{
+        id: typeof q.id === "string" ? q.id : String(index),
+        question: typeof q.question === "string" ? q.question : "",
+        ...header !== void 0 ? { header } : {},
+        ...options.length > 0 ? { options } : {},
+        ...q.multiSelect === true ? { multiSelect: true } : {}
+      }];
+    });
+  }
+  /**
+   * The live call, one line at a time: the question (or its header, while the
+   * question is still arriving), then the options it offers.
+   *
+   * The line count is the layout's own: `render` walks the same questions in the
+   * same order, so a line sits at the same index on both sides even mid-stream.
+   */
+  #liveLines() {
+    const lines = [];
+    for (const q of this.#questions()) {
+      const text = q.question.trim();
+      lines.push(text === "" ? q.header ?? "" : text);
+      const options = q.options ?? [];
+      if (options.length > 0) lines.push(`  ${String(options.length)} option(s): ${options.map((o) => o.label).join(", ")}`);
+    }
+    return lines;
+  }
+  #complete() {
+    try {
+      JSON.parse(this.#raw);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  render(width) {
+    const ascii = this.icons.think === "*";
+    const ellipsis = ascii ? "..." : "\u2026";
+    const fit = (text, cells = width) => clipCells(sanitize(text).replace(/\n/g, " "), Math.max(1, cells), ellipsis);
+    const questions = this.#questions();
+    const lead = this.#ended === void 0 ? ansi.cyan(spinnerFrame(this.now() - this.#start, this.icons)) : this.#ended.ok ? ansi.green(this.icons.ok) : ansi.red(this.icons.fail);
+    const label = "ask_user";
+    const headCells = 1 + 1 + label.length + 2;
+    if (questions.length === 0) return [`${lead} ${ansi.text(label)}  ${ansi.gray(ellipsis)}`];
+    const revealed = (i) => this.#tws[i]?.text ?? "";
+    const bullets = ascii ? { on: "(*)", off: "( )" } : { on: "\u25CF", off: "\u25CB" };
+    const lines = [];
+    let at = 0;
+    questions.forEach((q, i) => {
+      const prefix = i === 0 ? `${lead} ${ansi.text(label)}  ` : " ".repeat(headCells);
+      const asked = revealed(at++);
+      lines.push(`${prefix}${ansi.gray(fit(asked === "" ? ellipsis : asked, width - headCells))}`);
+      const options = q.options ?? [];
+      if (options.length > 0) {
+        const summary = revealed(at++);
+        lines.push(ansi.gray(fit(summary === "" ? ellipsis : summary)));
+      }
+      const answer = this.#answers?.find((a) => a.id === q.id) ?? this.#answers?.[i];
+      if (this.#ended !== void 0 && this.#answers !== void 0) {
+        const text = answer === void 0 ? "" : [...answer.selected, ...answer.custom !== void 0 && answer.custom !== "" ? [answer.custom] : []].join(", ");
+        lines.push(text === "" ? ansi.gray("skipped") : ansi.violet(fit(`${this.icons.ok} ${text}`)));
+        lines.push(ansi.gray(fit(`Q: ${q.question}`)));
+        if (options.length > 0) {
+          lines.push(ansi.gray("Options:"));
+          for (const o of options) {
+            const chosen = answer?.selected.includes(o.label) === true;
+            const rest = fit(`${o.label}${o.description !== void 0 ? ` - ${o.description}` : ""}`, width - 6);
+            lines.push(`  ${chosen ? ansi.green(bullets.on) : ansi.faint(bullets.off)} ${chosen ? ansi.text(rest) : ansi.gray(rest)}`);
+          }
+        }
+      }
+    });
+    if (this.#ended === void 0 && this.#complete()) {
+      lines.push(ansi.gray(fit(ascii ? "Waiting for user input..." : "Waiting for user input\u2026")));
+    } else if (this.#ended?.ok === false && this.#ended.note !== void 0) {
+      lines.push(ansi.red(fit(this.#ended.note)));
+    }
+    return lines;
+  }
+  invalidate() {
+  }
+};
+
+// src/ui/assistant-text.ts
+import { Markdown, Text } from "@earendil-works/pi-tui";
+
+// src/render/markdown.ts
+import stringWidth5 from "string-width";
+var READ_WIDTH = 110;
+var FENCE = /^ {0,3}(`{3,}|~{3,})/;
+var HEADING = /^ {0,3}#{1,6}\s/;
+var LIST_ITEM = /^(\s*)([-*+]|\d{1,9}[.)])(\s+)(.*)$/;
+var QUOTE = /^(\s*)(>\s?)/;
+var TABLE_RULE = /^ {0,3}\|?[\s:|-]*-[\s:|-]*\|/;
+var SETEXT = /^ {0,3}(?:=+|-+)\s*$/;
+var INDENTED = /^(?: {4}|\t)/;
+var OPENS_BLOCK = /^[-*+>#|]|\d{1,9}[.)]/;
+var UNBREAKABLE = /[[<]|:\/\//;
+var plain = (line) => line.replace(/\x1b\[[0-9;]*m/g, "");
+var blank = (line) => stringWidth5(plain(line).trim()) === 0;
+function shapeAnswer(source, availableWidth) {
+  const lines = source.split("\n");
+  const width = Math.max(1, Math.min(availableWidth, READ_WIDTH));
+  const cap = width < availableWidth;
+  const out = [];
+  let fence;
+  let table = false;
+  let words = [];
+  let kind = "";
+  let first = "";
+  let next = "";
+  let verbatim = false;
+  const flush = () => {
+    if (words.length > 0) {
+      out.push(...cap && !verbatim ? fill(words, first, next, width) : [`${first}${words.join(" ")}`]);
+      words = [];
+    }
+    kind = "";
+    verbatim = false;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (fence !== void 0) {
+      out.push(line);
+      const close = /^ {0,3}(`{3,}|~{3,})\s*$/.exec(line)?.[1];
+      if (close !== void 0 && close[0] === fence.char && close.length >= fence.len) fence = void 0;
+      continue;
+    }
+    const open = FENCE.exec(line)?.[1];
+    if (open !== void 0) {
+      flush();
+      fence = { char: open[0], len: open.length };
+      table = false;
+      out.push(line);
+      continue;
+    }
+    if (blank(line)) {
+      flush();
+      table = false;
+      out.push(line);
+      continue;
+    }
+    if (line.includes("|") && (table || TABLE_RULE.test(lines[i + 1] ?? ""))) {
+      flush();
+      table = true;
+      out.push(line);
+      continue;
+    }
+    table = false;
+    if (INDENTED.test(line)) {
+      flush();
+      out.push(line);
+      continue;
+    }
+    if (words.length > 0 && SETEXT.test(line)) {
+      flush();
+      out.push(line);
+      continue;
+    }
+    if (HEADING.test(line)) {
+      flush();
+      if (out.length > 0 && !blank(out[out.length - 1])) out.push("");
+      out.push(...cap && !UNBREAKABLE.test(line) ? fill(line.trim().split(/\s+/), "", "", width) : [line]);
+      continue;
+    }
+    const quote = QUOTE.exec(line);
+    const item = LIST_ITEM.exec(line);
+    if (item !== null) {
+      flush();
+      kind = "list";
+      const [, indent = "", marker = "", gap = ""] = item;
+      first = `${indent}${marker}${gap}`;
+      next = `${indent}${" ".repeat(marker.length + gap.length)}`;
+    } else if (quote !== null) {
+      if (kind !== "quote") {
+        flush();
+        kind = "quote";
+        first = quote[0];
+      }
+      next = quote[0];
+    } else if (kind === "") {
+      kind = "para";
+      first = next = "";
+    }
+    if (UNBREAKABLE.test(line)) verbatim = true;
+    if (verbatim) {
+      out.push(line);
+      continue;
+    }
+    const body = item !== null ? item[4] : quote !== null ? line.slice(quote[0].length) : line;
+    words.push(...body.trim().split(/\s+/).filter((word) => word !== ""));
+  }
+  flush();
+  return out.join("\n");
+}
+function fill(words, first, next, width) {
+  const tokens = [];
+  for (const [i, word] of words.entries()) {
+    if (i > 0 && OPENS_BLOCK.test(word)) tokens[tokens.length - 1] = `${tokens[tokens.length - 1]} ${word}`;
+    else tokens.push(word);
+  }
+  const out = [];
+  let start = 0;
+  while (start < tokens.length) {
+    const prefix = start === 0 ? first : next;
+    let cells = stringWidth5(prefix);
+    let end = start;
+    while (end < tokens.length) {
+      const add = stringWidth5(tokens[end]) + (end === start ? 0 : 1);
+      if (cells + add > width && end > start) break;
+      cells += add;
+      end += 1;
+    }
+    out.push(`${prefix}${tokens.slice(start, end).join(" ")}`);
+    start = end;
+  }
+  return out;
+}
+function oneBlankBetween(lines) {
+  const out = [];
+  let previousBlank = false;
+  for (const line of lines) {
+    const empty = blank(line);
+    if (empty && previousBlank) continue;
+    out.push(line);
+    previousBlank = empty;
+  }
+  return out;
+}
+
+// src/ui/chat-layout.ts
+import {
+  Container,
+  Editor,
+  sliceByColumn,
+  truncateToWidth,
+  visibleWidth as visibleWidth3
+} from "@earendil-works/pi-tui";
+import stringWidth6 from "string-width";
+
+// src/ui/assistant-text.ts
+var AssistantTextComponent = class {
+  #md;
+  #tw;
+  constructor(opts = {}) {
+    const icons = opts.icons ?? bruineIcons();
+    this.#md = new Markdown("", 0, 0, markdownThemeFor(icons), void 0, {
+      // Prose is read at a fixed measure and code keeps the width it needs, so a
+      // wide terminal gains air around the answer instead of lines through it.
+      transform: shapeAnswer
+    });
+    const animate = opts.animate ?? revealAllowed(icons);
+    const repaint = opts.onTick;
+    this.#tw = new Typewriter({
+      ...opts.typewriter,
+      // The repaint hook is the switch: without one there is nothing to animate
+      // for, so the text lands whole. With one, the reveal owns the painting:
+      // the component has to re-set the markdown on every step, not only when a
+      // delta arrives, or the screen keeps showing the text as it was.
+      onTick: animate && repaint !== void 0 ? () => {
+        this.#paint();
+        repaint();
+      } : void 0
+    });
+  }
+  push(delta) {
+    this.#tw.push(delta);
+    this.#paint();
+  }
+  finish() {
+    this.#tw.flush();
+    this.#paint();
+  }
+  #paint() {
+    this.#md.setText(withoutEmoji(this.#tw.text));
+  }
+  /** The shaped lines of the last markdown render: while the renderer hands back the same lines, so do we. */
+  #shaped;
+  render(width) {
+    const rendered = this.#md.render(width);
+    if (this.#shaped?.from !== rendered) this.#shaped = { from: rendered, lines: oneBlankBetween(rendered) };
+    return this.#shaped.lines;
+  }
+  invalidate() {
+    this.#md.invalidate();
+  }
+};
+
+// src/ui/changes.ts
+import { isAbsolute as isAbsolute4, join as join2 } from "path";
+import stringWidth7 from "string-width";
+import { visibleWidth as visibleWidth4 } from "@earendil-works/pi-tui";
+
+// src/platform/tool.ts
+import { execFile } from "child_process";
+import { access } from "fs/promises";
+import { delimiter, isAbsolute as isAbsolute3, join } from "path";
+function exitCode(error) {
+  const code = error?.code;
+  return typeof code === "number" ? code : 1;
+}
+var DEFAULT_TIMEOUT_MS = 5e3;
+var runTool = (cmd, args, opts = {}) => new Promise((resolve3) => {
+  const child = execFile(
+    cmd,
+    [...args],
+    {
+      encoding: "buffer",
+      timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      ...opts.maxBuffer === void 0 ? {} : { maxBuffer: opts.maxBuffer },
+      ...opts.daemon === true ? { killSignal: "SIGKILL" } : {}
+    },
+    (error, stdout, stderr) => {
+      const forked = opts.daemon === true && error?.killed === true;
+      resolve3({
+        code: error === null || forked ? 0 : exitCode(error),
+        stdout: Buffer.isBuffer(stdout) ? stdout : Buffer.alloc(0),
+        stderr: forked ? "" : typeof stderr === "string" ? stderr : String(stderr ?? "")
+      });
+    }
+  );
+  if (opts.input !== void 0) child.stdin?.end(opts.input);
+  child.on("error", () => resolve3({ code: 1, stdout: Buffer.alloc(0), stderr: "" }));
+});
+async function hasTool(cmd, env = process.env) {
+  const names = executableNames(cmd, env);
+  if (isAbsolute3(cmd) || cmd.includes("/") || cmd.includes("\\")) {
+    for (const name2 of names) if (await exists(name2)) return true;
+    return false;
+  }
+  for (const dir of (env["PATH"] ?? "").split(delimiter)) {
+    if (dir === "") continue;
+    for (const name2 of names) if (await exists(join(dir, name2))) return true;
+  }
+  return false;
+}
+function executableNames(cmd, env) {
+  if (process.platform !== "win32") return [cmd];
+  const exts = (env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";");
+  return [cmd, ...exts.filter((ext) => ext !== "").map((ext) => cmd + ext.toLowerCase())];
+}
+async function exists(path7) {
+  try {
+    await access(path7);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/ui/changes.ts
+var GIT_TIMEOUT_MS = 4e3;
+function parsePorcelain(raw) {
+  const out = /* @__PURE__ */ new Map();
+  const fields = raw.split("\0");
+  for (let i = 0; i < fields.length; i += 1) {
+    const field = fields[i];
+    if (field.length < 4) continue;
+    const code = `${field[0]}${field[1]}`.trim();
+    const path7 = field.slice(3);
+    if (code.startsWith("R") || code.startsWith("C")) i += 1;
+    if (path7 !== "") out.set(path7, code);
+  }
+  return out;
+}
+function changedSince(before, after) {
+  const out = [];
+  for (const [path7, code] of after) {
+    if (before.get(path7) === code) continue;
+    out.push({ path: path7, status: code });
+  }
+  for (const [path7, code] of before) {
+    if (after.has(path7)) continue;
+    out.push({ path: path7, status: "gone" });
+  }
+  return out;
+}
+function parseNumstat(raw) {
+  const out = /* @__PURE__ */ new Map();
+  const fields = raw.split("\0");
+  for (let i = 0; i < fields.length; i += 1) {
+    const row = fields[i];
+    const tab = row.indexOf("	");
+    if (tab < 0) continue;
+    const added = Number(row.slice(0, tab));
+    const removed = Number(row.slice(tab + 1, row.indexOf("	", tab + 1)));
+    const path7 = row.slice(row.indexOf("	", tab + 1) + 1);
+    if (!Number.isFinite(added) || !Number.isFinite(removed) || path7 === "") continue;
+    out.set(path7, { added, removed });
+  }
+  return out;
+}
+async function gitStatus(cwd, run = runTool) {
+  if (!await hasTool("git")) return void 0;
+  const result = await run("git", ["status", "--porcelain=v1", "-z"], {
+    timeoutMs: GIT_TIMEOUT_MS
+  });
+  if (result.code !== 0) return void 0;
+  return parsePorcelain(result.stdout.toString("utf8"));
+}
+async function gitNumstat(cwd, run = runTool) {
+  if (!await hasTool("git")) return void 0;
+  const result = await run("git", ["diff", "--numstat", "-z", "HEAD"], { timeoutMs: GIT_TIMEOUT_MS });
+  if (result.code !== 0) return void 0;
+  return parseNumstat(result.stdout.toString("utf8"));
+}
+async function turnChanges(opts) {
+  const after = await gitStatus(opts.cwd, opts.run);
+  if (opts.before !== void 0 && after !== void 0) {
+    const counts = await gitNumstat(opts.cwd, opts.run);
+    return changedSince(opts.before, after).map((file) => {
+      const n = counts?.get(file.path);
+      return n === void 0 ? file : { ...file, added: n.added, removed: n.removed };
+    });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const path7 of opts.declared ?? []) {
+    if (path7 === "" || seen.has(path7)) continue;
+    seen.add(path7);
+    out.push({ path: path7, status: "M" });
+  }
+  return out;
+}
+
+// src/plugins/modes.ts
+import { existsSync as existsSync3, readFileSync as readFileSync6 } from "fs";
+import { createUserMessage as createUserMessage2 } from "@deepseek-ai/dsh-llm";
+import { Text as Text2 } from "@earendil-works/pi-tui";
+
+// src/gate/rules.ts
+import path2 from "path";
+import { existsSync as existsSync2, lstatSync, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+
+// src/mcp/config.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync4 } from "fs";
+import path3 from "path";
+
+// src/mcp/state.ts
+import { mkdirSync, readFileSync as readFileSync5, renameSync, writeFileSync } from "fs";
+import path4 from "path";
+
+// src/plugins/modes.ts
+var PLAN_ON_TEXT = "Plan mode is on: do not modify files or run modifying commands.";
+var PLAN_OFF_TEXT = "Plan mode is off.";
+var MODE_ANNOUNCEMENTS = /* @__PURE__ */ new Set([PLAN_ON_TEXT, PLAN_OFF_TEXT]);
+
+// src/ui/tps.ts
+var MIN_DECODE_MS = 250;
+function cachePercent(cached2, totalInput) {
+  if (!Number.isFinite(cached2) || !Number.isFinite(totalInput)) return void 0;
+  if (cached2 < 0 || totalInput <= 0) return void 0;
+  const total = cached2 <= totalInput ? totalInput : totalInput + cached2;
+  if (total <= 0) return void 0;
+  return Math.min(100, Math.max(0, cached2 / total * 100));
+}
+var TpsMeter = class {
+  #callStart;
+  #t0;
+  #t1;
+  #deltas = 0;
+  #tps = 0;
+  #measuredTps = 0;
+  #estimatedTps = 0;
+  #textBytes = 0;
+  #firstTextBytes = 0;
+  #pp;
+  #cachePct;
+  #cacheFirst = false;
+  #calls = 0;
+  /** Kept for compatibility; prefer startCall/delta/usage/endCall. */
+  sample(timeMs, outputTokens) {
+    this.usage(timeMs, { outputTokens });
+  }
+  /** Frame start: marks request start for prefill timing. */
+  startCall(timeMs) {
+    this.#callStart = timeMs;
+    this.#t0 = void 0;
+    this.#t1 = void 0;
+    this.#deltas = 0;
+    this.#measuredTps = 0;
+    this.#estimatedTps = 0;
+    this.#textBytes = 0;
+    this.#firstTextBytes = 0;
+    this.#pp = void 0;
+  }
+  /** One decode delta (reasoning/text/tool-call) at the given time. */
+  delta(timeMs, text = "") {
+    this.#textBytes += Buffer.byteLength(text, "utf8");
+    if (this.#t0 === void 0) {
+      this.#firstTextBytes = this.#textBytes;
+      this.#t0 = timeMs;
+      this.#t1 = timeMs;
+      this.#deltas = 1;
+      this.#tps = 0;
+      return;
+    }
+    this.#t1 = timeMs;
+    this.#deltas += 1;
+    const dt = (timeMs - this.#t0) / 1e3;
+    this.#tps = dt > 0 ? (this.#deltas - 1) / dt : 0;
+    const bytes = this.#textBytes - this.#firstTextBytes;
+    this.#estimatedTps = dt * 1e3 >= MIN_DECODE_MS && Number.isFinite(dt) && bytes > 0 ? bytes / 4 / dt : 0;
+  }
+  /** Usage chunk at the end of a call: final decode rate + prefill rate. */
+  usage(timeMs, usage) {
+    const out = Number(usage.outputTokens ?? NaN);
+    const n = Number.isFinite(out) ? Math.max(0, out) : this.#deltas;
+    const decodeMs = this.#t0 !== void 0 && this.#t1 !== void 0 ? this.#t1 - this.#t0 : 0;
+    const measured = Number.isFinite(out) && out > 0 && Number.isFinite(decodeMs) && decodeMs >= MIN_DECODE_MS ? out / (decodeMs / 1e3) : 0;
+    this.#measuredTps = Number.isFinite(measured) ? measured : 0;
+    if (this.#t0 !== void 0 && this.#t1 !== void 0) {
+      const dt = (this.#t1 - this.#t0) / 1e3;
+      this.#tps = dt > 0 ? n / dt : 0;
+    } else if (this.#deltas > 0) {
+      this.#tps = 0;
+    }
+    const inp = Number(usage.inputTokens ?? NaN);
+    if (Number.isFinite(inp) && this.#t0 !== void 0 && this.#callStart !== void 0) {
+      const preDt = (this.#t0 - this.#callStart) / 1e3;
+      const cached2 = Number(usage.cacheReadTokens ?? 0);
+      const fresh = Number.isFinite(cached2) ? cached2 > inp ? Math.max(0, inp) : Math.max(0, inp - cached2) : Math.max(0, inp);
+      this.#pp = preDt > 0 && fresh >= 512 ? fresh / preDt : void 0;
+    }
+    const cachedRaw = Number(usage.cacheReadTokens ?? NaN);
+    if (Number.isFinite(cachedRaw) && Number.isFinite(inp)) {
+      this.#cachePct = cachePercent(cachedRaw, inp);
+      this.#cacheFirst = this.#calls === 0;
+    } else {
+      this.#cachePct = void 0;
+      this.#cacheFirst = false;
+    }
+  }
+  /** Frame end: when no usage arrived, estimate from delta count. */
+  endCall() {
+    if (this.#t0 !== void 0 && this.#t1 !== void 0 && this.#deltas > 0) {
+      if (this.#tps === 0) {
+        const dt = (this.#t1 - this.#t0) / 1e3;
+        this.#tps = dt > 0 ? this.#deltas / dt : 0;
+      }
+    }
+    this.#calls += 1;
+    this.#callStart = void 0;
+    this.#t0 = void 0;
+    this.#t1 = void 0;
+    this.#deltas = 0;
+  }
+  reset() {
+    this.#callStart = void 0;
+    this.#t0 = void 0;
+    this.#t1 = void 0;
+    this.#deltas = 0;
+    this.#tps = 0;
+    this.#measuredTps = 0;
+    this.#estimatedTps = 0;
+    this.#textBytes = 0;
+    this.#firstTextBytes = 0;
+    this.#pp = void 0;
+    this.#cachePct = void 0;
+    this.#cacheFirst = false;
+    this.#calls = 0;
+  }
+  get tps() {
+    return this.#tps;
+  }
+  /** Tokens/s backed by model usage; zero means there is no reliable reading. */
+  get measuredTps() {
+    return this.#measuredTps;
+  }
+  /** Local text-volume estimate for streams that report usage only at the end. */
+  get estimatedTps() {
+    return this.#estimatedTps;
+  }
+  get pp() {
+    return this.#pp;
+  }
+  get cachePct() {
+    return this.#cachePct;
+  }
+  get cacheFirst() {
+    return this.#cacheFirst;
+  }
+};
+
+// src/ui/spend.ts
+function reported(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, n) : void 0;
+}
+function loggedUsage(session) {
+  const total = { input: 0, output: 0, cacheRead: 0 };
+  const seen = { input: false, output: false, cacheRead: false };
+  try {
+    const events = session?.snapshotEvents?.();
+    if (!Array.isArray(events)) return { total, seen };
+    for (const event of events) {
+      if (event?.type !== "assistant/message") continue;
+      const usage = event.data?.usage;
+      if (usage === void 0 || usage === null) continue;
+      const counts = {
+        input: reported(usage.inputTokens),
+        output: reported(usage.outputTokens),
+        cacheRead: reported(usage.cacheReadTokens)
+      };
+      for (const key of ["input", "output", "cacheRead"]) {
+        const value = counts[key];
+        if (value === void 0) continue;
+        total[key] += value;
+        seen[key] = true;
+      }
+    }
+  } catch {
+  }
+  return { total, seen };
+}
+var SessionSpend = class {
+  #session;
+  #total;
+  #seen;
+  /** The last count each call reported, so growth can be told from a repeat. */
+  #call = { input: 0, output: 0, cacheRead: 0 };
+  constructor(session) {
+    this.#session = session;
+    const logged = loggedUsage(session);
+    this.#total = logged.total;
+    this.#seen = logged.seen;
+  }
+  /** The session these totals belong to; `/new` and `/resume` bring another. */
+  get session() {
+    return this.#session;
+  }
+  /**
+   * Move to another session: a new conversation starts at nothing, a resumed one
+   * at what its log already recorded. False when it is the session already read.
+   */
+  follow(session) {
+    if (session === this.#session) return false;
+    this.#session = session;
+    const logged = loggedUsage(session);
+    this.#total = logged.total;
+    this.#seen = logged.seen;
+    this.beginCall();
+    return true;
+  }
+  /** A model call starts: nothing of this call has been reported yet. */
+  beginCall() {
+    this.#call = { input: 0, output: 0, cacheRead: 0 };
+  }
+  /** Add one usage report. A count the server did not send is not a zero. */
+  add(report) {
+    this.#grow("input", report.input);
+    this.#grow("output", report.output);
+    this.#grow("cacheRead", report.cacheRead);
+  }
+  #grow(key, value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) return;
+    const count = Math.max(0, value);
+    const last = this.#call[key];
+    this.#call[key] = count;
+    this.#total[key] += count >= last ? count - last : count;
+    this.#seen[key] = true;
+  }
+  /**
+   * The row's readings. A glyph the session has never been told about reads
+   * `undefined`, which is how the footer is told to leave it off the row rather
+   * than print a zero.
+   */
+  get readings() {
+    return {
+      inputTokens: this.#seen.input ? this.#total.input : void 0,
+      outputTokens: this.#seen.output ? this.#total.output : void 0,
+      cacheRead: this.#seen.cacheRead ? this.#total.cacheRead : void 0
+    };
+  }
+};
+
+// src/ui/task-panel.ts
+function safeText(value) {
+  return withoutEmoji(value).replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, " ").replace(/\s+/g, " ").trim();
+}
+function taskItems(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const items = [];
+  for (const item of raw) {
+    if (item === null || typeof item !== "object") return void 0;
+    const value = item;
+    if (typeof value.content !== "string" || !["pending", "in_progress", "completed"].includes(String(value.status))) return void 0;
+    items.push({ content: safeText(value.content), status: value.status });
+  }
+  return items;
+}
+var TaskPanel = class {
+  constructor(icons, now = Date.now) {
+    this.icons = icons;
+    this.now = now;
+  }
+  icons;
+  now;
+  tasks = [];
+  expanded = false;
+  get active() {
+    return this.visible && this.tasks.some((item) => item.status === "in_progress");
+  }
+  get visible() {
+    return this.tasks.some((item) => item.status !== "completed");
+  }
+  get done() {
+    return this.tasks.filter((item) => item.status === "completed").length;
+  }
+  /** Return a completion count only when an open list just became complete. */
+  setTasks(tasks) {
+    const wasOpen = this.visible;
+    this.tasks = tasks.map((item) => ({ ...item, content: safeText(item.content) }));
+    return wasOpen && tasks.length > 0 && !this.visible ? tasks.length : void 0;
+  }
+  clearTasks() {
+    this.tasks = [];
+    this.expanded = false;
+  }
+  toggleExpanded() {
+    this.expanded = !this.expanded;
+  }
+  selectedIndexes() {
+    if (this.expanded || this.tasks.length <= 6) return this.tasks.map((_, i) => i);
+    const active = this.tasks.flatMap((item, i) => item.status === "in_progress" ? [i] : []);
+    const anchors = active.length > 0 ? active : [this.tasks.findIndex((item) => item.status === "pending")];
+    const ranked = this.tasks.map((_, i) => ({ i, distance: Math.min(...anchors.map((a) => Math.abs(i - a))) }));
+    ranked.sort((a, b) => a.distance - b.distance || a.i - b.i);
+    return ranked.slice(0, 5).map(({ i }) => i).sort((a, b) => a - b);
+  }
+  /** Plain text snapshot for pipes: one block per todo/write, no animation. */
+  plainLines() {
+    if (this.tasks.length === 0) return [];
+    return [`Tasks ${this.done}/${this.tasks.length}`, ...this.tasks.map((item) => {
+      const mark = item.status === "completed" ? this.icons.ok : item.status === "pending" ? this.icons.think === "*" ? "o" : "\u25CB" : this.icons.think === "*" ? "*" : "\u273B";
+      return `${mark} ${item.content}`;
+    })];
+  }
+  render(width) {
+    if (!this.visible) return [];
+    const available = Math.max(1, width - 4);
+    const indexes = this.selectedIndexes();
+    const lines = [`  ${ansi.bold(`Tasks  ${this.done}/${this.tasks.length}`)}`];
+    for (const i of indexes) {
+      const item = this.tasks[i];
+      const mark = item.status === "completed" ? ansi.green(this.icons.ok) : item.status === "in_progress" ? ansi.bold(spinnerFrame(this.now(), this.icons)) : this.icons.think === "*" ? "o" : "\u25CB";
+      const content = clipCells(item.content, Math.max(1, available - 2));
+      lines.push(`  ${mark} ${item.status === "completed" ? ansi.dim(content) : item.status === "in_progress" ? ansi.bold(content) : content}`);
+    }
+    if (indexes.length < this.tasks.length) {
+      lines.push(`  ${ansi.dim(`\u2026 ${this.tasks.length - indexes.length} more`)}`);
+    }
+    return lines;
+  }
+  invalidate() {
+  }
+};
+
+// src/ui/bruine-ui.ts
+import { parse as parseYaml2 } from "yaml";
+import {
+  Container as Container4,
+  matchesKey as matchesKey4,
+  ProcessTerminal,
+  SelectList,
+  Spacer,
+  Text as Text3,
+  TuiMainScreen,
+  truncateToWidth as truncateToWidth6,
+  visibleWidth as visibleWidth15
+} from "@earendil-works/pi-tui";
+
+// src/ui/footer.ts
+import { truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth5 } from "@earendil-works/pi-tui";
+import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { isAbsolute as isAbsolute5, join as join3 } from "path";
+
+// src/ui/place.ts
+import { homedir as homedir3 } from "os";
+import { posix, win32 } from "path";
+
+// src/ui/jump-latest.ts
+import { stripTerminalSequences, visibleWidth as visibleWidth6 } from "@earendil-works/pi-tui";
+
+// src/setup/skills.ts
+import { cp, lstat, mkdir, readFile, readdir, rename, rm, symlink, writeFile } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import path5, { dirname, join as join4 } from "path";
+
+// src/ui/shell.ts
+import { Container as Container2 } from "@earendil-works/pi-tui";
+
+// src/ui/questions.ts
+import { isKeyRelease, matchesKey, wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-works/pi-tui";
+import stringWidth8 from "string-width";
+
+// src/ui/box.ts
+import { truncateToWidth as truncateToWidth3, visibleWidth as visibleWidth7 } from "@earendil-works/pi-tui";
+
+// src/ui/keys.ts
+import { decodeKittyPrintable } from "@earendil-works/pi-tui";
+
+// src/ui/prompt-frame.ts
+import { stripTerminalSequences as stripTerminalSequences2, truncateToWidth as truncateToWidth4, visibleWidth as visibleWidth9 } from "@earendil-works/pi-tui";
+
+// src/ui/working.ts
+import { visibleWidth as visibleWidth8 } from "@earendil-works/pi-tui";
+
+// src/llm/silence.ts
+var STREAM_CEILING_MS = 15 * 60 * 1e3;
+var SECOND = 1e3;
+var MINUTE = 60 * SECOND;
+var PHASE_BUDGET_MS = {
+  waiting: 2 * MINUTE,
+  thinking: 90 * SECOND,
+  preparing: 3 * MINUTE,
+  answering: 60 * SECOND,
+  calling: 2 * MINUTE
+};
+var PER_THOUSAND_CHARS_MS = 6 * SECOND;
+var MAX_SIZE_BONUS_MS = 10 * MINUTE;
+var MIN_BUDGET_MS = 20 * SECOND;
+function formatSilence(ms) {
+  const s = Math.round(ms / 1e3);
+  if (s < 60) return `${String(s)}s`;
+  const m = Math.floor(s / 60);
+  const rest = s % 60;
+  return rest === 0 ? `${String(m)}m` : `${String(m)}m ${String(rest)}s`;
+}
+
+// src/ui/escape-filter.ts
+import { isKeyRelease as isKeyRelease2, isKeyRepeat, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+
+// src/ui/header.ts
+import { visibleWidth as visibleWidth10 } from "@earendil-works/pi-tui";
+var LOGO_CELLS = LOGO[0].length;
+var LOGO_GAP = 3;
+var LOGO_MIN_WIDTH = LOGO_CELLS + LOGO_GAP + 28;
+var RESOURCE_PREFIX = 2 + 9;
+var LOGO_BESIDE_GAP = " ".repeat(LOGO_GAP);
+
+// src/ui/intro.ts
+import { existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+
+// src/ui/intro-effects.ts
+var H = LOGO.length;
+var W = LOGO[0].length;
+var target = (r, c2) => LOGO[r][c2];
+var letters = () => {
+  const out = [];
+  for (let r = 0; r < H; r += 1) for (let c2 = 0; c2 < W; c2 += 1) if (target(r, c2) !== " ") out.push([r, c2]);
+  return out;
+};
+var LETTERS = letters();
+
+// src/ui/weather-effect.ts
+import { mkdir as mkdir2, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { readFileSync as readFileSync9 } from "fs";
+import { randomUUID } from "crypto";
+import { visibleWidth as visibleWidth11 } from "@earendil-works/pi-tui";
+var QUIET_INK = { far: ansi.faint, mid: ansi.faint, near: ansi.gray };
+var STORM_INK = { far: ansi.faint, mid: ansi.gray, near: ansi.violet };
+
+// src/ui/queued-prompts.ts
+import { truncateToWidth as truncateToWidth5 } from "@earendil-works/pi-tui";
+
+// src/ui/approval-band.ts
+import { matchesKey as matchesKey3, visibleWidth as visibleWidth12, wrapTextWithAnsi as wrapTextWithAnsi3 } from "@earendil-works/pi-tui";
+
+// src/ui/file-complete.ts
+import { CombinedAutocompleteProvider } from "@earendil-works/pi-tui";
+import { existsSync as existsSync6, readdirSync } from "fs";
+import { basename, delimiter as delimiter2, join as join6, relative as relative2 } from "path";
+
+// src/image/clipboard.ts
+import { readFileSync as readFileSync10 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { platform } from "os";
+import { extname } from "path";
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+
+// src/ui/selection.ts
+import { Container as Container3, sliceByColumn as sliceByColumn2, stripTerminalSequences as stripTerminalSequences3, visibleWidth as visibleWidth13 } from "@earendil-works/pi-tui";
+
+// src/ui/mouse.ts
+import { appendFileSync } from "fs";
+
+// src/ui/clipboard-write.ts
+import { platform as platform2 } from "os";
+
+// src/ui/toast.ts
+import { visibleWidth as visibleWidth14 } from "@earendil-works/pi-tui";
+
+// src/setup/discover.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { networkInterfaces } from "os";
+import { join as join7 } from "path";
+import { spawnSync } from "child_process";
+import { parse as parseYaml } from "yaml";
+
+// src/image/vision.ts
+var TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "vision", "multimodal", "image", "images"]);
+var VISION_KEYS = ["capabilities", "vision", "multimodal", "image", "images"];
+function declaresVision(value) {
+  if (value === true) return true;
+  if (typeof value === "string") {
+    return value.split(/[\s,;|]+/).some((word) => TRUE_WORDS.has(word.toLowerCase()));
+  }
+  if (Array.isArray(value)) {
+    return value.some((v) => typeof v === "string" && TRUE_WORDS.has(v.toLowerCase()));
+  }
+  return false;
+}
+function entryVisionAnswer(entry) {
+  if (entry === null || typeof entry !== "object") return "unknown";
+  const record = entry;
+  let declared = false;
+  for (const key of VISION_KEYS) {
+    const value = record[key];
+    if (value === void 0 || value === null) continue;
+    declared = true;
+    if (declaresVision(value)) return "yes";
+  }
+  return declared ? "no" : "unknown";
+}
+function settingsEntryAnswer(entry) {
+  return entryVisionAnswer(entry);
+}
+
+// src/ui/bruine-ui.ts
+import { existsSync as existsSync7, readFileSync as readFileSync12 } from "fs";
+import { join as join9 } from "path";
+
+// src/update.ts
+import { spawn } from "child_process";
+import { realpathSync as realpathSync2 } from "fs";
+import { mkdir as mkdir3, readFile as readFile4, rename as rename3, writeFile as writeFile3 } from "fs/promises";
+import path6 from "path";
+var NPM_PACKAGE = "@ziamana/bruine";
+var REGISTRY_LATEST = `https://registry.npmjs.org/${NPM_PACKAGE.replace("/", "%2F")}/latest`;
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+
+// src/ui/bruine-ui.ts
+function readSettingsRoute(dshHome) {
+  try {
+    const home = dshHome ?? runtimeHome();
+    const p = join9(home, "settings.yaml");
+    if (!existsSync7(p)) return void 0;
+    const doc = parseBruineSettingsYaml(readFileSync12(p, "utf8"));
+    if (doc === void 0) return void 0;
+    return doc;
+  } catch {
+    return void 0;
+  }
+}
+function parseBruineSettingsYaml(text) {
+  const doc = parseYaml2(text);
+  const def = doc?.["agent-default-model"];
+  const provider = typeof def?.provider === "string" ? def.provider : void 0;
+  const model = typeof def?.model === "string" ? def.model : void 0;
+  if (provider === void 0 || model === void 0) return void 0;
+  const route = doc?.["llm-pi-ai"]?.providers?.[provider];
+  const entry = Array.isArray(route?.models) ? route.models.find((m) => m !== null && typeof m === "object" && m.id === model) : void 0;
+  const out = { provider, model };
+  if (typeof route?.baseURL === "string") out.baseUrl = route.baseURL;
+  if (typeof entry?.name === "string") out.name = entry.name;
+  if (typeof entry?.contextWindow === "number") out.contextWindow = entry.contextWindow;
+  if (typeof route?.displayName === "string") out.providerDisplayName = route.displayName;
+  if (entry?.compat?.thinkingFormat !== void 0) out.hasCompat = true;
+  const vision = settingsEntryAnswer(entry);
+  if (vision !== "unknown") out.vision = vision;
+  return out;
+}
+
+// src/ui/errors.ts
+import { appendFile, mkdir as mkdir4 } from "fs/promises";
+import { join as join10 } from "path";
+import { truncateToWidth as truncateToWidth7, wrapTextWithAnsi as wrapTextWithAnsi4 } from "@earendil-works/pi-tui";
+function firstLine(text) {
+  return (text.split(/\r?\n/)[0] ?? text).trim();
+}
+function statusOf(failure) {
+  if (typeof failure.status === "number") return failure.status;
+  const m = /\b(4\d\d|5\d\d)\b/.exec(typeof failure.message === "string" ? failure.message : "");
+  return m?.[1] === void 0 ? void 0 : Number(m[1]);
+}
+function timeoutSeconds(message) {
+  const s = /(\d+(?:[.,]\d+)?)\s*sec(?:onds?)?\b/i.exec(message) ?? /(\d+(?:[.,]\d+)?)\s*s\b/i.exec(message);
+  if (s?.[1] !== void 0) return Number(s[1].replace(",", "."));
+  const ms = /(\d+(?:[.,]\d+)?)\s*ms\b/i.exec(message);
+  return ms?.[1] === void 0 ? void 0 : Math.round(Number(ms[1].replace(",", ".")) / 100) / 10;
+}
+function formatK(n) {
+  const k = n / 1e3;
+  return `${k >= 10 ? Math.round(k) : Math.round(k * 10) / 10}k`;
+}
+function describeLlmError(failure, route) {
+  const code = typeof failure.code === "string" ? failure.code : "UNKNOWN";
+  const message = typeof failure.message === "string" ? failure.message : "";
+  const status = statusOf(failure);
+  const server = route.baseUrl;
+  const at = server === void 0 ? "the model server" : `your model server at ${server}`;
+  if (code === "AUTH" || status === 401 || status === 403 || /\b40[13]\b/.test(message)) {
+    return { message: `The API key was refused by ${route.provider}`, hint: "Set a new key: bruine setup" };
+  }
+  if (status === 404 || /\b404\b|model.{0,30}(not found|does not exist)/i.test(message)) {
+    return {
+      message: `Model "${route.model}" not found on ${server ?? "the model server"}`,
+      hint: "Change it: bruine setup",
+      wantAvailableModels: true
+    };
+  }
+  if (code === "RATE_LIMIT" || status === 429) {
+    return { message: `Rate limited by ${route.provider}`, hint: "Wait a moment and try again" };
+  }
+  if (code === "QUOTA_EXCEEDED") {
+    return { message: `Quota exceeded at ${route.provider}`, hint: "Check the account balance: bruine setup" };
+  }
+  if (code === "CONTEXT_WINDOW_EXCEEDED") {
+    const n = route.contextWindow !== void 0 && route.contextWindow > 0 ? ` (${formatK(route.contextWindow)})` : "";
+    return { message: `The conversation is larger than the model's context${n}`, hint: "Use /compact or /new" };
+  }
+  if (code === "TIMEOUT" || /\btime(?:d)?\s*out\b|timeout/i.test(message)) {
+    const secs = timeoutSeconds(message);
+    return {
+      message: `The model server did not answer in time${secs === void 0 ? "" : ` (${String(secs)}s)`}`,
+      hint: "It may still be loading the model. Try again, or check the server logs"
+    };
+  }
+  if (code === "TRANSPORT" || /\bECONN|\b(?:network|connection|socket|fetch|dns)\b/i.test(message)) {
+    return {
+      message: `Can't reach ${at}`,
+      hint: "Is llama.cpp / Ollama / LM Studio running?  Change it: bruine setup"
+    };
+  }
+  if (code === "SERVER" || status !== void 0 && status >= 500) {
+    return {
+      message: `The model server returned an error (${String(status ?? code)})`,
+      hint: firstLine(message) === "" ? "Try again" : firstLine(message)
+    };
+  }
+  if (code === "ABORTED" || code === "CANCELLED" || /\b(cancell?ed|aborted|interrupted)\b/i.test(message)) {
+    const said = firstLine(message);
+    return {
+      message: said === "" ? "The turn was cancelled" : said,
+      hint: "You stopped this turn. Ask again, or /new to start clean"
+    };
+  }
+  return {
+    message: firstLine(message) === "" ? `${route.provider}: unknown model error` : firstLine(message),
+    hint: "Details in logs/bruine.log; if it repeats: bruine setup"
+  };
+}
+async function fetchAvailableModels(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, "")}/models`, {
+      signal: AbortSignal.timeout(1e3)
+    });
+    if (!res.ok) return [];
+    const body = await res.json();
+    const raw = Array.isArray(body?.data) ? body.data : Array.isArray(body?.models) ? body.models : [];
+    return raw.map((m) => String(m?.id ?? m?.model ?? "")).filter((id) => id !== "" && id !== "undefined").slice(0, 3);
+  } catch {
+    return [];
+  }
+}
+function bruineLogPath(env = process.env) {
+  const home = runtimeHome(env);
+  return join10(home, "logs", "bruine.log");
+}
+async function appendErrorLog(failure, extra = "") {
+  const path7 = bruineLogPath();
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} [llm-error] code=${String(failure.code ?? "UNKNOWN")}${failure.status === void 0 ? "" : ` status=${String(failure.status)}`} ${String(failure.message ?? "").slice(0, 2e3)}${extra === "" ? "" : ` ${extra}`}
+`;
+  try {
+    await mkdir4(join10(path7, ".."), { recursive: true });
+    await appendFile(path7, line, "utf8");
+  } catch {
+  }
+}
+
+// src/ui/retry.ts
+function silenceOf(failure) {
+  if (typeof failure?.silenceMs === "number") return failure.silenceMs;
+  const ms = /after (\d+)\s*ms/.exec(failure?.message ?? "")?.[1];
+  return ms === void 0 ? void 0 : Number(ms);
+}
+function retryCause(failure) {
+  switch (failure?.code) {
+    case "TIMEOUT": {
+      const quiet = silenceOf(failure);
+      return quiet === void 0 ? "The model is not answering." : `The model has not answered for ${formatSilence(quiet)}.`;
+    }
+    case "RATE_LIMIT":
+      return "The provider is limiting requests.";
+    case "SERVER":
+      return "The model's server returned an error.";
+    case "TRANSPORT":
+      return "The connection to the model dropped.";
+    case "EMPTY_RESPONSE":
+      return "The model sent an empty answer.";
+    default:
+      return failure?.code === void 0 ? "The request failed." : `The request failed (${failure.code}).`;
+  }
+}
+function retryCount(event) {
+  return event.maxRetries === void 0 ? String(event.retry) : `${String(event.retry)}/${String(event.maxRetries)}`;
+}
+function retryWait(delayMs) {
+  if (delayMs < 100) return "now";
+  if (delayMs < 1e4) return `in ${(delayMs / 1e3).toFixed(1).replace(/\.0$/, "")}s`;
+  return `in ${formatSilence(delayMs)}`;
+}
+function retryLine(event) {
+  return `${retryCause(event.failure)} Retry ${retryCount(event)} ${retryWait(event.delayMs)}.`;
+}
+
+// src/plugins/silence.ts
+import { existsSync as existsSync8, readFileSync as readFileSync13, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
+import { parse as parseYaml3 } from "yaml";
+var BRUINE_SILENCE_SERVICE = "bruineSilence";
+
+// src/plugins/render.ts
+var name = "bruine-render";
+var BRUINE_RENDER_SERVICE = "bruineRender";
+function stdoutScreen() {
+  return {
+    write: (s) => void process.stdout.write(s),
+    get columns() {
+      return process.stdout.columns ?? 80;
+    }
+  };
+}
+function createUi(screen, icons = bruineIcons()) {
+  return {
+    screen,
+    icons,
+    reasoning: new ReasoningLine(screen, Date.now, icons),
+    text: new TextStream(screen),
+    tools: new ToolCallView(screen, Date.now, icons)
+  };
+}
+function restoreTasks(session) {
+  try {
+    const events = session?.snapshotEvents?.();
+    if (!Array.isArray(events)) return void 0;
+    for (let i = events.length - 1; i >= 0; i--) {
+      if (events[i]?.type === "todo/write") return taskItems(events[i]?.data?.todos);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function reported2(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : void 0;
+}
+function attachTui(ctx, agent, ui, service, getAgent) {
+  const tps = new TpsMeter();
+  const tools = /* @__PURE__ */ new Map();
+  const todoToolIds = /* @__PURE__ */ new Set();
+  const setUiTasks = (tasks) => {
+    ui.setTasks?.(tasks);
+  };
+  let reasoning;
+  let text;
+  let lastInputTokens = 0;
+  let lastOutputTokens = 0;
+  let lastCacheTokens = 0;
+  const spend = new SessionSpend(agent.session);
+  let turnStartWall = Date.now();
+  let turnOutput = 0;
+  let turnBefore;
+  let turnToolIds = [];
+  let turnBreaks = /* @__PURE__ */ new Set();
+  let needBreak = false;
+  let lastUser = "";
+  let currentAnswer = "";
+  let suggestController;
+  service.describe = (callId) => {
+    const comp = tools.get(callId);
+    if (comp === void 0) return void 0;
+    return { tool: comp.tool, summary: comp.summary(80) };
+  };
+  service.cancelSuggest = () => {
+    suggestController?.abort();
+    suggestController = void 0;
+  };
+  const hideWorking = () => {
+    ui.activity?.setNote(void 0);
+    if (ui.activity?.state === "Waiting for model") ui.activity.setState("Working");
+    ui.requestRender();
+  };
+  const showWorking = () => {
+    if (reasoning === void 0 && text === void 0) {
+      ui.showWorking?.();
+      ui.requestRender();
+    }
+  };
+  const closeLive = () => {
+    if (reasoning !== void 0) {
+      reasoning.end();
+      reasoning = void 0;
+      ui.requestRender();
+    }
+    if (text !== void 0) {
+      text.finish();
+      text = void 0;
+    }
+  };
+  const ensureReasoning = () => {
+    if (reasoning === void 0) {
+      reasoning = new ReasoningComponent(Date.now, ui.icons);
+      ui.addChat(reasoning);
+    }
+    return reasoning;
+  };
+  const ensureText = () => {
+    if (text === void 0) {
+      text = new AssistantTextComponent({ onTick: () => ui.requestRender(), icons: ui.icons });
+      ui.addChat(text);
+    }
+    return text;
+  };
+  const ensureTool = (id, toolName) => {
+    let comp = tools.get(id);
+    if (comp === void 0) {
+      const question = toolName === "ask_user_question" ? new QuestionCallComponent(Date.now, ui.icons, { onTick: () => ui.requestRender() }) : void 0;
+      comp = question ?? new ToolCallComponent(toolName, Date.now, ui.icons);
+      tools.set(id, comp);
+      if (needBreak) {
+        turnBreaks.add(id);
+        needBreak = false;
+      }
+      turnToolIds.push(id);
+      if (question !== void 0) ui.addQuestionCall?.(question);
+      else ui.addChat(comp);
+    }
+    return comp;
+  };
+  const footerState = () => ui.footer?.state ?? {};
+  const reportTurnChanges = (ordered) => {
+    const declared = ordered.map((t) => t.comp.touchedPath?.()).filter((p) => p !== void 0);
+    const before = turnBefore;
+    turnBefore = void 0;
+    void turnChanges({ before, declared, cwd: process.cwd() }).then((changed) => {
+      if (changed.length === 0) return;
+      ui.showTurnChanges?.(changed);
+      ui.requestRender();
+    });
+  };
+  const showLlmError = async (failure) => {
+    const f = failure ?? {};
+    const settings = readSettingsRoute();
+    const state2 = footerState();
+    const route = {
+      provider: settings?.providerDisplayName ?? settings?.provider ?? "the model server",
+      model: settings?.model ?? "",
+      ...settings?.baseUrl !== void 0 ? { baseUrl: settings.baseUrl } : {},
+      ...typeof state2.contextWindow === "number" ? { contextWindow: state2.contextWindow } : {}
+    };
+    const lines = describeLlmError(f, route);
+    const message = new Text4(ansi.red(`${ui.icons.fail} ${lines.message}`), 0, 0);
+    const hint = new Text4(dim(lines.hint), 0, 0);
+    ui.addChat(message);
+    ui.addChat(hint);
+    ui.requestRender();
+    if (lines.wantAvailableModels === true && settings?.baseUrl !== void 0) {
+      const ids = await fetchAvailableModels(settings.baseUrl);
+      if (ids.length > 0) {
+        hint.setText(dim(`Available: ${ids.join(", ")}. ${lines.hint}`));
+        ui.requestRender();
+      }
+    }
+    void appendErrorLog(f);
+  };
+  let compactionBefore;
+  let compactionShadowed;
+  const liveAgent = () => {
+    try {
+      return getAgent?.() ?? agent;
+    } catch {
+      return agent;
+    }
+  };
+  ui.setSilenceProbe?.(() => {
+    let silence;
+    try {
+      silence = ctx.get(BRUINE_SILENCE_SERVICE);
+    } catch {
+      return void 0;
+    }
+    const id = liveAgent().session?.id;
+    const reading = silence?.reading(id === void 0 ? void 0 : String(id));
+    return reading === void 0 ? void 0 : { quietMs: Date.now() - reading.quietSince, budgetMs: reading.budget };
+  });
+  let subagentCount = 0;
+  const refreshSubagents = () => {
+    const registry = ctx.get("agents");
+    const candidates = registry?.list?.() ?? [];
+    const root = liveAgent();
+    const owned = /* @__PURE__ */ new Set([root]);
+    let changed = true;
+    while (changed && registry?.isOwnedBy) {
+      changed = false;
+      for (const candidate of candidates) {
+        if (owned.has(candidate) || candidate.session?.id === void 0) continue;
+        for (const parent of owned) {
+          if (!registry.isOwnedBy(candidate.session.id, parent)) continue;
+          owned.add(candidate);
+          changed = true;
+          break;
+        }
+      }
+    }
+    const count = candidates.filter((candidate) => candidate !== root && owned.has(candidate) && candidate.status === "running").length;
+    if (count === subagentCount) return;
+    subagentCount = count;
+    ui.footer.set({ subagents: count });
+    ui.requestRender();
+  };
+  const mainRequests = new MainRequestMemory();
+  const offRequest = ctx.on(
+    "llm/stream",
+    (options, next) => {
+      mainRequests.see(options, liveAgent().session?.id);
+      return next();
+    },
+    { global: true, prepend: true }
+  );
+  const offAgentCreated = ctx.on("agent/created", refreshSubagents);
+  const offAgentStatus = ctx.on("agent/status", refreshSubagents);
+  const offAgentDisposed = ctx.on("agent/disposed", refreshSubagents);
+  refreshSubagents();
+  const offStream = ctx.on("agent/assistant-stream", ({ agent: subject, frame }) => {
+    if (subject !== liveAgent()) return;
+    const f = frame;
+    const now = typeof f.time === "number" ? f.time : Date.now();
+    if (f.type === "start") {
+      tps.startCall(now);
+      if (spend.follow(liveAgent().session)) ui.footer.set(spend.readings);
+      else spend.beginCall();
+      ui.footer.set({ tps: 0, tpsEstimated: false, pp: void 0 });
+      closeLive();
+      void gitStatus(process.cwd()).then((status) => {
+        turnBefore = status;
+      });
+      showWorking();
+      return;
+    }
+    if (f.type === "end") {
+      tps.endCall();
+      ui.footer.set({ tps: tps.measuredTps || tps.estimatedTps, tpsEstimated: tps.measuredTps === 0 && tps.estimatedTps > 0, pp: tps.pp, cachePct: tps.cachePct, cacheFirst: tps.cacheFirst });
+      hideWorking();
+      closeLive();
+      ui.requestRender();
+      return;
+    }
+    const chunk = f.chunk;
+    if (chunk === void 0) return;
+    const trackDelta = (content) => {
+      if (typeof content !== "string" || content.length === 0) return;
+      tps.delta(now, content);
+      ui.footer.set({ tps: tps.measuredTps || tps.estimatedTps, tpsEstimated: tps.measuredTps === 0 && tps.estimatedTps > 0, pp: tps.pp, cachePct: tps.cachePct, cacheFirst: tps.cacheFirst });
+    };
+    switch (chunk.type) {
+      case "reasoning-delta":
+        hideWorking();
+        trackDelta(chunk.text);
+        ensureReasoning().push(chunk.text);
+        ui.requestRender();
+        return;
+      case "text-delta":
+        hideWorking();
+        trackDelta(chunk.text);
+        needBreak = true;
+        currentAnswer += String(chunk.text ?? "");
+        ensureText().push(chunk.text);
+        ui.requestRender();
+        return;
+      case "block-start":
+        if (chunk.blockType !== "reasoning") closeLive();
+        return;
+      case "block-end":
+        if (chunk.block.type === "reasoning") {
+          reasoning?.end();
+          reasoning = void 0;
+          ui.requestRender();
+        } else if (chunk.block.type === "text") {
+          text?.finish();
+          text = void 0;
+        }
+        return;
+      case "tool-call-delta": {
+        hideWorking();
+        trackDelta(chunk.argumentsDelta || chunk.name);
+        const id = String(chunk.id);
+        if (chunk.name === "todo_write") todoToolIds.add(id);
+        if (todoToolIds.has(id)) return;
+        if (chunk.name !== void 0) ensureTool(id, chunk.name);
+        tools.get(id)?.args(chunk.argumentsDelta ?? "");
+        ui.requestRender();
+        return;
+      }
+      case "usage": {
+        const u = chunk.usage ?? {};
+        const tokens = Number(u.outputTokens ?? 0);
+        lastOutputTokens = tokens;
+        lastInputTokens = Number(u.inputTokens ?? lastInputTokens);
+        if (Number.isFinite(tokens)) turnOutput += Math.max(0, tokens);
+        const details = u.prompt_tokens_details ?? u.promptTokensDetails ?? {};
+        const cached2 = Number(
+          u.cacheReadTokens ?? u.cachedTokens ?? u.cache_read ?? details.cached_tokens ?? NaN
+        );
+        if (Number.isFinite(cached2)) lastCacheTokens = Math.max(0, cached2);
+        tps.usage(now, {
+          outputTokens: Number(u.outputTokens ?? NaN),
+          inputTokens: Number(u.inputTokens ?? NaN),
+          cacheReadTokens: cached2
+        });
+        const window = agent.session?.requestContext?.()?.contextWindow;
+        if (typeof window === "number" && window > 0) {
+          ui.footer.set({ contextUsed: lastInputTokens + lastCacheTokens + lastOutputTokens, contextWindow: window });
+        }
+        spend.add({ input: reported2(u.inputTokens), output: reported2(u.outputTokens), cacheRead: reported2(cached2) });
+        ui.footer.set({ ...spend.readings, tps: tps.measuredTps || tps.estimatedTps, tpsEstimated: tps.measuredTps === 0 && tps.estimatedTps > 0, pp: tps.pp, cachePct: tps.cachePct, cacheFirst: tps.cacheFirst });
+        ui.requestRender();
+        return;
+      }
+      case "finish":
+        tps.endCall();
+        ui.footer.set({ tps: tps.measuredTps || tps.estimatedTps, tpsEstimated: tps.measuredTps === 0 && tps.estimatedTps > 0, pp: tps.pp, cachePct: tps.cachePct, cacheFirst: tps.cacheFirst });
+        closeLive();
+        ui.requestRender();
+        return;
+      default:
+        return;
+    }
+  });
+  const offSession = ctx.on("session/event", (session, event) => {
+    if (session !== liveAgent().session) return;
+    switch (event.type) {
+      case "user/message": {
+        if (event.data.source?.kind !== "user") return;
+        const blocks = (event.data.content ?? []).filter((b) => b.type === "text");
+        const content = blocks.map((b) => b.text).join(" ");
+        const trimmed = content.trim();
+        if (trimmed === "") return;
+        if (MODE_ANNOUNCEMENTS.has(trimmed)) return;
+        lastUser = trimmed;
+        ui.addUserPrompt(trimmed);
+        return;
+      }
+      case "turn/start":
+        refreshSubagents();
+        tps.reset();
+        ui.footer.set({ tps: 0, tpsEstimated: false, pp: void 0, cachePct: void 0, cacheFirst: false });
+        turnStartWall = Date.now();
+        turnOutput = 0;
+        turnToolIds = [];
+        turnBreaks = /* @__PURE__ */ new Set();
+        needBreak = false;
+        currentAnswer = "";
+        suggestController?.abort();
+        suggestController = void 0;
+        showWorking();
+        return;
+      case "tool/call": {
+        hideWorking();
+        const id = String(event.data.callId);
+        if (event.data.name === "todo_write") {
+          todoToolIds.add(id);
+          return;
+        }
+        const comp = ensureTool(id, event.data.name);
+        if (event.data.arguments) comp.setArgs(event.data.arguments);
+        ui.requestRender();
+        return;
+      }
+      case "tool/result": {
+        const block = event.data.message?.content?.[0];
+        if (block === void 0 || block.type !== "tool-result") return;
+        if (todoToolIds.delete(String(block.toolCallId))) return;
+        const output = block.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        tools.get(String(block.toolCallId))?.result(block.isError !== true, output);
+        ui.requestRender();
+        return;
+      }
+      case "todo/write": {
+        const tasks = taskItems(event.data?.todos);
+        if (tasks !== void 0) setUiTasks(tasks);
+        return;
+      }
+      case "llm/retry": {
+        const data = event.data;
+        closeLive();
+        const mark = ui.icons.think === "*" ? "~" : "\u21BB";
+        ui.addChat(new Text4(`${ansi.yellow(mark)} ${ansi.gray(retryLine(data))}`, 1, 0));
+        ui.activity?.setNote(`retry ${retryCount(data)}`);
+        ui.requestRender();
+        return;
+      }
+      case "llm/retry-started":
+        ui.activity?.setState("Waiting for model");
+        ui.requestRender();
+        return;
+      case "compaction/start": {
+        const state2 = footerState();
+        const pct = typeof state2.contextUsed === "number" && typeof state2.contextWindow === "number" && state2.contextWindow > 0 ? Math.round(state2.contextUsed / state2.contextWindow * 100) : 80;
+        compactionBefore = typeof state2.contextUsed === "number" ? state2.contextUsed : void 0;
+        compactionShadowed = void 0;
+        ui.showNotice?.(
+          `Context ${String(pct)}% full: summarizing the conversation\u2026`
+        );
+        return;
+      }
+      case "compaction/summary": {
+        const n = Number(event.data?.shadowedTokenCount);
+        if (Number.isFinite(n)) compactionShadowed = n;
+        return;
+      }
+      case "compaction/end": {
+        if (event.data?.error === void 0) {
+          if (compactionBefore !== void 0 && compactionShadowed !== void 0) {
+            const after = Math.max(0, compactionBefore - compactionShadowed);
+            ui.addChat(new Text4(dim(`Compacted: ${formatK(compactionBefore)} \u2192 ${formatK(after)} tokens`), 0, 0));
+          } else {
+            ui.addChat(new Text4(dim("Compacted."), 0, 0));
+          }
+        }
+        compactionBefore = void 0;
+        compactionShadowed = void 0;
+        ui.requestRender();
+        return;
+      }
+      case "turn/end": {
+        hideWorking();
+        closeLive();
+        for (const comp of tools.values()) comp.cancel();
+        const window = agent.session?.requestContext?.()?.contextWindow;
+        if (typeof window === "number" && window > 0) {
+          ui.footer.set({
+            contextUsed: lastInputTokens + lastCacheTokens + lastOutputTokens,
+            contextWindow: window
+          });
+        }
+        const reason = event.data.reason;
+        const wallSec = Math.max(0, (Date.now() - turnStartWall) / 1e3);
+        if (reason?.kind === "error") {
+          void showLlmError(reason.error);
+          ui.onTurnEnd?.({
+            tools: [],
+            wallSec,
+            outputTokens: turnOutput,
+            cancelled: false,
+            error: true
+          });
+        } else if (reason?.kind === "aborted") {
+          ui.onTurnEnd?.({
+            tools: [],
+            wallSec,
+            outputTokens: 0,
+            cancelled: true,
+            error: false
+          });
+        } else {
+          const ordered = turnToolIds.map((id) => {
+            const comp = tools.get(id);
+            if (comp === void 0) return void 0;
+            return {
+              tool: comp.tool,
+              ok: comp.doneOk ?? false,
+              seconds: comp.seconds ?? 0,
+              comp,
+              breakBefore: turnBreaks.has(id),
+              hidden: comp.tool === "ask_user_question"
+            };
+          }).filter((t) => t !== void 0);
+          reportTurnChanges(ordered);
+          ui.onTurnEnd?.({
+            tools: ordered,
+            wallSec,
+            outputTokens: turnOutput,
+            cancelled: false,
+            error: false
+          });
+          void triggerSuggest();
+        }
+        turnToolIds = [];
+        turnBreaks = /* @__PURE__ */ new Set();
+        needBreak = false;
+        turnOutput = 0;
+        ui.requestRender();
+        return;
+      }
+      default:
+        return;
+    }
+  });
+  const restored = restoreTasks(agent.session);
+  if (restored !== void 0) setUiTasks(restored);
+  ui.footer.set(spend.readings);
+  function suggestionsEnabled() {
+    try {
+      const home = process.env.DSH_HOME;
+      if (home === void 0 || home === "") return true;
+      const raw = readFileSync14(configReadPath(home), "utf8");
+      const doc = JSON.parse(raw);
+      return doc.suggestions ?? true;
+    } catch {
+      return true;
+    }
+  }
+  function fastRoute() {
+    try {
+      const home = process.env.DSH_HOME;
+      if (home !== void 0 && home !== "") {
+        const raw = readFileSync14(configReadPath(home), "utf8");
+        const doc = JSON.parse(raw);
+        const fast = doc.models?.fast ?? doc.models?.main;
+        if (fast?.provider !== void 0 && fast?.model !== void 0) {
+          return { provider: fast.provider, model: fast.model };
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  async function triggerSuggest() {
+    const modes = ctx.get("modes");
+    if (!shouldSuggest({ enabled: suggestionsEnabled(), plan: modes?.plan === true, lastUser, answer: currentAnswer })) return;
+    const route = fastRoute();
+    if (route === void 0) return;
+    const llm = ctx.get("llm");
+    if (llm === void 0) return;
+    suggestController?.abort();
+    const controller = new AbortController();
+    suggestController = controller;
+    const timer = setTimeout(() => controller.abort(), 4e3);
+    try {
+      let off = false;
+      try {
+        const info = await llm.resolveModelInfo?.(route.provider, route.model);
+        off = (info?.reasoning?.efforts ?? []).some((e) => e.id === "off");
+      } catch {
+        off = false;
+      }
+      const last = mainRequests.last;
+      const effort = off ? { effort: "off" } : {};
+      const request = last !== void 0 && sameRoute(route, last) ? sharedPrefixRequest(last, currentAnswer, effort) : standaloneRequest(route, lastUser, currentAnswer.slice(-800), effort);
+      let text2 = "";
+      for await (const chunk of llm.stream({ ...request, signal: controller.signal })) {
+        if (controller.signal.aborted) return;
+        if (chunk.type === "text-delta" && chunk.text !== void 0) text2 += chunk.text;
+      }
+      if (controller.signal.aborted) return;
+      const words = text2.trim().split(/\s+/).filter((w) => w !== "").slice(0, 8);
+      if (words.length === 0) return;
+      if (controller.signal.aborted) return;
+      ui.setGhost?.(words.join(" "));
+      ui.requestRender();
+    } catch {
+    } finally {
+      clearTimeout(timer);
+      if (suggestController === controller) suggestController = void 0;
+    }
+  }
+  return () => {
+    hideWorking();
+    closeLive();
+    for (const comp of tools.values()) comp.cancel();
+    ui.requestRender();
+    offRequest();
+    offAgentCreated();
+    offAgentStatus();
+    offAgentDisposed();
+    if (subagentCount > 0) {
+      ui.footer.set({ subagents: 0 });
+      ui.requestRender();
+    }
+    offStream();
+    offSession();
+  };
+}
+function attach(ctx, agent, ui) {
+  const started = /* @__PURE__ */ new Set();
+  const todoToolIds = /* @__PURE__ */ new Set();
+  const taskPanel = new TaskPanel(ui.icons);
+  const showTasks = (raw) => {
+    const tasks = taskItems(raw);
+    if (tasks === void 0) return;
+    taskPanel.setTasks(tasks);
+    const lines = taskPanel.plainLines();
+    if (lines.length > 0) ui.screen.write(`${lines.join("\n")}
+`);
+  };
+  let compactionBefore;
+  let compactionShadowed;
+  const offStream = ctx.on("agent/assistant-stream", ({ agent: subject, frame }) => {
+    if (subject !== agent) return;
+    const f = frame;
+    if (f.type === "start") {
+      ui.reasoning.end();
+      return;
+    }
+    if (f.type === "end") {
+      ui.reasoning.end();
+      return;
+    }
+    const chunk = f.chunk;
+    if (chunk === void 0) return;
+    switch (chunk.type) {
+      case "reasoning-delta":
+        ui.reasoning.push(chunk.text);
+        return;
+      case "text-delta":
+        ui.text.push(chunk.text);
+        return;
+      case "block-start":
+        if (chunk.blockType !== "reasoning") ui.reasoning.end();
+        return;
+      case "block-end":
+        if (chunk.block.type === "reasoning") ui.reasoning.end();
+        else if (chunk.block.type === "text") ui.text.end();
+        return;
+      case "tool-call-delta": {
+        const id = String(chunk.id);
+        if (chunk.name === "todo_write") todoToolIds.add(id);
+        if (todoToolIds.has(id)) return;
+        if (chunk.name !== void 0 && !started.has(id)) {
+          started.add(id);
+          ui.tools.start(id, chunk.name);
+        }
+        if (chunk.argumentsDelta) ui.tools.args(id, chunk.argumentsDelta);
+        return;
+      }
+      case "usage":
+      case "finish":
+        return;
+      default:
+        return;
+    }
+  });
+  const offSession = ctx.on("session/event", (session, event) => {
+    if (session !== agent.session) return;
+    switch (event.type) {
+      case "tool/call": {
+        const id = String(event.data.callId);
+        if (event.data.name === "todo_write") {
+          todoToolIds.add(id);
+          return;
+        }
+        if (started.has(id)) return;
+        started.add(id);
+        ui.tools.start(id, event.data.name);
+        if (event.data.arguments) ui.tools.args(id, event.data.arguments);
+        return;
+      }
+      case "tool/result": {
+        const block = event.data.message?.content?.[0];
+        if (block === void 0 || block.type !== "tool-result") return;
+        if (todoToolIds.delete(String(block.toolCallId))) return;
+        const output = block.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+        ui.tools.result(String(block.toolCallId), block.isError !== true, output);
+        started.delete(String(block.toolCallId));
+        return;
+      }
+      case "todo/write":
+        showTasks(event.data?.todos);
+        return;
+      case "compaction/start":
+        ui.screen.write("\nsummarizing the conversation\u2026\n");
+        return;
+      case "compaction/summary": {
+        const n = Number(event.data?.shadowedTokenCount);
+        if (Number.isFinite(n)) compactionShadowed = n;
+        return;
+      }
+      case "compaction/end":
+        if (compactionBefore !== void 0 && compactionShadowed !== void 0) {
+          const after = Math.max(0, compactionBefore - compactionShadowed);
+          ui.screen.write(`${dim(`Compacted: ${formatK(compactionBefore)} \u2192 ${formatK(after)} tokens`)}
+`);
+        } else {
+          ui.screen.write(`${dim("Compacted.")}
+`);
+        }
+        compactionBefore = void 0;
+        compactionShadowed = void 0;
+        return;
+      case "turn/end": {
+        ui.reasoning.end();
+        ui.text.end();
+        const reason = event.data.reason;
+        if (reason?.kind === "error") {
+          const settings = readSettingsRoute();
+          const lines = describeLlmError(reason.error ?? {}, {
+            provider: settings?.providerDisplayName ?? settings?.provider ?? "the model server",
+            model: settings?.model ?? "",
+            ...settings?.baseUrl !== void 0 ? { baseUrl: settings.baseUrl } : {}
+          });
+          ui.screen.write(`
+${ui.icons.fail} ${lines.message}
+${dim(lines.hint)}
+`);
+          void appendErrorLog(reason.error ?? {});
+        } else if (reason?.kind === "aborted") {
+          ui.screen.write("\n- cancelled\n");
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  });
+  const restored = restoreTasks(agent.session);
+  if (restored !== void 0) showTasks(restored);
+  return () => {
+    offStream();
+    offSession();
+  };
+}
+function apply(ctx) {
+  const service = {};
+  if (appEnv("HEADLESS") === "1") {
+    ctx.provide(BRUINE_RENDER_SERVICE, service);
+    return;
+  }
+  if (process.stdin.isTTY === true && process.stdout.isTTY === true) {
+    ctx.provide(BRUINE_RENDER_SERVICE, service);
+    ctx.inject(["bruineRepl"], (c2) => {
+      const repl = c2.bruineRepl;
+      if (repl?.agent !== void 0 && repl.ui !== void 0) {
+        attachTui(ctx, repl.agent, repl.ui, service, () => repl.agent);
+      }
+    });
+    return;
+  }
+  const ui = createUi(stdoutScreen());
+  service.screen = ui;
+  ctx.provide(BRUINE_RENDER_SERVICE, service);
+  ctx.inject(["bruineRepl"], (c2) => {
+    const repl = c2.bruineRepl;
+    if (repl?.agent !== void 0) attach(ctx, repl.agent, ui);
+  });
+}
+export {
+  BRUINE_RENDER_SERVICE,
+  apply,
+  attach,
+  attachTui,
+  createUi,
+  name,
+  stdoutScreen
+};