pi-focus-mode 0.1.0

package/focus-mode.js

@@ -0,0 +1,2097 @@
+// extensions/focus-mode/focus-mode.ts
+import { AssistantMessageComponent, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
+
+// shared/announce.ts
+var stderrAnnounced = /* @__PURE__ */ new Set();
+function announce(ctx, message, level, reason = message) {
+  if (ctx?.hasUI === false) {
+    if (stderrAnnounced.has(reason)) return;
+    stderrAnnounced.add(reason);
+    try {
+      process.stderr.write(`${message}
+`);
+    } catch {
+    }
+    return;
+  }
+  try {
+    ctx?.ui?.notify?.(message, level);
+  } catch {
+  }
+}
+
+// shared/settings.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+var announcedConfigErrors = /* @__PURE__ */ new Set();
+function readConfig(path, ctx) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    if (!announcedConfigErrors.has(path)) {
+      announcedConfigErrors.add(path);
+      const message = error instanceof Error ? error.message : String(error);
+      announce(ctx, `settings: could not parse ${path} (${message}); using defaults.`, "warning", `settings-parse:${path}`);
+    }
+    return {};
+  }
+}
+function resolveSettings(name, definitions, context, runtime = {}) {
+  const environment = runtime.environment ?? process.env;
+  const globalPath = join(runtime.agentDir ?? getAgentDir(), `${name}.json`);
+  const projectPath = join(context.cwd, CONFIG_DIR_NAME, `${name}.json`);
+  const globalConfig = readConfig(globalPath, context);
+  const projectConfig = context.isProjectTrusted() ? readConfig(projectPath, context) : {};
+  const resolved = {};
+  for (const key of Object.keys(definitions)) {
+    const definition = definitions[key];
+    let value = definition.default;
+    let provenance = { source: "default" };
+    if (definition.discover) {
+      try {
+        const discovered = definition.discover();
+        if (discovered !== void 0) {
+          value = discovered.value;
+          provenance = { source: "discovered", name: definition.discoverName ?? "discovery" };
+        }
+      } catch {
+      }
+    }
+    if (Object.hasOwn(globalConfig, key)) {
+      value = globalConfig[key];
+      provenance = { source: "global", path: globalPath };
+    }
+    if (Object.hasOwn(projectConfig, key)) {
+      value = projectConfig[key];
+      provenance = { source: "project", path: projectPath };
+    }
+    const environmentValue = environment[definition.env];
+    if (environmentValue !== void 0) {
+      value = definition.parseEnv ? definition.parseEnv(environmentValue) : environmentValue;
+      provenance = { source: "environment", name: definition.env };
+    }
+    resolved[key] = { value, provenance };
+  }
+  return resolved;
+}
+
+// extensions/focus-mode/src/fold-picker.ts
+import { Key, matchesKey, truncateToWidth as truncateToWidth2, visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+
+// extensions/focus-mode/src/thinking-width.ts
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+function fitThinkingLine(text, width) {
+  const start = Math.max(-1, ...[...text.matchAll(/◈ (?!\d+(?: |$))/g)].map((match) => match.index));
+  const suffixStart = start < 0 ? -1 : text.indexOf(" \xB7 ", start);
+  if (suffixStart < 0) return truncateToWidth(text, width, "\u2026").replace(/\x1b\[0m(?=…)/g, "");
+  const suffix = text.slice(suffixStart);
+  if (visibleWidth(suffix) >= width) return truncateToWidth(text, width, "\u2026").replace(/\x1b\[0m(?=…)/g, "");
+  const available = Math.max(0, width - visibleWidth(suffix));
+  if (visibleWidth(text) <= width) return text;
+  return truncateToWidth(text.slice(0, suffixStart), available, "\u2026").replace(/\x1b\[0m(?=…)/g, "") + suffix;
+}
+
+// extensions/focus-mode/src/fold-picker.ts
+var FoldPicker = class {
+  selected = 0;
+  model;
+  getTheme;
+  requestRender;
+  done;
+  constructor(model, getTheme, requestRender, done) {
+    this.model = model;
+    this.getTheme = getTheme;
+    this.requestRender = requestRender;
+    this.done = done;
+  }
+  items() {
+    const items = [];
+    let exchange = 0;
+    for (const process2 of this.model.processes()) {
+      if (process2.exchange !== exchange) {
+        exchange = process2.exchange;
+        const id = exchange;
+        items.push({ label: `${this.model.isExchangeOpen(id) ? "\u25BE" : "\u25B8"} Exchange ${id}`, toggle: () => {
+          this.model.toggleExchange(id);
+        } });
+      }
+      items.push({ label: `  ${this.model.processLine(process2.id)}`, toggle: () => {
+        this.model.toggleProcess(process2.id);
+      } });
+      for (const block of process2.blocks) {
+        if (block.kind === "thinking") {
+          items.push({ label: `    ${this.model.isThinkingOpen(block.message, block.index) ? "\u25BE" : "\u25B8"} ${this.model.thinkingTitle(block.message, block.index, block.trace, false)}`, toggle: () => {
+            if (this.model.toggleThinking(block.message, block.index) && !this.model.isProcessOpen(process2.id)) this.model.toggleProcess(process2.id);
+          } });
+        } else {
+          const id = block.key.slice(5);
+          const parts = this.model.titleParts(id);
+          items.push({ label: `    ${this.model.isOpen(id) ? "\u25BE" : "\u25B8"} \u2699 ${parts?.name ?? "tool"}  ${parts?.argument ?? ""}  ${parts?.stats ?? ""}`, toggle: () => {
+            if (this.model.toggle(id) && !this.model.isProcessOpen(process2.id)) this.model.toggleProcess(process2.id);
+          } });
+        }
+      }
+    }
+    return items;
+  }
+  render(width) {
+    const rows = this.items();
+    const theme = this.getTheme();
+    const fit = (content) => {
+      const clipped = truncateToWidth2(content, width, "\u2026");
+      return theme.bg("customMessageBg", clipped) + theme.bg("customMessageBg", " ".repeat(Math.max(0, width - visibleWidth2(clipped))));
+    };
+    const styleText = (content, availableWidth = width) => {
+      const clipped = truncateToWidth2(content, availableWidth, "\u2026").replaceAll("\x1B[0m", "");
+      const colored = theme.fg("dim", clipped);
+      return theme.italic?.(colored) ?? colored;
+    };
+    const border = fit(theme.fg("dim", "\u2500".repeat(width)));
+    const lines = [border, fit(styleText("Fold exchange / process / block"))];
+    if (!rows.length) return [...lines, fit(styleText("  No blocks yet")), border];
+    this.selected = Math.min(this.selected, rows.length - 1);
+    return [...lines, ...rows.map((row, index) => {
+      const mark = index === this.selected ? ">" : " ";
+      return fit(mark + styleText(fitThinkingLine(` ${row.label}`, Math.max(0, width - 1)), Math.max(0, width - 1)));
+    }), border];
+  }
+  handleInput(data) {
+    const rows = this.items();
+    if (matchesKey(data, Key.escape)) {
+      this.done();
+      return;
+    }
+    if (matchesKey(data, Key.up)) this.selected = Math.max(0, this.selected - 1);
+    else if (matchesKey(data, Key.down)) this.selected = Math.min(rows.length - 1, this.selected + 1);
+    else if (matchesKey(data, Key.enter)) rows[this.selected]?.toggle();
+    else return;
+    this.requestRender();
+  }
+  invalidate() {
+  }
+};
+
+// extensions/focus-mode/src/transcript-cursor.ts
+import { Key as Key2, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
+var TranscriptCursor = class {
+  model;
+  changed;
+  done;
+  constructor(model, changed, done) {
+    this.model = model;
+    this.changed = changed;
+    this.done = done;
+  }
+  // The overlay owns focus while the model's existing renderers draw the highlight.
+  render() {
+    return [];
+  }
+  invalidate() {
+  }
+  handleInput(data) {
+    if (matchesKey2(data, Key2.escape)) {
+      this.model.stopCursor();
+      this.changed();
+      this.done();
+    } else if (matchesKey2(data, Key2.up)) {
+      this.model.cursorMove(-1);
+      this.changed();
+    } else if (matchesKey2(data, Key2.down)) {
+      this.model.cursorMove(1);
+      this.changed();
+    } else if (matchesKey2(data, Key2.enter)) {
+      this.model.cursorToggle();
+      this.changed();
+    }
+  }
+};
+
+// extensions/focus-mode/src/headline-scheduler.ts
+var TOKEN_INTERVAL = 400;
+var TIME_INTERVAL_MS = 6e3;
+var TRACE_CHARS = 1500;
+var HeadlineLengthError = class extends Error {
+};
+var HeadlineScheduler = class {
+  blocks = /* @__PURE__ */ new Map();
+  now;
+  timeoutMs;
+  sequence = 0;
+  inFlight = false;
+  abort;
+  timer;
+  disposed = false;
+  announcedFailure = false;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.timeoutMs = options.timeoutMs ?? 8e3;
+  }
+  observe(key, trace) {
+    if (this.disposed || !trace) return;
+    const previous = this.blocks.get(key);
+    if (previous?.settled) return;
+    const tokens = Math.ceil(trace.length / 4);
+    if (previous) {
+      previous.trace = trace;
+      previous.tokens = tokens;
+    } else {
+      this.blocks.set(key, { trace, tokens, startedAt: this.now(), lastRequestedTokens: 0, settled: false, finalRequested: false, appliedSequence: 0 });
+    }
+    this.tick();
+  }
+  settle(key) {
+    const block = this.blocks.get(key);
+    if (!block || block.settled || this.disposed) return;
+    block.settled = true;
+    this.tick();
+  }
+  tick() {
+    if (this.disposed || this.inFlight) return;
+    const at = this.now();
+    for (const [key, block] of this.blocks) {
+      if (block.settled ? !block.finalRequested : block.tokens - block.lastRequestedTokens >= TOKEN_INTERVAL || at - (block.lastRequestedAt ?? block.startedAt) >= TIME_INTERVAL_MS) {
+        this.request(key, block, at);
+        return;
+      }
+    }
+  }
+  request(key, block, at) {
+    this.inFlight = true;
+    block.lastRequestedAt = at;
+    block.lastRequestedTokens = block.tokens;
+    if (block.settled) block.finalRequested = true;
+    const sequence = ++this.sequence;
+    const controller = new AbortController();
+    this.abort = controller;
+    const trace = block.trace.slice(-TRACE_CHARS);
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(new Error("headline timeout"));
+      }, this.timeoutMs);
+      this.timer = timer;
+    });
+    const call = Promise.resolve().then(() => this.options.summarize(trace, controller.signal));
+    void Promise.race([call, timeout]).then((text) => {
+      if (this.disposed || sequence < block.appliedSequence) return;
+      const words = text.trim().split(/\s+/).filter(Boolean).slice(0, 10);
+      if (!words.length) throw new Error("empty headline");
+      block.appliedSequence = sequence;
+      this.options.onHeadline(key, `\u2248 ${words.join(" ")}`);
+    }).catch((error) => {
+      if (this.disposed || sequence < block.appliedSequence) return;
+      block.appliedSequence = sequence;
+      this.options.onHeadline(key, void 0);
+      if (!this.announcedFailure) {
+        this.announcedFailure = true;
+        this.options.onFailure(
+          error instanceof HeadlineLengthError ? "length" : controller.signal.aborted && error instanceof Error && error.message === "headline timeout" ? "timeout" : "error",
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }).finally(() => {
+      if (timer) clearTimeout(timer);
+      if (this.timer === timer) this.timer = void 0;
+      if (this.abort === controller) this.abort = void 0;
+      this.inFlight = false;
+      if (block.settled && block.finalRequested) this.blocks.delete(key);
+      this.tick();
+    });
+  }
+  dispose() {
+    this.disposed = true;
+    this.abort?.abort();
+    if (this.timer) clearTimeout(this.timer);
+    this.blocks.clear();
+  }
+};
+
+// extensions/focus-mode/src/tool-fold.ts
+var MAX_THINKING_MESSAGES = 256;
+function elapsed(ms) {
+  return ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(1)}s`;
+}
+function headline(trace, streaming) {
+  const plain = trace.replace(/^\s*(?:[-*+]|\d+\.)\s+/gm, "").replace(/\*\*|`/g, "");
+  let start = 0;
+  let last = "Thinking";
+  const boundaries = streaming ? /[.?!]+(?=\s)|[。？！]+|\r?\n/g : /[.?!]+(?=\s|$)|[。？！]+|\r?\n/g;
+  for (const end of plain.matchAll(boundaries)) {
+    const sentence = plain.slice(start, end.index + end[0].length).trim().replace(/\s+/g, " ");
+    if (sentence) last = sentence;
+    start = end.index + end[0].length;
+  }
+  return last;
+}
+var traceHeadline = headline;
+var ThinkingFoldModel = class {
+  blocks = /* @__PURE__ */ new Map();
+  untimedBlocks = /* @__PURE__ */ new WeakMap();
+  now;
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  forMessage(message, create) {
+    if (typeof message.timestamp !== "number" || !Number.isFinite(message.timestamp)) {
+      const existing2 = this.untimedBlocks.get(message);
+      if (existing2 || !create) return existing2;
+      const blocks2 = /* @__PURE__ */ new Map();
+      this.untimedBlocks.set(message, blocks2);
+      return blocks2;
+    }
+    const existing = this.blocks.get(message.timestamp);
+    if (existing || !create) return existing;
+    if (this.blocks.size >= MAX_THINKING_MESSAGES) this.blocks.delete(this.blocks.keys().next().value);
+    const blocks = /* @__PURE__ */ new Map();
+    this.blocks.set(message.timestamp, blocks);
+    return blocks;
+  }
+  observe(message, event, reasoningTokens) {
+    const blocks = this.forMessage(message, event.type === "thinking_delta");
+    if (!blocks) return;
+    const at = this.now();
+    if (event.type === "thinking_delta" && event.contentIndex !== void 0) {
+      const block = blocks.get(event.contentIndex) ?? { startedAt: at, characters: 0 };
+      block.characters += event.delta?.length ?? 0;
+      if (reasoningTokens !== void 0 && reasoningTokens > 0) block.tokens = reasoningTokens;
+      blocks.set(event.contentIndex, block);
+    } else if (event.type === "thinking_end") {
+      const block = event.contentIndex === void 0 ? void 0 : blocks.get(event.contentIndex);
+      if (block && block.endedAt === void 0) block.endedAt = at;
+    } else if (event.type !== "thinking_start") {
+      for (const block of blocks.values()) {
+        if (block.endedAt === void 0) block.endedAt = at;
+      }
+    }
+  }
+  settle(message) {
+    for (const block of this.forMessage(message, false)?.values() ?? []) {
+      if (block.endedAt === void 0) block.endedAt = this.now();
+    }
+  }
+  setHeadline(message, index, headline2) {
+    const block = this.forMessage(message, false)?.get(index);
+    if (block) block.headline = headline2;
+  }
+  record(message, index, trace) {
+    const block = this.forMessage(message, false)?.get(index);
+    return {
+      kind: "thinking",
+      id: `thinking:${message.timestamp}:${index}`,
+      durationMs: block?.endedAt === void 0 ? void 0 : Math.max(0, block.endedAt - block.startedAt),
+      startedAt: block?.startedAt,
+      endedAt: block?.endedAt,
+      status: "done",
+      wordCount: trace.trim().split(/\s+/).filter(Boolean).length,
+      headline: block?.headline ?? headline(trace, false),
+      headlineSource: block?.headline ? "model" : "trace"
+    };
+  }
+  title(message, index, trace, streaming, saved) {
+    const block = this.forMessage(message, false)?.get(index);
+    const ms = saved?.durationMs ?? (block ? Math.max(0, (block.endedAt ?? this.now()) - block.startedAt) : void 0);
+    const label = saved?.kind === "thinking" ? saved.headline : block?.headline ?? headline(trace, streaming && block?.endedAt === void 0);
+    if (!streaming || block?.endedAt !== void 0) {
+      const words = saved?.kind === "thinking" ? saved.wordCount : trace.trim().split(/\s+/).filter(Boolean).length;
+      return `\u25C8 ${label} \xB7 ${ms === void 0 ? "\u2014" : elapsed(ms)} \xB7 ${words} ${words === 1 ? "word" : "words"}`;
+    }
+    const count = block?.tokens ?? Math.max(1, Math.ceil((block?.characters ?? trace.length) / 4));
+    const prefix = block?.tokens === void 0 ? "~" : "";
+    const rate = ms !== void 0 && ms > 0 ? Math.round(count / (ms / 1e3)) : 0;
+    return `\u25C8 ${label} \xB7 ${ms === void 0 ? "\u2014" : elapsed(ms)} \xB7 ${prefix}${count} tok \xB7 ${prefix}${rate} tok/s`;
+  }
+  timing(message, index) {
+    const block = this.forMessage(message, false)?.get(index);
+    return block && { start: block.startedAt, end: block.endedAt };
+  }
+};
+function duration(ms) {
+  if (ms === void 0) return "\u2014";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function summary(args) {
+  if (!args) return "";
+  for (const key of ["command", "path", "pattern"]) {
+    if (typeof args[key] === "string") return args[key].replace(/\s+/g, " ").trim();
+  }
+  const value = Object.values(args).find((item) => typeof item === "string");
+  return typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+}
+function lineCount(result) {
+  const output = result?.content?.filter((item) => item.type === "text").map((item) => item.text ?? "").join("\n") ?? "";
+  if (!output) return 0;
+  return output.replace(/\r?\n$/, "").split(/\r?\n/).length;
+}
+var ToolFoldModel = class {
+  blocks = /* @__PURE__ */ new Map();
+  processList = [];
+  processById = /* @__PURE__ */ new Map();
+  processByBlock = /* @__PURE__ */ new Map();
+  seenContent = /* @__PURE__ */ new Map();
+  exchangeItems = [];
+  progress = /* @__PURE__ */ new Map();
+  progressByItem = /* @__PURE__ */ new Map();
+  openProcess;
+  openThinking = /* @__PURE__ */ new Set();
+  currentExchange = 0;
+  now;
+  thinking;
+  saved;
+  pendingThinking = /* @__PURE__ */ new Map();
+  cursorActive = false;
+  cursorKey;
+  constructor(now = Date.now) {
+    this.now = now;
+    this.thinking = new ThinkingFoldModel(now);
+  }
+  /** Rebuilds process membership from the active branch while keeping restored stats in session entries. */
+  clear(saved) {
+    this.blocks.clear();
+    this.processList = [];
+    this.processById.clear();
+    this.processByBlock.clear();
+    this.seenContent.clear();
+    this.exchangeItems = [];
+    this.progress.clear();
+    this.progressByItem.clear();
+    this.openProcess = void 0;
+    this.openThinking.clear();
+    this.currentExchange = 0;
+    this.thinking = new ThinkingFoldModel(this.now);
+    this.pendingThinking.clear();
+    this.cursorActive = false;
+    this.cursorKey = void 0;
+    this.saved = saved;
+  }
+  /**
+   * Returns the saved display record of each block in the exchange: timing, status
+   * and counts, plus each thinking block's headline. That headline is the model
+   * summary or the trace's last complete sentence, so it can repeat trace text;
+   * the rest of the trace, tool arguments and results stay in Pi messages.
+   */
+  recordsForExchange(exchange) {
+    return this.processList.filter((process2) => process2.exchange === exchange).flatMap((process2) => process2.blocks.map((block) => {
+      if (block.kind === "thinking") return this.pendingThinking.get(block.key) ?? this.thinking.record(block.message, block.index, block.trace);
+      const tool = this.blocks.get(block.key.slice(5));
+      return {
+        kind: "tool",
+        id: block.key,
+        durationMs: tool?.startedAt === void 0 || tool.endedAt === void 0 ? void 0 : Math.max(0, tool.endedAt - tool.startedAt),
+        startedAt: tool?.startedAt,
+        endedAt: tool?.endedAt,
+        status: !tool?.endedAt ? "unknown" : tool.isError ? "error" : "ok",
+        lineCount: lineCount(tool?.result)
+      };
+    }));
+  }
+  releaseExchangeRecords() {
+    this.pendingThinking.clear();
+  }
+  /** Adds newly visible content in message order; repeated snapshots keep existing membership. */
+  ingest(message) {
+    if (typeof message?.timestamp !== "number" || !Number.isFinite(message.timestamp) || !Array.isArray(message.content)) return;
+    const seen = this.seenContent.get(message.timestamp) ?? /* @__PURE__ */ new Set();
+    this.seenContent.set(message.timestamp, seen);
+    for (let index = 0; index < message.content.length; index++) {
+      const item = message.content[index];
+      if (item.type === "thinking") {
+        const start = index;
+        const traces = [];
+        while (message.content[index]?.type === "thinking") {
+          if (message.content[index].thinking?.trim()) traces.push(message.content[index].thinking.trim());
+          index++;
+        }
+        index--;
+        if (!traces.length) continue;
+        const key = `thinking:${message.timestamp}:${start}`;
+        const existing = this.processByBlock.get(key)?.blocks.find((block) => block.key === key);
+        if (existing?.kind === "thinking") existing.trace = traces.join("\n\n");
+        else this.append({ kind: "thinking", key, message: { timestamp: message.timestamp }, index: start, trace: traces.join("\n\n") });
+        continue;
+      }
+      if (seen.has(index)) continue;
+      if (item.type === "text") {
+        if (!item.text?.trim()) continue;
+        this.exchangeItems.push({ key: `text:${message.timestamp}:${index}`, exchange: Math.max(1, this.currentExchange), startedAt: this.now(), kind: "text" });
+        this.openProcess = void 0;
+      }
+      if (item.type === "toolCall" && item.id) {
+        this.append({ kind: "tool", key: `tool:${item.id}` });
+        this.observe(item.id, item.name ?? "tool", item.arguments ?? {});
+      }
+      if (item.type === "toolCall" && !item.id) continue;
+      seen.add(index);
+    }
+  }
+  append(block) {
+    if (this.processByBlock.has(block.key)) return;
+    if (!this.openProcess) {
+      this.openProcess = { id: block.key, exchange: Math.max(1, this.currentExchange), blocks: [], open: false, settled: false };
+      this.processList.push(this.openProcess);
+      this.processById.set(this.openProcess.id, this.openProcess);
+    }
+    this.openProcess.blocks.push(block);
+    this.processByBlock.set(block.key, this.openProcess);
+    this.exchangeItems.push({ key: block.key, exchange: this.openProcess.exchange, startedAt: this.now(), kind: "block" });
+  }
+  processes() {
+    return this.processList;
+  }
+  hasTextImmediatelyBefore(key) {
+    const index = this.exchangeItems.findIndex((item2) => item2.key === key);
+    const item = this.exchangeItems[index];
+    const previous = index > 0 ? this.exchangeItems[index - 1] : void 0;
+    return previous?.exchange === item?.exchange && previous?.kind === "text";
+  }
+  progressParts(exchange) {
+    const items = this.exchangeItems.filter((item) => item.exchange === exchange);
+    const lastBlock = items.findLastIndex((item) => item.kind === "block");
+    const final = items[lastBlock + 1];
+    return lastBlock >= 0 && final?.kind === "text" ? { items: items.slice(0, lastBlock + 1), final } : void 0;
+  }
+  progressDurationForExchange(exchange) {
+    const parts = this.progressParts(exchange);
+    if (!parts) return void 0;
+    const first = parts.items.find((item) => item.kind === "block") ?? parts.items[0];
+    const block = first.kind === "block" ? this.processByBlock.get(first.key)?.blocks.find((item) => item.key === first.key) : void 0;
+    const saved = this.pendingThinking.get(first.key) ?? this.saved?.(first.key);
+    const start = saved?.startedAt ?? (block?.kind === "thinking" ? this.thinking.timing(block.message, block.index)?.start : block?.kind === "tool" ? this.blocks.get(block.key.slice(5))?.startedAt : void 0) ?? first.startedAt;
+    return Math.max(0, parts.final.startedAt - start);
+  }
+  progressForItem(key) {
+    const progress = this.progressByItem.get(key);
+    return progress && { exchange: progress.exchange, lead: progress.lead === key, open: progress.open };
+  }
+  /** Returns the settled progress branch for an item, grouping consecutive blocks by process. */
+  progressGuideForItem(key) {
+    const progress = this.progressByItem.get(key);
+    if (!progress?.open) return void 0;
+    const parts = this.progressParts(progress.exchange);
+    if (!parts) return void 0;
+    const children = [];
+    let previousProcess;
+    for (const item2 of parts.items) {
+      if (item2.kind === "text") {
+        children.push(item2.key);
+        previousProcess = void 0;
+        continue;
+      }
+      const process2 = this.processByBlock.get(item2.key);
+      const child2 = process2?.id ?? item2.key;
+      if (child2 !== previousProcess) children.push(child2);
+      previousProcess = child2;
+    }
+    const item = parts.items.find((candidate) => candidate.key === key);
+    const child = item?.kind === "text" ? item.key : item && this.processByBlock.get(item.key)?.id;
+    const index = child === void 0 ? -1 : children.indexOf(child);
+    if (index < 0) return void 0;
+    const last = index === children.length - 1;
+    return last ? { branch: "\u2514 ", continuation: "  " } : { branch: "\u251C ", continuation: "\u2502 " };
+  }
+  /** Returns the branch for a block title and the continuation for its opened output. */
+  processBlockGuide(key) {
+    const process2 = this.processByBlock.get(key);
+    const index = process2?.blocks.findIndex((block) => block.key === key) ?? -1;
+    if (!process2 || index < 0) return void 0;
+    const last = index === process2.blocks.length - 1;
+    return last ? { branch: "\u2514 ", continuation: "  " } : { branch: "\u251C ", continuation: "\u2502 " };
+  }
+  /** Returns the guide columns that continue into an item from its previous transcript item. */
+  guideBeforeItem(key) {
+    const index = this.exchangeItems.findIndex((item) => item.key === key);
+    if (index <= 0) return void 0;
+    const current = this.exchangeItems[index];
+    const previous = this.exchangeItems[index - 1];
+    if (previous.exchange !== current.exchange) return void 0;
+    const progress = this.progressByItem.get(key);
+    const outer = progress?.open ? this.progressGuideForItem(previous.key)?.continuation ?? "" : "";
+    const previousProcess = previous.kind === "block" ? this.processByBlock.get(previous.key) : void 0;
+    const currentProcess = current.kind === "block" ? this.processByBlock.get(current.key) : void 0;
+    if (previousProcess && currentProcess?.id === previousProcess.id) {
+      if (!previousProcess.open) return void 0;
+      return outer + (this.processBlockGuide(previous.key)?.continuation ?? "");
+    }
+    return outer || void 0;
+  }
+  progressLine(exchange) {
+    const progress = this.progress.get(exchange);
+    if (!progress) return "";
+    const notes = progress.notes ? ` \xB7 ${progress.notes} ${progress.notes === 1 ? "note" : "notes"}` : "";
+    return `${progress.open ? "\u25BE" : "\u25B8"} Worked for ${elapsed(progress.durationMs)} \xB7 \u25C8 ${progress.thinking} \u2699 ${progress.tools}${notes}`;
+  }
+  toggleProgress(exchange) {
+    const progress = this.progress.get(exchange);
+    if (!progress) return void 0;
+    progress.open = !progress.open;
+    return progress.open;
+  }
+  /** Toggles a fold row and sets its direct children to the same open state. */
+  toggleOneLevel(control) {
+    if (control.kind === "progress") {
+      const open = this.toggleProgress(control.exchange);
+      if (open === void 0) return void 0;
+      for (const process2 of this.processList) {
+        if (process2.exchange === control.exchange && process2.open !== open) this.toggleProcess(process2.id);
+      }
+      return open;
+    }
+    if (control.kind === "process") {
+      const open = this.toggleProcess(control.id);
+      if (open === void 0) return void 0;
+      for (const block of this.processById.get(control.id).blocks) {
+        if (block.kind === "thinking") {
+          if (this.isThinkingOpen(block.message, block.index) !== open) this.toggleThinking(block.message, block.index);
+        } else {
+          const id = block.key.slice(5);
+          if (this.isOpen(id) !== open) this.toggle(id);
+        }
+      }
+      return open;
+    }
+    if (control.kind === "thinking") return this.toggleThinking(control.message, control.index);
+    return this.toggle(control.id);
+  }
+  cursorRows() {
+    const rows = [];
+    for (const process2 of this.processList) {
+      const progress = this.progress.get(process2.exchange);
+      if (progress && !rows.some((row) => row.key === `exchange:${process2.exchange}`)) rows.push({ key: `exchange:${process2.exchange}`, title: this.progressLine(process2.exchange), toggle: () => {
+        this.toggleProgress(process2.exchange);
+      } });
+      if (progress && !progress.open) continue;
+      const last = process2.blocks.at(-1);
+      const detail = last?.kind === "thinking" ? this.thinkingTitle(last.message, last.index, last.trace, false) : last?.kind === "tool" ? this.titleParts(last.key.slice(5)) : void 0;
+      const label = typeof detail === "string" ? detail : detail ? `\u2699 ${detail.name} ${detail.argument}`.trim() : "";
+      rows.push({ key: `process:${process2.id}`, title: `${this.processLine(process2.id)}${label ? ` \xB7 ${label}` : ""}`, toggle: () => {
+        this.toggleProcess(process2.id);
+      } });
+      if (!process2.open) continue;
+      for (const block of process2.blocks) {
+        if (block.kind === "thinking") rows.push({ key: block.key, title: this.thinkingTitle(block.message, block.index, block.trace, false), toggle: () => {
+          this.toggleThinking(block.message, block.index);
+        } });
+        else {
+          const id = block.key.slice(5);
+          const parts = this.titleParts(id);
+          rows.push({ key: block.key, title: `\u2699 ${parts?.name ?? "tool"} ${parts?.argument ?? ""}`.trim(), toggle: () => {
+            this.toggle(id);
+          } });
+        }
+      }
+    }
+    return rows;
+  }
+  /** Selects settled progress lines, process lines, and block titles in transcript order. */
+  startCursor() {
+    const first = this.cursorRows()[0];
+    if (!first) return false;
+    this.cursorActive = true;
+    this.cursorKey = first.key;
+    return true;
+  }
+  stopCursor() {
+    this.cursorActive = false;
+    this.cursorKey = void 0;
+  }
+  cursorMove(delta) {
+    const rows = this.cursorRows();
+    if (!rows.length) {
+      this.cursorKey = void 0;
+      return;
+    }
+    const index = rows.findIndex((row) => row.key === this.cursorKey);
+    this.cursorKey = rows[Math.max(0, Math.min(rows.length - 1, Math.max(0, index) + delta))].key;
+  }
+  cursorToggle() {
+    const row = this.cursorRows().find((item) => item.key === this.cursorKey);
+    row?.toggle();
+  }
+  cursorTitle() {
+    return this.cursorActive ? this.cursorRows().find((item) => item.key === this.cursorKey)?.title : void 0;
+  }
+  isCursorHighlighted(key) {
+    return this.cursorActive && this.cursorKey === key;
+  }
+  beginExchange(index = this.currentExchange + 1) {
+    this.currentExchange = index;
+    this.openProcess = void 0;
+  }
+  /** Closes the open process and folds answered progress after the final text is known. */
+  endExchange(durationMs, answered = true) {
+    if (answered) {
+      const parts = this.progressParts(this.currentExchange);
+      if (parts) {
+        const progress = {
+          exchange: this.currentExchange,
+          lead: parts.items[0].key,
+          open: false,
+          durationMs: durationMs ?? this.progressDurationForExchange(this.currentExchange) ?? 0,
+          thinking: parts.items.filter((item) => item.key.startsWith("thinking:")).length,
+          tools: parts.items.filter((item) => item.key.startsWith("tool:")).length,
+          notes: parts.items.filter((item) => item.kind === "text").length
+        };
+        this.progress.set(this.currentExchange, progress);
+        for (const item of parts.items) this.progressByItem.set(item.key, progress);
+      }
+    }
+    this.openProcess = void 0;
+    for (let index = this.processList.length - 1; index >= 0 && !this.processList[index].settled; index--) this.processList[index].settled = true;
+  }
+  toggleLatestProcess() {
+    const process2 = this.processList.at(-1);
+    return process2 && this.toggleProcess(process2.id);
+  }
+  toggleExchange(exchange) {
+    if (this.progress.has(exchange)) return this.toggleProgress(exchange);
+    const processes = this.processList.filter((process2) => process2.exchange === exchange);
+    if (!processes.length) return void 0;
+    const open = processes.some((process2) => !process2.open);
+    for (const process2 of processes) process2.open = open;
+    return open;
+  }
+  isExchangeOpen(exchange) {
+    const progress = this.progress.get(exchange);
+    if (progress) return progress.open;
+    const processes = this.processList.filter((process2) => process2.exchange === exchange);
+    return processes.length ? processes.every((process2) => process2.open) : void 0;
+  }
+  toggleLatestExchange() {
+    const process2 = this.processList.at(-1);
+    return process2 && this.toggleExchange(process2.exchange);
+  }
+  processForThinking(message, index) {
+    return this.processByBlock.get(`thinking:${message.timestamp}:${index}`);
+  }
+  processForTool(id) {
+    return this.processByBlock.get(`tool:${id}`);
+  }
+  /** Whether this model has ingested or run the tool call, so its session owns the component. */
+  ownsTool(id) {
+    return this.processByBlock.has(`tool:${id}`) || this.blocks.has(id);
+  }
+  /** Whether this model has ingested the assistant message, so its session owns the component. */
+  ownsMessage(message) {
+    return typeof message?.timestamp === "number" && this.seenContent.has(message.timestamp);
+  }
+  /**
+   * Whether a thinking run or tool call in the message matches what this model ingested
+   * for that timestamp. Used to tell apart sessions whose messages share a timestamp.
+   */
+  ingestedContentOf(message) {
+    const content = message?.content ?? [];
+    for (let index = 0; index < content.length; index++) {
+      const item = content[index];
+      if (item.type === "toolCall" && item.id && this.processByBlock.has(`tool:${item.id}`)) return true;
+      if (item.type !== "thinking" || content[index - 1]?.type === "thinking") continue;
+      const traces = [];
+      for (let run = index; content[run]?.type === "thinking"; run++) if (content[run].thinking?.trim()) traces.push(content[run].thinking.trim());
+      const key = `thinking:${message.timestamp}:${index}`;
+      const block = this.processByBlock.get(key)?.blocks.find((candidate) => candidate.key === key);
+      if (block?.kind === "thinking" && block.trace === traces.join("\n\n")) return true;
+    }
+    return false;
+  }
+  isProcessLead(id, key) {
+    return this.processById.get(id)?.blocks[0]?.key === key;
+  }
+  toggleProcess(id) {
+    const process2 = this.processById.get(id);
+    if (!process2) return void 0;
+    process2.open = !process2.open;
+    return process2.open;
+  }
+  isProcessOpen(id) {
+    return this.processById.get(id)?.open ?? false;
+  }
+  toggleThinking(message, index) {
+    const key = `thinking:${message.timestamp}:${index}`;
+    if (this.openThinking.has(key)) {
+      this.openThinking.delete(key);
+      return false;
+    }
+    this.openThinking.add(key);
+    return true;
+  }
+  isThinkingOpen(message, index) {
+    return this.openThinking.has(`thinking:${message.timestamp}:${index}`);
+  }
+  processLine(id) {
+    const process2 = this.processById.get(id);
+    if (!process2) return "";
+    let first;
+    let last;
+    let activity = "";
+    let queued = "";
+    for (const block of process2.blocks) {
+      const tool = block.kind === "tool" ? this.blocks.get(block.key.slice(5)) : void 0;
+      const saved = this.pendingThinking.get(block.key) ?? this.saved?.(block.key);
+      const timing = saved?.startedAt !== void 0 ? { start: saved.startedAt, end: saved.endedAt } : block.kind === "thinking" ? this.thinking.timing(block.message, block.index) : tool?.startedAt === void 0 ? void 0 : { start: tool.startedAt, end: tool.endedAt };
+      if (!timing && !process2.settled && block.kind === "tool" && tool?.endedAt === void 0 && !saved) queued ||= `\u2699 ${tool?.name ?? "tool"} queued`;
+      if (!timing) continue;
+      first = first === void 0 ? timing.start : Math.min(first, timing.start);
+      last = Math.max(last ?? timing.start, timing.end ?? (process2.settled ? timing.start : this.now()));
+      if (timing.end === void 0 && !process2.settled) activity = block.kind === "tool" ? `\u2699 ${tool?.name ?? "tool"} running ${elapsed(this.now() - timing.start)}` : this.thinking.title(block.message, block.index, block.trace, true);
+    }
+    const count = `\u25C8 ${process2.blocks.filter((block) => block.kind === "thinking").length} \u2699 ${process2.blocks.filter((block) => block.kind === "tool").length}`;
+    const total = first === void 0 || last === void 0 ? "0ms" : elapsed(Math.max(0, last - first));
+    return `${process2.open ? "\u25BE" : "\u25B8"} ${count} \xB7 ${activity || queued || total}`;
+  }
+  observe(id, name, args, result) {
+    const block = this.blocks.get(id);
+    if (block) {
+      block.args = args;
+      if (result) block.result = result;
+    } else {
+      this.blocks.set(id, { name, args, result, isError: false, open: false });
+    }
+  }
+  start(id, name, at = this.now()) {
+    const block = this.blocks.get(id) ?? { name, isError: false, open: false };
+    block.name = name;
+    block.startedAt = at;
+    this.blocks.set(id, block);
+  }
+  end(id, isError, result, at = this.now()) {
+    const block = this.blocks.get(id) ?? { name: "tool", isError: false, open: false };
+    block.endedAt = at;
+    block.isError = isError;
+    if (result) block.result = result;
+    this.blocks.set(id, block);
+  }
+  observeThinking(message, event, reasoningTokens) {
+    this.thinking.observe(message, event, reasoningTokens);
+  }
+  settleThinking(message) {
+    this.thinking.settle(message);
+    for (let index = 0; index < (message.content?.length ?? 0); index++) {
+      if (message.content?.[index].type !== "thinking" || message.content?.[index - 1]?.type === "thinking") continue;
+      const key = `thinking:${message.timestamp}:${index}`;
+      const block = this.processByBlock.get(key)?.blocks.find((item) => item.key === key);
+      if (block?.kind === "thinking") this.pendingThinking.set(key, this.thinking.record(message, index, block.trace));
+    }
+  }
+  thinkingTitle(message, index, trace, streaming) {
+    const key = `thinking:${message.timestamp}:${index}`;
+    return this.thinking.title(message, index, trace, streaming, this.pendingThinking.get(key) ?? this.saved?.(key));
+  }
+  /**
+   * Applies a model headline, or `undefined` to fall back to the trace sentence.
+   * Returns the correction to persist when the block's exchange record was already
+   * saved with a different headline; otherwise the change is live or still pending.
+   */
+  setThinkingHeadline(message, index, headline2) {
+    const key = `thinking:${message.timestamp}:${index}`;
+    this.thinking.setHeadline(message, index, headline2);
+    const block = this.processByBlock.get(key)?.blocks.find((item) => item.key === key);
+    const next = headline2 ? { headline: headline2, headlineSource: "model" } : block?.kind === "thinking" ? { headline: traceHeadline(block.trace, false), headlineSource: "trace" } : void 0;
+    const pending = this.pendingThinking.get(key);
+    if (pending?.kind === "thinking") {
+      if (next) Object.assign(pending, next);
+      return void 0;
+    }
+    const saved = this.saved?.(key);
+    if (!next || saved?.kind !== "thinking" || saved.headline === next.headline && saved.headlineSource === next.headlineSource) return void 0;
+    return { id: key, ...next };
+  }
+  toggle(id) {
+    const block = this.blocks.get(id);
+    if (!block) return void 0;
+    block.open = !block.open;
+    return block.open;
+  }
+  isOpen(id) {
+    return this.blocks.get(id)?.open ?? false;
+  }
+  titleParts(id) {
+    const block = this.blocks.get(id);
+    if (!block) return void 0;
+    const saved = this.saved?.(`tool:${id}`);
+    const argument = summary(block.args);
+    const settled = this.processByBlock.get(`tool:${id}`)?.settled ?? false;
+    const noResult = saved?.kind === "tool" ? saved.status === "unknown" : block.endedAt === void 0 && settled;
+    if (noResult) return { name: block.name, argument, stats: "no result" };
+    const elapsed2 = saved?.durationMs ?? (block.startedAt === void 0 ? void 0 : Math.max(0, (block.endedAt ?? this.now()) - block.startedAt));
+    const status = saved?.kind === "tool" ? saved.status === "error" ? "\u2717" : "\u2713" : block.endedAt === void 0 ? "running" : block.isError ? "\u2717" : "\u2713";
+    const count = saved?.kind === "tool" ? saved.lineCount : lineCount(block.result);
+    const lines = saved?.kind === "tool" || block.endedAt !== void 0 ? ` \xB7 ${count} ${count === 1 ? "line" : "lines"}` : "";
+    return { name: block.name, argument, stats: `${status} ${duration(elapsed2)}${lines}` };
+  }
+};
+
+// extensions/focus-mode/src/tool-render.ts
+import { MouseRegion, Text, truncateToWidth as truncateToWidth3, visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
+import { homedir } from "node:os";
+var hoveredControl;
+function setHover(model, key) {
+  const next = model && key !== void 0 ? { model, key } : void 0;
+  if (hoveredControl?.model === next?.model && hoveredControl?.key === next?.key) return false;
+  hoveredControl = next;
+  return true;
+}
+function isHovered(model, key) {
+  return hoveredControl?.model === model && hoveredControl.key === key;
+}
+var repaint = { handled: true, render: true };
+function endHoverOnMove(event) {
+  return event.type === "move" && setHover(void 0, void 0) ? repaint : void 0;
+}
+function styleControl(theme, model, key, text) {
+  if (!theme) return text;
+  const color = model.isCursorHighlighted(key) ? "accent" : isHovered(model, key) ? "muted" : "dim";
+  const colored = theme.fg(color, text);
+  return theme.italic?.(colored) ?? colored;
+}
+function hoverRows(theme, model, key, lines, leading) {
+  if (!theme) return lines;
+  const cursor = model.isCursorHighlighted(key);
+  const hovered = isHovered(model, key);
+  const color = cursor ? "accent" : hovered ? "muted" : "dim";
+  const colorOpen = theme.fg(color, "\0").split("\0")[0];
+  const italicOpen = theme.italic?.("\0").split("\0")[0] ?? "";
+  const restoredStyle = colorOpen + italicOpen;
+  const selected = hovered && !cursor && theme.bg;
+  if (!selected) return restoredStyle ? lines.map((line) => line.replaceAll("\x1B[0m", `\x1B[0m${restoredStyle}`)) : lines;
+  const [open, close] = theme.bg("selectedBg", "\0").split("\0");
+  const bare = " ".repeat(leading);
+  return lines.map((line) => {
+    const cut = line.startsWith(bare) ? leading : 0;
+    const body = line.slice(cut).replaceAll("\x1B[0m", `\x1B[0m${open}${restoredStyle}`).replaceAll("\x1B[49m", `\x1B[49m${open}`);
+    return line.slice(0, cut) + open + body + close;
+  });
+}
+var toolOwners = /* @__PURE__ */ new WeakMap();
+var thinkingOwners = /* @__PURE__ */ new WeakMap();
+var BLOCK_INDENT = 2;
+function withGuide(theme, prefix, lines) {
+  if (!prefix) return lines;
+  const aligned = prefix.replace(/([│├└]) /g, " $1");
+  const guide = theme?.fg("dim", aligned) ?? aligned;
+  return lines.map((line) => guide + line);
+}
+function withoutBlankEdges(lines) {
+  const blank = (line) => line.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07]*(?:\x07|\x1b\\\\)/g, "").trim() === "";
+  let start = 0;
+  let end = lines.length;
+  while (start < end && blank(lines[start])) start++;
+  while (end > start && blank(lines[end - 1])) end--;
+  return { lines: lines.slice(start, end), leading: start };
+}
+function truncateProcessLine(text, width) {
+  return fitThinkingLine(text, width);
+}
+function progressRow(model, exchange, theme, padding, width) {
+  const key = `exchange:${exchange}`;
+  const text = truncateProcessLine(model.progressLine(exchange), width - padding * 2);
+  return hoverRows(theme, model, key, new Text(styleControl(theme, model, key, text), padding, 0).render(width), padding);
+}
+function pathTail(path, width) {
+  if (visibleWidth3(path) <= width) return path;
+  const slash = path.lastIndexOf("/");
+  if (slash < 0) return "\u2026" + Array.from(path).reverse().reduce((tail2, character) => visibleWidth3("\u2026" + character + tail2) <= width ? character + tail2 : tail2, "");
+  const prefix = path.startsWith("~/") ? "~/\u2026/" : "\u2026/";
+  const tail = path.slice(slash + 1);
+  let result = prefix + tail;
+  if (visibleWidth3(result) > width) {
+    result = "\u2026";
+    for (const character of Array.from(tail).reverse()) {
+      if (visibleWidth3(result) + visibleWidth3(character) > width) break;
+      result = "\u2026" + character + result.slice(1);
+    }
+    return result;
+  }
+  for (const segment of path.slice(path.startsWith("~/") ? 2 : 0, slash).split("/").reverse()) {
+    if (!segment || visibleWidth3(prefix + segment + "/" + result.slice(prefix.length)) > width) break;
+    result = prefix + segment + "/" + result.slice(prefix.length);
+  }
+  return result;
+}
+function installToolFold(componentClass, model, getTheme = () => void 0, getOutputPad = () => 1, getHomeDirectory = homedir) {
+  const prototype = componentClass?.prototype;
+  const shared = prototype && toolOwners.get(prototype);
+  if (shared) return shared.add({ model, getTheme, getOutputPad, getHomeDirectory });
+  const original = prototype?.render;
+  const originalMouse = prototype?.handleMouse;
+  const hadOwnMouse = prototype && Object.hasOwn(prototype, "handleMouse");
+  if (typeof original !== "function") return { installed: false, restore() {
+  } };
+  const ownerFor = (component) => {
+    const all = Array.from(owners);
+    return all.findLast((owner) => owner.model.ownsTool(component.toolCallId)) ?? all.at(-1);
+  };
+  const nativeOffset = /* @__PURE__ */ new WeakMap();
+  function folded(width) {
+    nativeOffset.delete(this);
+    if (owners.size === 0) return original.call(this, width);
+    try {
+      const { model: model2, getTheme: getTheme2, getOutputPad: getOutputPad2, getHomeDirectory: getHomeDirectory2 } = ownerFor(this);
+      model2.observe(this.toolCallId, this.toolName, this.args, this.result);
+      const key = `tool:${this.toolCallId}`;
+      const process2 = model2.processForTool(this.toolCallId);
+      const processLead = process2 && model2.isProcessLead(process2.id, key);
+      const progress = model2.progressForItem(key);
+      const progressGuide = model2.progressGuideForItem(key);
+      const processGuide = model2.processBlockGuide(key);
+      const gapBefore = model2.hasTextImmediatelyBefore(`tool:${this.toolCallId}`) && (processLead || progress?.lead);
+      const compactProgress = progress?.open === true;
+      const padding = Math.min(getOutputPad2(), Math.max(0, Math.floor((width - 1) / 2)));
+      const progressLine = progress?.lead ? progressRow(model2, progress.exchange, getTheme2(), padding, width) : [];
+      const withGap = (rows2) => gapBefore && !compactProgress && rows2.length ? [...withGuide(getTheme2(), progressGuide ? "\u2502 " : "", [""]), ...rows2] : rows2;
+      if (progress && !progress.open) return withGap(progressLine);
+      if (process2 && !model2.isProcessOpen(process2.id) && !model2.isProcessLead(process2.id, `tool:${this.toolCallId}`)) return [];
+      const contentWidth = width - padding * 2 - (progress ? BLOCK_INDENT : 0);
+      const processText = process2 && model2.isProcessLead(process2.id, `tool:${this.toolCallId}`) ? truncateProcessLine(model2.processLine(process2.id), contentWidth) : void 0;
+      const processKey = `process:${process2?.id}`;
+      const processLine = processText === void 0 ? [] : hoverRows(getTheme2(), model2, processKey, new Text(styleControl(getTheme2(), model2, processKey, processText), padding, 0).render(width - (progress ? BLOCK_INDENT : 0)), padding);
+      const processRows = progressGuide && processLead ? withGuide(getTheme2(), progressGuide.branch, processLine) : processLine;
+      if (process2 && !model2.isProcessOpen(process2.id)) return withGap([...progressLine, ...progressLine.length && processRows.length && !compactProgress ? withGuide(getTheme2(), progressGuide?.continuation ?? "", [""]) : [], ...processRows]);
+      const parts = model2.titleParts(this.toolCallId);
+      if (!parts || width <= 0) return original.call(this, width);
+      const indent = process2 ? BLOCK_INDENT : 0;
+      const titleWidth = contentWidth - indent;
+      const name = truncateToWidth3(`\u2699 ${parts.name}`, titleWidth, "");
+      const remaining = titleWidth - visibleWidth3(name);
+      const stats = truncateToWidth3(`  ${parts.stats}`, remaining, "");
+      const argumentWidth = Math.max(0, remaining - visibleWidth3(`  ${parts.stats}`));
+      const home = getHomeDirectory2();
+      const path = typeof this.args?.path === "string" && (parts.argument === this.args.path || parts.argument === this.args.path.replace(/\s+/g, " ").trim()) ? parts.argument.startsWith(`${home}/`) ? `~${parts.argument.slice(home.length)}` : parts.argument : void 0;
+      const argument = argumentWidth > 2 && parts.argument ? (path === void 0 ? truncateToWidth3(`  ${parts.argument}`, argumentWidth, "\u2026") : `  ${pathTail(path, argumentWidth - 2)}`).replace(/\x1b\[0m/g, "") : "";
+      const text = name + argument + stats;
+      const styled = styleControl(getTheme2(), model2, `tool:${this.toolCallId}`, text);
+      const titleRows = hoverRows(getTheme2(), model2, `tool:${this.toolCallId}`, new Text(styled, padding, 0).render(width - indent - (progress ? BLOCK_INDENT : 0)), padding);
+      const titlePrefix = (progressGuide?.continuation ?? "") + (process2 ? processGuide?.branch ?? "  " : "");
+      const title = withGuide(getTheme2(), titlePrefix, titleRows);
+      const rows = [...processRows, ...title];
+      if (!model2.isOpen(this.toolCallId)) return withGap([...progressLine, ...progressLine.length && rows.length && !compactProgress ? withGuide(getTheme2(), progressGuide?.continuation ?? "", [""]) : [], ...rows]);
+      const native = original.call(this, width - indent * 2 - (progress ? BLOCK_INDENT : 0));
+      const trimmed = withoutBlankEdges(native);
+      nativeOffset.set(this, { rows: processLine.length + title.length - trimmed.leading, columns: indent * 2 });
+      const bodyPrefix = (progressGuide?.continuation ?? "") + (process2 ? processGuide?.continuation ?? "  " : "") + (indent ? " ".repeat(BLOCK_INDENT) : "");
+      const body = withGuide(getTheme2(), bodyPrefix, trimmed.lines);
+      return withGap([...progressLine, ...progressLine.length && rows.length && !compactProgress ? withGuide(getTheme2(), progressGuide?.continuation ?? "", [""]) : [], ...rows, ...body]);
+    } catch {
+      return original.call(this, width);
+    }
+  }
+  prototype.render = folded;
+  function foldedMouse(event) {
+    if (owners.size === 0) return originalMouse?.call(this, event);
+    const { model: model2 } = ownerFor(this);
+    const key = `tool:${this.toolCallId}`;
+    const progress = model2.progressForItem(key);
+    const process2 = model2.processForTool(this.toolCallId);
+    const processLead = process2 && model2.isProcessLead(process2.id, key);
+    const gapBefore = model2.hasTextImmediatelyBefore(key) && (processLead || progress?.lead);
+    const gapRows = gapBefore && progress?.open !== true ? 1 : 0;
+    if (progress?.lead && event.y === gapRows) {
+      if (event.type === "move") return setHover(model2, `exchange:${progress.exchange}`) ? repaint : void 0;
+      if (event.type === "click" && event.button === "left") {
+        const control = { kind: "progress", exchange: progress.exchange };
+        if (event.alt) model2.toggleOneLevel(control);
+        else model2.toggleProgress(progress.exchange);
+        this.ui?.requestRender();
+        return { handled: true, render: false };
+      }
+    }
+    if (progress && !progress.open) return event.type === "move" && setHover(void 0, void 0) ? repaint : void 0;
+    const rowOffset = gapRows + (progress?.lead ? 1 : 0);
+    if (progress || rowOffset) event = {
+      ...event,
+      y: event.y - rowOffset,
+      x: event.x === void 0 ? void 0 : event.x - (progress ? BLOCK_INDENT : 0),
+      width: event.width - (progress ? BLOCK_INDENT : 0),
+      height: event.height - rowOffset
+    };
+    const lead = process2 && model2.isProcessLead(process2.id, `tool:${this.toolCallId}`);
+    if (event.type === "move") {
+      const titleRow = lead ? 1 : 0;
+      const key2 = lead && event.y === 0 ? `process:${process2.id}` : event.y === titleRow && (!process2 || model2.isProcessOpen(process2.id)) && model2.titleParts(this.toolCallId) ? `tool:${this.toolCallId}` : void 0;
+      const changed = setHover(model2, key2);
+      const offset2 = key2 ? void 0 : nativeOffset.get(this);
+      const native = offset2 && event.y >= offset2.rows ? originalMouse?.call(this, { ...event, y: event.y - offset2.rows, x: event.x === void 0 ? void 0 : event.x - offset2.columns, width: event.width - offset2.columns, height: event.height - offset2.rows }) : void 0;
+      return native ?? (changed ? repaint : void 0);
+    }
+    if (event.type === "click" && event.button === "left" && event.y === 0 && process2 && model2.isProcessLead(process2.id, `tool:${this.toolCallId}`)) {
+      const control = { kind: "process", id: process2.id };
+      if (event.alt) model2.toggleOneLevel(control);
+      else model2.toggleProcess(process2.id);
+      this.ui?.requestRender();
+      return { handled: true, render: false };
+    }
+    const titleY = process2 && model2.isProcessLead(process2.id, `tool:${this.toolCallId}`) ? 1 : 0;
+    if (event.type === "click" && event.button === "left" && event.y === titleY && (!process2 || model2.isProcessOpen(process2.id))) {
+      const control = { kind: "tool", id: this.toolCallId };
+      const toggled = event.alt ? model2.toggleOneLevel(control) : model2.toggle(this.toolCallId);
+      if (toggled !== void 0) {
+        this.ui?.requestRender();
+        return { handled: true, render: false };
+      }
+    }
+    const offset = nativeOffset.get(this);
+    if (!offset) return originalMouse?.call(this, event);
+    if (event.y < offset.rows) return void 0;
+    return originalMouse?.call(this, {
+      ...event,
+      y: event.y - offset.rows,
+      x: event.x === void 0 ? void 0 : event.x - offset.columns,
+      width: event.width - offset.columns,
+      height: event.height - offset.rows
+    });
+  }
+  prototype.handleMouse = foldedMouse;
+  const owners = /* @__PURE__ */ new Set();
+  const add = (owner) => {
+    if (owners.size === 0) {
+      if (prototype.render === original) prototype.render = folded;
+      if (prototype.handleMouse === originalMouse) prototype.handleMouse = foldedMouse;
+    }
+    owners.add(owner);
+    return { installed: true, restore() {
+      if (!owners.delete(owner)) return;
+      if (hoveredControl?.model === owner.model) setHover(void 0, void 0);
+      if (owners.size > 0) return;
+      if (prototype.render === folded && prototype.handleMouse === foldedMouse) toolOwners.delete(prototype);
+      if (prototype.render === folded) prototype.render = original;
+      if (prototype.handleMouse === foldedMouse) {
+        if (hadOwnMouse) prototype.handleMouse = originalMouse;
+        else delete prototype.handleMouse;
+      }
+    } };
+  };
+  toolOwners.set(prototype, { add });
+  return add({ model, getTheme, getOutputPad, getHomeDirectory });
+}
+function installThinkingFold(componentClass, model, getTheme = () => void 0, requestRender = () => {
+}, observeOutputPad = () => {
+}) {
+  const prototype = componentClass?.prototype;
+  const shared = prototype && thinkingOwners.get(prototype);
+  if (shared) return shared.add({ model, getTheme, requestRender, observeOutputPad });
+  const original = prototype?.updateContent;
+  if (typeof original !== "function") return { installed: false, restore() {
+  } };
+  const originalMouse = prototype.handleMouse;
+  const hadOwnMouse = Object.hasOwn(prototype, "handleMouse");
+  let claimedMove = false;
+  const textControls = /* @__PURE__ */ new WeakMap();
+  const ownerFor = (message) => {
+    const all = Array.from(owners);
+    const claimants = all.filter((owner) => owner.model.ownsMessage(message));
+    if (claimants.length > 1) return claimants.findLast((owner) => owner.model.ingestedContentOf(message)) ?? claimants.at(-1);
+    return claimants[0] ?? all.at(-1);
+  };
+  function foldContent(message, isStreaming) {
+    const { model: model2, getTheme: getTheme2, requestRender: requestRender2, observeOutputPad: observeOutputPad2 } = ownerFor(message);
+    observeOutputPad2(this.outputPad);
+    if (!Array.isArray(message?.content) || !this.contentContainer?.children) {
+      original.call(this, message, isStreaming);
+      return;
+    }
+    const hidden = this.hideThinkingBlock;
+    const overrides = this.thinkingVisibilityOverrides;
+    try {
+      this.hideThinkingBlock = false;
+      this.thinkingVisibilityOverrides = /* @__PURE__ */ new Map();
+      original.call(this, message, isStreaming);
+    } finally {
+      this.hideThinkingBlock = hidden;
+      this.thinkingVisibilityOverrides = overrides;
+    }
+    const runs = [];
+    for (let index = 0; index < message.content.length; ) {
+      if (message.content[index].type !== "thinking") {
+        index++;
+        continue;
+      }
+      const start = index;
+      const parts = [];
+      while (message.content[index]?.type === "thinking") {
+        const trace = message.content[index].thinking?.trim();
+        if (trace) parts.push(trace);
+        index++;
+      }
+      if (parts.length) runs.push({ index: start, trace: parts.join("\n\n") });
+    }
+    const children = this.contentContainer.children;
+    textControls.set(this, []);
+    const childKeys = /* @__PURE__ */ new Map();
+    const processByKey = /* @__PURE__ */ new Map();
+    const regions = children.map((child, index) => child.constructor.name === "MouseRegion" ? index : -1).filter((index) => index >= 0);
+    const texts = message.content.flatMap((part, index) => part.type === "text" && part.text?.trim() ? [index] : []);
+    const markdown = children.map((child, index) => child.constructor.name === "Markdown" ? index : -1).filter((index) => index >= 0);
+    if (regions.length !== runs.length || markdown.length !== texts.length) {
+      original.call(this, message, isStreaming);
+      return;
+    }
+    texts.forEach((index, textIndex) => {
+      const native = children[markdown[textIndex]];
+      const key = `text:${message.timestamp}:${index}`;
+      const originalRender = native.render.bind(native);
+      const component = this;
+      native.render = (width) => {
+        const progress = model2.progressForItem(key);
+        if (!progress) return originalRender(width);
+        const line = progress.lead ? progressRow(model2, progress.exchange, getTheme2(), component.outputPad, width) : [];
+        const guide = model2.progressGuideForItem(key);
+        const continuation = guide?.continuation ?? "  ";
+        const rows = progress.open ? withGuide(getTheme2(), continuation, originalRender(width - BLOCK_INDENT)) : [];
+        return progress.open ? [...line, ...rows] : line;
+      };
+      childKeys.set(native, key);
+      const controls = textControls.get(this) ?? [];
+      controls.push({ child: native, key });
+      textControls.set(this, controls);
+    });
+    const progressKeys = [
+      ...texts.map((index) => `text:${message.timestamp}:${index}`),
+      ...runs.map((run) => `thinking:${message.timestamp}:${run.index}`)
+    ];
+    const firstContentKey = [
+      ...texts.map((index) => ({ index, key: `text:${message.timestamp}:${index}` })),
+      ...runs.map((run) => ({ index: run.index, key: `thinking:${message.timestamp}:${run.index}` }))
+    ].sort((left, right) => left.index - right.index)[0]?.key;
+    const messageProgress = () => progressKeys.map((key) => model2.progressForItem(key)).find(Boolean);
+    const hasProgressLead = () => progressKeys.some((key) => model2.progressForItem(key)?.lead);
+    const hasFinalText = () => texts.some((index) => !model2.progressForItem(`text:${message.timestamp}:${index}`));
+    const compactItem = (key) => {
+      if (model2.progressForItem(key)?.open) return true;
+      const process2 = processByKey.get(key);
+      return process2 !== void 0 && model2.isProcessOpen(process2.id);
+    };
+    const compactLead = (key) => {
+      const progress = model2.progressForItem(key);
+      if (progress) return progress.lead;
+      const process2 = processByKey.get(key);
+      return process2 !== void 0 && model2.isProcessLead(process2.id, key);
+    };
+    const sameCompactGroup = (left, right) => {
+      const leftProgress = model2.progressForItem(left);
+      const rightProgress = model2.progressForItem(right);
+      if (leftProgress?.open && rightProgress?.open && leftProgress.exchange === rightProgress.exchange) return true;
+      const leftProcess = processByKey.get(left);
+      const rightProcess = processByKey.get(right);
+      return leftProcess !== void 0 && leftProcess.id === rightProcess?.id && model2.isProcessOpen(leftProcess.id);
+    };
+    const initialSpacer = children[0];
+    if (initialSpacer?.constructor.name === "Spacer") {
+      children[0] = {
+        constructor: initialSpacer.constructor,
+        render(width) {
+          if (firstContentKey && compactItem(firstContentKey) && !compactLead(firstContentKey)) return [];
+          const progress = messageProgress();
+          if (progress && !progress.open && !hasProgressLead() && !hasFinalText()) return [];
+          const prefix = (!progress || progress.open) && firstContentKey ? model2.guideBeforeItem(firstContentKey) : void 0;
+          if (prefix) {
+            const lines = initialSpacer.render(width - visibleWidth3(prefix));
+            return withGuide(getTheme2(), prefix, lines);
+          }
+          return initialSpacer.render(width);
+        }
+      };
+    }
+    runs.forEach((run, runIndex) => {
+      const native = children[regions[runIndex]];
+      const process2 = model2.processForThinking(message, run.index);
+      const key = `thinking:${message.timestamp}:${run.index}`;
+      if (process2) processByKey.set(key, process2);
+      const lead = process2 && model2.isProcessLead(process2.id, key);
+      const gapBefore = model2.hasTextImmediatelyBefore(key) && (lead || model2.progressForItem(key)?.lead);
+      const preceding = children[regions[runIndex] - 1];
+      if (process2 && !lead && preceding?.constructor.name === "Spacer") {
+        children[regions[runIndex] - 1] = {
+          constructor: preceding.constructor,
+          render() {
+            return [];
+          }
+        };
+      }
+      const separatorIndex = regions[runIndex] + 1;
+      const separator = children[separatorIndex];
+      if (separator?.constructor.name === "Spacer") {
+        const following = children[separatorIndex + 1];
+        const finalText = textControls.get(this)?.find((control) => control.child === following);
+        children[separatorIndex] = {
+          constructor: separator.constructor,
+          render(width) {
+            const progress = model2.progressForItem(key);
+            if (progress && !progress.open && (!finalText || model2.progressForItem(finalText.key))) return [];
+            return separator.render(width);
+          }
+        };
+      }
+      const onMouse = (event) => {
+        const progress = model2.progressForItem(key);
+        const gapRows = gapBefore && progress?.open !== true ? 1 : 0;
+        if (progress?.lead && event.y === gapRows) {
+          if (event.type === "move") {
+            claimedMove = true;
+            return setHover(model2, `exchange:${progress.exchange}`) ? repaint : void 0;
+          }
+          if (event.type === "click" && event.button === "left") {
+            const control = { kind: "progress", exchange: progress.exchange };
+            if (event.alt) model2.toggleOneLevel(control);
+            else model2.toggleProgress(progress.exchange);
+            folded.call(this, message, isStreaming);
+            requestRender2();
+            return { handled: true, render: false };
+          }
+        }
+        if (progress && !progress.open) return void 0;
+        const y = event.y - gapRows - (progress?.lead ? 1 : 0);
+        if (event.type === "move") {
+          const titleRow = lead ? 1 : 0;
+          const key2 = lead && y === 0 ? `process:${process2.id}` : y === titleRow && (!process2 || model2.isProcessOpen(process2.id)) ? `thinking:${message.timestamp}:${run.index}` : void 0;
+          claimedMove = key2 !== void 0;
+          return setHover(model2, key2) ? repaint : void 0;
+        }
+        if (event.type !== "click" || event.button !== "left") return void 0;
+        if (process2 && lead && y === 0) {
+          const control = { kind: "process", id: process2.id };
+          if (event.alt) model2.toggleOneLevel(control);
+          else model2.toggleProcess(process2.id);
+        } else if (process2 && !model2.isProcessOpen(process2.id)) {
+          const control = { kind: "process", id: process2.id };
+          if (event.alt) model2.toggleOneLevel(control);
+          else model2.toggleProcess(process2.id);
+        } else if (event.alt) {
+          const control = { kind: "thinking", message, index: run.index };
+          model2.toggleOneLevel(control);
+        } else model2.toggleThinking(message, run.index);
+        folded.call(this, message, isStreaming);
+        requestRender2();
+        return { handled: true, render: false };
+      };
+      const component = this;
+      const child = {
+        render(width) {
+          const current = model2.progressForItem(key);
+          const progressLine = current?.lead ? progressRow(model2, current.exchange, getTheme2(), component.outputPad, width) : [];
+          const progressGuide = current?.open ? model2.progressGuideForItem(key) : void 0;
+          const processGuide = process2 ? model2.processBlockGuide(key) : void 0;
+          const withGap = (rows2) => gapBefore && current?.open !== true && rows2.length ? [...withGuide(getTheme2(), progressGuide ? "\u2502 " : "", [""]), ...rows2] : rows2;
+          if (current && !current.open) return withGap(progressLine);
+          if (process2 && !model2.isProcessOpen(process2.id) && !lead) return [];
+          const innerWidth = width - (current ? BLOCK_INDENT : 0);
+          const padding = Math.min(component.outputPad, Math.max(0, Math.floor((width - 1) / 2)));
+          const processText = lead ? truncateProcessLine(model2.processLine(process2.id), innerWidth - padding * 2) : void 0;
+          const processLine = processText === void 0 ? [] : hoverRows(getTheme2(), model2, `process:${process2.id}`, new Text(styleControl(getTheme2(), model2, `process:${process2.id}`, processText), component.outputPad, 0).render(innerWidth), component.outputPad);
+          const processRows = progressGuide && lead ? withGuide(getTheme2(), progressGuide.branch, processLine) : processLine;
+          if (process2 && !model2.isProcessOpen(process2.id)) {
+            const gap2 = progressLine.length && processRows.length && current?.open !== true ? withGuide(getTheme2(), progressGuide?.continuation ?? "", [""]) : [];
+            return withGap([...progressLine, ...gap2, ...processRows]);
+          }
+          const indent = process2 ? BLOCK_INDENT : 0;
+          const title = fitThinkingLine(model2.thinkingTitle(message, run.index, run.trace, component.isStreaming), innerWidth - indent - padding * 2);
+          const styled = styleControl(getTheme2(), model2, `thinking:${message.timestamp}:${run.index}`, title);
+          const titlePrefix = (progressGuide?.continuation ?? "") + (process2 ? processGuide?.branch ?? "  " : "");
+          const titleRows = withGuide(getTheme2(), titlePrefix, hoverRows(
+            getTheme2(),
+            model2,
+            key,
+            new Text(styled, component.outputPad, 0).render(innerWidth - indent),
+            component.outputPad
+          ));
+          const bodyPrefix = (progressGuide?.continuation ?? "") + (process2 ? processGuide?.continuation ?? "  " : "") + (indent ? " ".repeat(BLOCK_INDENT) : "");
+          const body = model2.isThinkingOpen(message, run.index) ? withGuide(getTheme2(), bodyPrefix, native.child.render(innerWidth - indent * 2)) : [];
+          const rows = [...processRows, ...titleRows, ...body];
+          const gap = progressLine.length && rows.length && current?.open !== true ? withGuide(getTheme2(), progressGuide?.continuation ?? "", [""]) : [];
+          return withGap([...progressLine, ...gap, ...rows]);
+        },
+        invalidate() {
+        }
+      };
+      const region = new MouseRegion(child, onMouse);
+      children[regions[runIndex]] = region;
+      childKeys.set(region, key);
+    });
+    const continuationFor = (key) => {
+      const progressPrefix = model2.progressGuideForItem(key)?.continuation ?? "";
+      const process2 = processByKey.get(key);
+      const blockPrefix = process2 && model2.isProcessOpen(process2.id) ? model2.processBlockGuide(key)?.continuation ?? "" : "";
+      return progressPrefix + blockPrefix;
+    };
+    for (let index = 1; index < children.length; index++) {
+      const spacer = children[index];
+      if (spacer.constructor.name !== "Spacer") continue;
+      let previousKey;
+      for (let previous = index - 1; previous >= 0; previous--) {
+        const sibling = children[previous];
+        previousKey = childKeys.get(sibling);
+        if (previousKey || sibling.constructor.name !== "Spacer") break;
+      }
+      let nextKey;
+      for (let next = index + 1; next < children.length; next++) {
+        const sibling = children[next];
+        nextKey = childKeys.get(sibling);
+        if (nextKey || sibling.constructor.name !== "Spacer") break;
+      }
+      const key = previousKey ?? nextKey;
+      if (!key) continue;
+      const originalRender = spacer.render.bind(spacer);
+      children[index] = {
+        constructor: spacer.constructor,
+        render(width) {
+          if (previousKey && nextKey && sameCompactGroup(previousKey, nextKey)) return [];
+          if (previousKey && nextKey && compactItem(previousKey) !== compactItem(nextKey)) return originalRender(width);
+          const prefix = continuationFor(key);
+          return prefix ? withGuide(getTheme2(), prefix, originalRender(Math.max(0, width - visibleWidth3(prefix)))) : originalRender(width);
+        }
+      };
+    }
+  }
+  function folded(message, isStreaming) {
+    if (owners.size === 0) {
+      original.call(this, message, isStreaming);
+      return;
+    }
+    try {
+      foldContent.call(this, message, isStreaming);
+    } catch {
+      original.call(this, message, isStreaming);
+    }
+  }
+  prototype.updateContent = folded;
+  function hoverMouse(event) {
+    claimedMove = false;
+    const pointer = event;
+    if (owners.size > 0 && pointer.y !== void 0 && pointer.width !== void 0) {
+      let row = 0;
+      for (const child of this.contentContainer.children) {
+        const control = textControls.get(this)?.find((item) => item.child === child);
+        const owner = this.lastMessage ? ownerFor(this.lastMessage) : void 0;
+        const progress = control && owner?.model.progressForItem(control.key);
+        if (progress?.lead && pointer.y === row) {
+          if (event.type === "move") return setHover(owner.model, `exchange:${progress.exchange}`) ? repaint : void 0;
+          if (event.type === "click" && pointer.button === "left") {
+            const control2 = { kind: "progress", exchange: progress.exchange };
+            if (pointer.alt) owner?.model.toggleOneLevel(control2);
+            else owner?.model.toggleProgress(progress.exchange);
+            if (this.lastMessage) this.updateContent(this.lastMessage);
+            owner?.requestRender();
+            return { handled: true, render: false };
+          }
+        }
+        row += child.render(pointer.width).length;
+      }
+    }
+    const result = originalMouse?.call(this, event);
+    if (event.type === "move" && owners.size > 0 && !claimedMove && setHover(void 0, void 0)) return result ?? repaint;
+    return result;
+  }
+  prototype.handleMouse = hoverMouse;
+  const owners = /* @__PURE__ */ new Set();
+  const add = (owner) => {
+    owners.add(owner);
+    return { installed: true, restore() {
+      if (!owners.delete(owner)) return;
+      if (hoveredControl?.model === owner.model) setHover(void 0, void 0);
+      if (owners.size > 0) return;
+      if (prototype.updateContent === folded) thinkingOwners.delete(prototype);
+      if (prototype.updateContent === folded) prototype.updateContent = original;
+      if (prototype.handleMouse === hoverMouse && !thinkingOwners.has(prototype)) {
+        if (hadOwnMouse) prototype.handleMouse = originalMouse;
+        else delete prototype.handleMouse;
+      }
+    } };
+  };
+  thinkingOwners.set(prototype, { add });
+  return add({ model, getTheme, requestRender, observeOutputPad });
+}
+
+// extensions/focus-mode/focus-mode.ts
+import { Box, Text as Text2 } from "@earendil-works/pi-tui";
+var ENTRY_TYPE = "exchange-stats";
+var HEADLINE_ENTRY_TYPE = "exchange-stats-headline";
+var STATUS_KEY = "exchange";
+var TICK_MS = 1e3;
+var TOOL_SHARE_NOTE = 0.25;
+var FOLD_KEYS = {
+  processKey: { default: "ctrl+alt+f", env: "PI_FOCUS_MODE_PROCESS_KEY" },
+  exchangeKey: { default: "ctrl+alt+e", env: "PI_FOCUS_MODE_EXCHANGE_KEY" },
+  pickerKey: { default: "ctrl+alt+s", env: "PI_FOCUS_MODE_PICKER_KEY" },
+  cursorKey: { default: "ctrl+alt+g", env: "PI_FOCUS_MODE_CURSOR_KEY" }
+};
+var CURSOR_SETTING = { cursorMode: { default: false, env: "PI_FOCUS_MODE_CURSOR_MODE", parseEnv: (value) => value === "true" } };
+var SUMMARY_SETTING = { summaryModel: { default: "", env: "PI_FOCUS_MODE_SUMMARY_MODEL" } };
+var emptyTotals = () => ({
+  input: 0,
+  output: 0,
+  reasoning: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+  totalTokens: 0,
+  cost: 0
+});
+function fmtDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "\u2014";
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  const s = ms / 1e3;
+  if (s < 60) return `${s.toFixed(1)}s`;
+  const m = Math.floor(s / 60);
+  const rem = Math.round(s % 60);
+  return rem > 0 ? `${m}m${rem}s` : `${m}m`;
+}
+function fmtLocalFinishTime(at) {
+  const date = new Date(at);
+  const time = new Intl.DateTimeFormat(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+  }).format(date);
+  const calendarDate = new Intl.DateTimeFormat(void 0, { year: "numeric", month: "numeric", day: "numeric" });
+  if (calendarDate.format(date) === calendarDate.format(new Date(Date.now()))) return time;
+  return new Intl.DateTimeFormat(void 0, { dateStyle: "medium" }).format(date) + " " + time;
+}
+function fmtTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return "0";
+  if (n < 1e3) return `${Math.round(n)}`;
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}k`;
+  return `${(n / 1e6).toFixed(2)}M`;
+}
+function fmtCost(cost) {
+  if (!Number.isFinite(cost) || cost <= 0) return "$0";
+  return cost < 0.01 ? `$${cost.toFixed(5)}` : `$${cost.toFixed(4)}`;
+}
+function fmtCacheUsage(cacheRead, cacheWrite) {
+  const read = cacheRead > 0 ? fmtTokens(cacheRead) : void 0;
+  const written = cacheWrite > 0 ? fmtTokens(cacheWrite) : void 0;
+  if (read && written) return `cache ${read} / ${written} written`;
+  if (read) return `cache ${read}`;
+  if (written) return `cache ${written} written`;
+  return void 0;
+}
+function plural(n, one, many = `${one}s`) {
+  return n === 1 ? `${n} ${one}` : `${n} ${many}`;
+}
+function openToolText(spans, now) {
+  let longest;
+  for (const span of spans.values()) {
+    if (!longest || now - span.start > now - longest.start) longest = span;
+  }
+  if (!longest) return void 0;
+  const extra = spans.size > 1 ? ` (+${spans.size - 1})` : "";
+  return `${longest.name} ${fmtDuration(now - longest.start)}${extra}`;
+}
+function unionMs(runs) {
+  if (runs.length === 0) return 0;
+  const sorted = [...runs].sort((a, b) => a.start - b.start);
+  let total = 0;
+  let start = sorted[0].start;
+  let end = sorted[0].end;
+  for (const run of sorted.slice(1)) {
+    if (run.start > end) {
+      total += end - start;
+      start = run.start;
+      end = run.end;
+    } else if (run.end > end) {
+      end = run.end;
+    }
+  }
+  return total + (end - start);
+}
+function registerExchangeStats(pi, toolComponent = ToolExecutionComponent, settingsRuntime = {}) {
+  let toolFold = new ToolFoldModel();
+  let themeContext;
+  const getTitleTheme = () => themeContext?.ui.theme;
+  let outputPad = 1;
+  let lastStatus = "";
+  const requestRender = () => {
+    if (themeContext) themeContext.ui.setStatus(STATUS_KEY, toolFold.cursorTitle() ? `${lastStatus} \xB7 Cursor ${toolFold.cursorTitle()}` : lastStatus);
+  };
+  let toolPatch;
+  let thinkingPatch;
+  let sessionActive = false;
+  const resolvedKeys = resolveSettings("focus-mode", FOLD_KEYS, {
+    cwd: process.cwd(),
+    hasUI: true,
+    isProjectTrusted: () => false
+  }, settingsRuntime);
+  const cursorMode = resolveSettings("focus-mode", CURSOR_SETTING, {
+    cwd: process.cwd(),
+    hasUI: true,
+    isProjectTrusted: () => false
+  }, settingsRuntime).cursorMode.value === true;
+  const validKey = (value) => {
+    if (typeof value !== "string") return false;
+    const parts = value.split("+");
+    const base = parts.pop();
+    return parts.length > 0 && new Set(parts).size === parts.length && parts.every((part) => ["ctrl", "alt", "shift", "super"].includes(part)) && base !== void 0 && (/^[a-z0-9]$/.test(base) || ["enter", "escape", "tab", "space", "backspace", "delete", "up", "down", "left", "right", "home", "end"].includes(base));
+  };
+  const keys = Object.fromEntries(Object.entries(FOLD_KEYS).map(([name, definition]) => {
+    const value = resolvedKeys[name].value;
+    return [name, validKey(value) ? value : definition.default];
+  }));
+  const invalidKey = Object.entries(FOLD_KEYS).some(([name]) => !validKey(resolvedKeys[name].value));
+  let warnedAboutKey = false;
+  let warnedAboutToolFold = false;
+  let warnedAboutThinkingFold = false;
+  let summaryScheduler;
+  let summarySession = 0;
+  let restoredEntries = [];
+  let sessionTotals = {
+    ...emptyTotals(),
+    exchanges: 0,
+    turnCount: 0,
+    durationMs: 0,
+    toolMs: 0,
+    waitingMs: 0
+  };
+  let sessionStartedAt = 0;
+  let running = false;
+  let startedAt = 0;
+  let promptCount = 0;
+  let exchangeIndex = 0;
+  let model = "unknown";
+  let stopReason = "stop";
+  let turns = [];
+  let totals = emptyTotals();
+  let waitingMs = 0;
+  let waitingStart;
+  let liveTimer;
+  let liveRefresh;
+  let activeTurn;
+  let activeToolRuns = [];
+  function setStatus(text, ctx) {
+    if (!ctx.hasUI) return;
+    lastStatus = text;
+    ctx.ui.setStatus(STATUS_KEY, toolFold.cursorTitle() ? `${text} \xB7 Cursor ${toolFold.cursorTitle()}` : text);
+  }
+  pi.registerShortcut(keys.processKey, { description: "Toggle latest process", handler: (ctx) => {
+    if (toolFold.toggleLatestProcess() !== void 0) {
+      themeContext = ctx;
+      requestRender();
+    }
+  } });
+  pi.registerShortcut(keys.exchangeKey, { description: "Toggle latest exchange", handler: (ctx) => {
+    if (toolFold.toggleLatestExchange() !== void 0) {
+      themeContext = ctx;
+      requestRender();
+    }
+  } });
+  pi.registerShortcut(keys.pickerKey, { description: "Choose exchange, process or block to fold", handler: async (ctx) => {
+    if (!ctx.hasUI) return;
+    await ctx.ui.custom((tui, theme, _keybindings, done) => new FoldPicker(toolFold, () => ctx.ui.theme ?? theme, () => tui.requestRender(), () => done(void 0)), { overlay: true });
+  } });
+  if (cursorMode) pi.registerShortcut(keys.cursorKey, { description: "Move through transcript folds", handler: async (ctx) => {
+    if (!ctx.hasUI || !toolFold.startCursor()) return;
+    themeContext = ctx;
+    requestRender();
+    try {
+      await ctx.ui.custom((_tui, _theme, _keybindings, done) => new TranscriptCursor(toolFold, requestRender, () => done(void 0)), { overlay: true });
+    } finally {
+      toolFold.stopCursor();
+      requestRender();
+    }
+  } });
+  function liveStatusText() {
+    const now = Date.now();
+    const parts = [`\u23F1 ${fmtDuration(now - startedAt)}`];
+    if (turns.length > 0) parts.push(`${plural(turns.length, "turn")} done`);
+    const toolText = activeTurn ? openToolText(activeTurn.spans, now) : void 0;
+    if (toolText) parts.push(toolText);
+    else if (activeTurn) parts.push(`turn ${activeTurn.index}`);
+    return parts.join(" \xB7 ");
+  }
+  function stopLiveTimer() {
+    if (liveTimer) clearInterval(liveTimer);
+    liveTimer = void 0;
+    liveRefresh = void 0;
+  }
+  function resetExchangeState() {
+    running = false;
+    startedAt = 0;
+    promptCount = 0;
+    turns = [];
+    totals = emptyTotals();
+    waitingMs = 0;
+    waitingStart = void 0;
+    activeTurn = void 0;
+    activeToolRuns = [];
+    stopLiveTimer();
+  }
+  function restoreSession(ctx) {
+    const entries = ctx.sessionManager?.getBranch() ?? [];
+    restoredEntries = entries;
+    toolFold.clear((id) => {
+      let correction;
+      for (let index = restoredEntries.length - 1; index >= 0; index--) {
+        const entry = restoredEntries[index];
+        if (entry.type !== "custom") continue;
+        const patch = entry.customType === HEADLINE_ENTRY_TYPE ? entry.data : void 0;
+        if (!correction && patch?.id === id) correction = patch;
+        if (entry.customType !== ENTRY_TYPE) continue;
+        const found = entry.data?.blocks?.find((block) => block.id === id);
+        if (found) return found.kind === "thinking" && correction ? { ...found, headline: correction.headline, headlineSource: correction.headlineSource } : found;
+      }
+      return void 0;
+    });
+    const recordedIndex = entries.reduce((highest, entry) => entry.type === "custom" && entry.customType === ENTRY_TYPE && entry.data?.kind === "exchange" ? Math.max(highest, entry.data.index) : highest, 0);
+    if (!running) exchangeIndex = recordedIndex;
+    const lastCompaction = entries.findLastIndex((entry) => entry.type === "compaction");
+    const active = entries.slice(lastCompaction + 1);
+    let nextExchange = active.find((entry) => entry.type === "custom" && entry.customType === ENTRY_TYPE && entry.data?.kind === "exchange")?.data?.index ?? (running ? exchangeIndex : exchangeIndex + 1);
+    let inExchange = false;
+    for (const entry of active) {
+      if (entry.type === "custom" && entry.customType === ENTRY_TYPE && entry.data?.kind === "exchange") {
+        toolFold.endExchange(entry.data.progressDurationMs ?? entry.data.durationMs);
+        inExchange = false;
+        nextExchange = entry.data.index + 1;
+      } else if (entry.type === "message" && entry.message?.role === "assistant" && Array.isArray(entry.message.content)) {
+        if (!inExchange) {
+          toolFold.beginExchange(nextExchange);
+          inExchange = true;
+        }
+        toolFold.ingest(entry.message);
+      } else if (entry.type === "message" && entry.message?.role === "toolResult" && entry.message.toolCallId) {
+        toolFold.end(entry.message.toolCallId, false, { content: entry.message.content });
+      }
+    }
+    if (!running && inExchange) toolFold.endExchange();
+    else if (running && !inExchange) toolFold.beginExchange(exchangeIndex);
+  }
+  pi.registerEntryRenderer(ENTRY_TYPE, (entry, _options, theme) => {
+    const data = entry.data;
+    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+    const dimText = (text) => {
+      const colored = theme.fg("dim", text);
+      return theme.italic?.(colored) ?? colored;
+    };
+    const boxMouse = box.handleMouse.bind(box);
+    box.handleMouse = (event) => endHoverOnMove(event) ?? boxMouse(event);
+    if (!data) {
+      box.addChild(new Text2(dimText("(no stats)"), 0, 0));
+      return box;
+    }
+    const isSession = data.kind === "session";
+    const finishTime = data.endedAt === void 0 ? "" : ` \xB7 ${fmtLocalFinishTime(data.endedAt)}`;
+    const headline2 = isSession ? `\u{1F4CA} Session \xB7 ${plural(data.turnCount, "turn")} across ${plural(data.index, "exchange")}` : `\u23F1 ${fmtDuration(data.durationMs)}${finishTime}`;
+    const summary2 = [`in ${fmtTokens(data.input)}`, `out ${fmtTokens(data.output)}`];
+    const cache = fmtCacheUsage(data.cacheRead, data.cacheWrite);
+    if (cache) summary2.push(cache);
+    if (data.waitingMs > 0) summary2.push(`waiting ${fmtDuration(data.waitingMs)}`);
+    summary2.push(fmtCost(data.cost));
+    box.addChild(new Text2(dimText(`${headline2} \xB7 ${data.model} (${summary2.join(" \xB7 ")})`), 0, 0));
+    return box;
+  });
+  pi.on("session_start", (_event, ctx) => {
+    if (sessionActive) return;
+    sessionActive = true;
+    resetExchangeState();
+    toolFold = new ToolFoldModel();
+    outputPad = 1;
+    lastStatus = "";
+    restoredEntries = [];
+    sessionTotals = { ...emptyTotals(), exchanges: 0, turnCount: 0, durationMs: 0, toolMs: 0, waitingMs: 0 };
+    toolPatch = installToolFold(toolComponent, toolFold, getTitleTheme, () => outputPad);
+    thinkingPatch = installThinkingFold(AssistantMessageComponent, toolFold, getTitleTheme, requestRender, (padding) => {
+      outputPad = padding;
+    });
+    themeContext = ctx;
+    const session = ++summarySession;
+    summaryScheduler?.dispose();
+    summaryScheduler = void 0;
+    const summaryValue = resolveSettings("focus-mode", SUMMARY_SETTING, {
+      cwd: ctx.cwd ?? process.cwd(),
+      hasUI: ctx.hasUI,
+      isProjectTrusted: () => ctx.isProjectTrusted?.() ?? false
+    }, settingsRuntime).summaryModel.value;
+    const configuredModel = typeof summaryValue === "string" ? summaryValue.trim() : "";
+    if (configuredModel) {
+      const slash = configuredModel.indexOf("/");
+      const chosen = slash > 0 ? ctx.modelRegistry?.find(configuredModel.slice(0, slash), configuredModel.slice(slash + 1)) : void 0;
+      if (!chosen) {
+        announce(ctx, `focus-mode: unknown summaryModel ${configuredModel}; using trace sentence`, "warning", `focus-mode:unknown-summary:${session}`);
+      } else {
+        summaryScheduler = new HeadlineScheduler({
+          summarize: async (trace, signal) => {
+            const response = await ctx.modelRegistry.streamSimple(chosen, {
+              systemPrompt: "Summarize this live thinking trace as a headline of at most 10 words. Return only the headline.",
+              messages: [{ role: "user", content: [{ type: "text", text: trace }], timestamp: Date.now() }]
+            }, { reasoning: "off", maxTokens: 32, signal }).result();
+            if (response.stopReason === "length" && !response.content.some((part) => part.type === "text" && part.text.trim())) {
+              throw new HeadlineLengthError("model did not answer within its output cap");
+            }
+            if (response.stopReason !== "stop") throw new Error(response.errorMessage ?? "headline request failed");
+            return response.content.filter((part) => part.type === "text").map((part) => part.text).join(" ");
+          },
+          onHeadline: (key, headline2) => {
+            const [timestamp, index] = key.split(":").map(Number);
+            const patch = toolFold.setThinkingHeadline({ timestamp }, index, headline2);
+            if (patch) {
+              try {
+                pi.appendEntry(HEADLINE_ENTRY_TYPE, patch);
+                restoredEntries.push({ type: "custom", customType: HEADLINE_ENTRY_TYPE, data: patch });
+              } catch {
+              }
+            }
+            requestRender();
+          },
+          onFailure: (reason, message) => {
+            const detail = reason === "length" ? 'model did not answer within its output cap; set thinkingLevelMap.off to "none" for this model' : reason === "timeout" ? "request timed out" : (message ?? "headline request failed").replace(/\s+/g, " ").trim().slice(0, 120);
+            announce(ctx, `focus-mode: headline summary ${configuredModel}: ${detail}; using trace sentence`, "warning", `focus-mode:headline-failure:${session}`);
+          }
+        });
+      }
+    }
+    if (invalidKey && !warnedAboutKey) {
+      announce(ctx, "focus-mode: invalid fold shortcut; using default key", "warning", "focus-mode:invalid-fold-key");
+      warnedAboutKey = true;
+    }
+    if (!toolPatch.installed && !warnedAboutToolFold) {
+      announce(ctx, "focus-mode: tool folding unavailable; Pi tool rows remain native", "warning");
+      warnedAboutToolFold = true;
+    }
+    if (!thinkingPatch.installed && !warnedAboutThinkingFold) {
+      announce(ctx, "focus-mode: thinking folding unavailable; Pi thinking remains native", "warning");
+      warnedAboutThinkingFold = true;
+    }
+    restoreSession(ctx);
+    sessionStartedAt = Date.now();
+    setStatus("\u23F1 ready", ctx);
+  });
+  pi.on("session_shutdown", () => {
+    if (!sessionActive) return;
+    sessionActive = false;
+    themeContext = void 0;
+    toolFold.stopCursor();
+    summaryScheduler?.dispose();
+    summaryScheduler = void 0;
+    toolPatch?.restore();
+    thinkingPatch?.restore();
+    toolPatch = void 0;
+    thinkingPatch = void 0;
+    resetExchangeState();
+    toolFold = new ToolFoldModel();
+    restoredEntries = [];
+  });
+  pi.on("session_compact", (_event, ctx) => {
+    restoreSession(ctx);
+    requestRender();
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    restoreSession(ctx);
+    requestRender();
+  });
+  pi.on("message_update", (event) => {
+    if (event.message.role !== "assistant") return;
+    toolFold.observeThinking(event.message, event.assistantMessageEvent, event.message.usage?.reasoning);
+    toolFold.ingest(event.message);
+    const update = event.assistantMessageEvent;
+    if (update.type === "thinking_delta" && update.contentIndex !== void 0) {
+      let start = update.contentIndex;
+      while (start > 0 && event.message.content[start - 1]?.type === "thinking") start--;
+      let end = start;
+      while (event.message.content[end]?.type === "thinking") end++;
+      const trace = event.message.content.slice(start, end).map((item) => item.type === "thinking" ? item.thinking.trim() : "").filter(Boolean).join("\n\n");
+      if (trace) summaryScheduler?.observe(`${event.message.timestamp}:${start}`, trace);
+    } else if (update.type !== "thinking_start") {
+      for (let index = 0; index < event.message.content.length; index++) {
+        if (event.message.content[index].type === "thinking") summaryScheduler?.settle(`${event.message.timestamp}:${index}`);
+      }
+    }
+  });
+  pi.on("message_end", (event) => {
+    if (event.message.role === "assistant") {
+      toolFold.ingest(event.message);
+      toolFold.settleThinking(event.message);
+      for (let index = 0; index < event.message.content.length; index++) {
+        if (event.message.content[index].type === "thinking") summaryScheduler?.settle(`${event.message.timestamp}:${index}`);
+      }
+    }
+  });
+  pi.on("before_agent_start", (_event, ctx) => {
+    if (running) {
+      promptCount++;
+      return;
+    }
+    running = true;
+    toolFold.beginExchange(exchangeIndex + 1);
+    startedAt = Date.now();
+    promptCount = 1;
+    exchangeIndex++;
+    turns = [];
+    totals = emptyTotals();
+    waitingMs = 0;
+    waitingStart = void 0;
+    activeTurn = void 0;
+    activeToolRuns = [];
+    model = ctx.model?.id ?? "unknown";
+    stopReason = "stop";
+    stopLiveTimer();
+    setStatus(liveStatusText(), ctx);
+    liveRefresh = () => setStatus(liveStatusText(), ctx);
+    liveTimer = setInterval(() => {
+      try {
+        liveRefresh?.();
+        summaryScheduler?.tick();
+      } catch {
+        stopLiveTimer();
+      }
+    }, TICK_MS);
+  });
+  pi.on("turn_start", (event, _ctx) => {
+    if (!running) return;
+    activeTurn = { index: event.turnIndex ?? turns.length + 1, startedAt: Date.now(), spans: /* @__PURE__ */ new Map() };
+    activeToolRuns = [];
+  });
+  pi.on("tool_execution_start", (event, _ctx) => {
+    toolFold.start(event.toolCallId, event.toolName);
+    if (!running || !activeTurn) return;
+    activeTurn.spans.set(event.toolCallId, { name: event.toolName, start: Date.now() });
+  });
+  pi.on("tool_execution_end", (event, _ctx) => {
+    toolFold.end(event.toolCallId, Boolean(event.isError), event.result);
+    if (!running || !activeTurn) return;
+    const open = activeTurn.spans.get(event.toolCallId);
+    if (open) {
+      activeTurn.spans.delete(event.toolCallId);
+      activeToolRuns.push({
+        name: event.toolName ?? open.name,
+        start: open.start,
+        end: Date.now(),
+        isError: Boolean(event.isError)
+      });
+      return;
+    }
+    const at = Date.now();
+    activeToolRuns.push({ name: event.toolName, start: at, end: at, isError: Boolean(event.isError) });
+  });
+  pi.on("turn_end", (event, _ctx) => {
+    if (!running || !activeTurn) return;
+    const endedAt = Date.now();
+    for (const [id, open] of activeTurn.spans) {
+      activeToolRuns.push({ name: open.name, start: open.start, end: endedAt, isError: false });
+      activeTurn.spans.delete(id);
+    }
+    const usage = event.message?.role === "assistant" ? event.message.usage : void 0;
+    const durationMs = endedAt - activeTurn.startedAt;
+    const toolMs = unionMs(activeToolRuns);
+    const output = usage?.output ?? 0;
+    turns.push({
+      index: activeTurn.index,
+      durationMs,
+      toolMs,
+      modelMs: Math.max(0, durationMs - toolMs),
+      outputPerSec: durationMs > 0 ? output / (durationMs / 1e3) : 0,
+      tools: activeToolRuns.map((run) => ({ name: run.name, ms: run.end - run.start, isError: run.isError })),
+      input: usage?.input ?? 0,
+      output,
+      reasoning: usage?.reasoning ?? 0,
+      cacheRead: usage?.cacheRead ?? 0,
+      cacheWrite: usage?.cacheWrite ?? 0,
+      totalTokens: usage?.totalTokens ?? 0,
+      cost: usage?.cost?.total ?? 0
+    });
+    totals.input += usage?.input ?? 0;
+    totals.output += output;
+    totals.reasoning += usage?.reasoning ?? 0;
+    totals.cacheRead += usage?.cacheRead ?? 0;
+    totals.cacheWrite += usage?.cacheWrite ?? 0;
+    totals.totalTokens += usage?.totalTokens ?? 0;
+    totals.cost += usage?.cost?.total ?? 0;
+    if (event.message?.stopReason) stopReason = event.message.stopReason;
+    activeTurn = void 0;
+    activeToolRuns = [];
+  });
+  pi.on("ui_prompt_start", (_event, _ctx) => {
+    if (!running || waitingStart !== void 0) return;
+    waitingStart = Date.now();
+  });
+  pi.on("ui_prompt_end", (_event, _ctx) => {
+    if (waitingStart === void 0) return;
+    waitingMs += Date.now() - waitingStart;
+    waitingStart = void 0;
+  });
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!running) return;
+    const endedAt = Date.now();
+    if (waitingStart !== void 0) {
+      waitingMs += endedAt - waitingStart;
+      waitingStart = void 0;
+    }
+    const durationMs = endedAt - startedAt;
+    const progressDurationMs = toolFold.progressDurationForExchange(exchangeIndex);
+    const toolMs = turns.reduce((sum, turn) => sum + turn.toolMs, 0);
+    const record = {
+      ...totals,
+      kind: "exchange",
+      index: exchangeIndex,
+      promptCount,
+      turnCount: turns.length,
+      turns,
+      startedAt,
+      endedAt,
+      durationMs,
+      ...progressDurationMs === void 0 ? {} : { progressDurationMs },
+      waitingMs,
+      toolMs,
+      model,
+      stopReason,
+      blocks: toolFold.recordsForExchange(exchangeIndex)
+    };
+    stopLiveTimer();
+    sessionTotals.input += totals.input;
+    sessionTotals.output += totals.output;
+    sessionTotals.reasoning += totals.reasoning;
+    sessionTotals.cacheRead += totals.cacheRead;
+    sessionTotals.cacheWrite += totals.cacheWrite;
+    sessionTotals.totalTokens += totals.totalTokens;
+    sessionTotals.cost += totals.cost;
+    sessionTotals.exchanges++;
+    sessionTotals.turnCount += turns.length;
+    sessionTotals.durationMs += durationMs;
+    sessionTotals.toolMs += toolMs;
+    sessionTotals.waitingMs += waitingMs;
+    try {
+      pi.appendEntry(ENTRY_TYPE, record);
+      if (!restoredEntries.some((entry) => entry.data === record)) restoredEntries.push({ type: "custom", customType: ENTRY_TYPE, data: record });
+    } catch {
+    }
+    const parts = [`\u23F1 ${fmtDuration(durationMs)}`, plural(turns.length, "turn")];
+    if (toolMs > 0 && durationMs > 0 && toolMs / durationMs >= TOOL_SHARE_NOTE) {
+      parts.push(`tools ${fmtDuration(toolMs)}`);
+    }
+    parts.push(`out ${fmtTokens(totals.output)}`);
+    if (totals.cost > 0) parts.push(fmtCost(totals.cost));
+    if (waitingMs > 0) parts.push(`waiting ${fmtDuration(waitingMs)}`);
+    setStatus(parts.join(" \xB7 "), ctx);
+    toolFold.endExchange();
+    toolFold.releaseExchangeRecords();
+    resetExchangeState();
+  });
+  pi.registerCommand("exstats", {
+    description: "Append a cumulative session timing card",
+    handler: () => {
+      const record = {
+        ...sessionTotals,
+        kind: "session",
+        index: sessionTotals.exchanges,
+        promptCount: sessionTotals.exchanges,
+        turnCount: sessionTotals.turnCount,
+        turns: [],
+        startedAt: sessionStartedAt,
+        endedAt: Date.now(),
+        durationMs: sessionTotals.durationMs,
+        waitingMs: sessionTotals.waitingMs,
+        toolMs: sessionTotals.toolMs,
+        model: `${plural(sessionTotals.turnCount, "turn")} tracked`,
+        stopReason: "session"
+      };
+      try {
+        pi.appendEntry(ENTRY_TYPE, record);
+      } catch {
+      }
+    }
+  });
+}
+var focus_mode_default = registerExchangeStats;
+export {
+  focus_mode_default as default,
+  registerExchangeStats
+};