@yanzc/claude-pro 0.5.5 → 0.5.7

package/README.md

@@ -161,7 +161,8 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 ## 终端标题、页脚与窗口缩放
 
 - **终端标题**：标签/窗口标题显示 `✳ <会话标题> | <目录> · <模型> · <effort>`（会话标题是**当前话题**：每次发消息后，后台让小模型（haiku）判断是否换了话题，换了就生成一个简短标题，和官方客户端一样；"继续"之类的消息不会改标题。话题记在会话文件里，`/resume`、重启后仍在，`/resume` 列表也显示它。旧会话没有话题时，恢复时按最近一条提问生成。还没生成时显示第一条提问。最多 40 字，保证模型和 effort 不被窄标签截掉。`CLAUDE_PRO_DISABLE_TOPIC_TITLE=1` 关闭，省掉每条消息一次的小请求）。忙碌时前缀在 `⠂`/`⠐` 之间闪动，限流暂停时变 `⏸`，退出时恢复进入前的标题。`/model`、`/effort`、`/clear`、`/resume` 后自动更新。**VS Code**(1.140 起)只对它认得的 AI 命令行(claude/codex/copilot/gemini)把程序设置的标题显示在标签上(`terminal.integrated.tabs.allowAgentCliTitle`,默认开),其余一律显示进程名 `node`;它在 Windows 上靠 `node.exe` 命令行里的 `\claude-code\` 路径段识别 Claude Code,所以监督进程用 `bin\claude-code\..\claude-pro.js` 启动会话(目录不必存在,Node 自己化简 `..`)。不经过监督进程的启动方式(`CLAUDE_PRO_NO_SUPERVISOR=1`)或 Linux/macOS 上,要在 VS Code 设置里把 `terminal.integrated.tabs.title` 改成 `${sequence}` 才能看到标题。
-- **页脚**：输入框下方右侧常驻当前模型和 effort（如 `sonnet-5-5 · high`）；没发送 effort（auto）或该模型不支持时只显示模型；窄窗口放不下时先让位给"上下文快满"等提示，再不行就不显示。
+- **用户的提问**：带一条深灰色背景（横跨整个窗口宽度），和回复一眼就能分开。背景条是用当前背景色清除行尾（`\x1b[K`）画出来的，不靠补空格，窗口变宽变窄都正好铺满。
+- **页脚**：输入框下方右侧常驻当前模型和 effort（如 `sonnet-5-5 · high`）；没发送 effort（auto）或该模型不支持时只显示模型；窄窗口放不下时先让位给"上下文快满"等提示，再不行就不显示。模型前面是**当前对话累计花费**（如 `$1.23 · opus-5-5 · effort high`）：按官方价（和网关扣费同一张价目表，含 5 分钟/1 小时缓存写入、长上下文价）把每个请求算进去，子 agent、压缩、话题标题、WebFetch 都算，按 Esc 中断的请求按已读入的输入和估算的已输出部分算；记在会话文件里，重启、`/resume` 后接着累计，`/clear` 从零开始。`/cost` 第一行也显示它，`-p --output-format json` 的结果带本次运行的 `total_cost_usd`。不认识价格的模型（第三方端点的自定义模型）不计；网关上游分组倍率不是 1 的账户以网关流水为准。花费前面是**提示词缓存时钟**（和官方 VS Code 扩展的 prompt cache clock 一致）：`◷ 12m` 表示对话的缓存估计还能保留 12 分钟（按 5 分钟或 1 小时 TTL 倒数，每次用到缓存的回复重新开始计时）；倒数结束后分钟数消失、图标变红，直到下一次回复——这时发下一条消息会把整个对话重新写入缓存，更慢也更贵；压缩之后到下一次回复之前也是红色，因为压缩后的对话还没进缓存。时钟记在会话文件里，重启、`/resume` 后接着显示（压缩后关掉的会话恢复时是冷的）；还没有回复报告过缓存用量时不显示。窄窗口先省掉花费，再省掉时钟。
 - **缩放窗口**：拖动期间不重绘，停下约 80ms 后从左上角整屏绝对重绘一次，输入框不会再留下残影。注意：很短的会话里这次重绘会覆盖终端上方 shell 的内容。
 
 ## 自动重启：改了自己的代码马上生效
@@ -304,6 +305,7 @@ claude-pro -p --plan "给出重构方案"                    # 只调研、只
 | `ctrl+l` | 清屏重绘 |
 | `alt+v` | 粘贴剪贴板图片 |
 | `PgUp` / `PgDn`、滚轮、`Ctrl+Home` / `Ctrl+End` | 全屏模式下滚动对话 / 到开头 / 回到最新 |
+| `ctrl+f` | 全屏模式下在对话里查找（像 VS Code）：输入框的位置换成查找框，边输入边高亮所有匹配（不分大小写，当前这个橙色、其余黄色），右上角显示"第几个/共几个"（`No results` 表示没有）。先跳到视图底部往上最近的一个；`Enter` 或 `↑` 跳到更早的一个，`Shift+Enter` 或 `↓` 跳到更新的一个，到头后绕回；`PgUp`/`PgDn`、滚轮照常滚动；`Esc` 关闭，画面停在当前位置（`Ctrl+End` 回到底部）。再按 `ctrl+f` 会带上上次的关键字（已选中，直接输入就替换）；先用鼠标选中文字再按，会搜选中的文字。查找时有新输出，匹配会跟着更新。经典模式（`/tui default`）的对话在终端自己的滚动缓冲里，请用终端自带的查找 |
 | `↑` / `↓` | 在多行输入（包括自动折行的长文字）里上下移动光标；光标在第一行时 `↑` 先移到开头、再按才翻到上一条历史消息，`↓` 在最后一行同理 |
 | `Tab` | 补全命令 / 文件 |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "claude-pro: a self-implemented coding agent for Anthropic-compatible APIs or local Claude Code subscription login. Full access with no permission prompts; file edits are checkpointed and can be rewound.",
   "type": "module",
   "repository": {

package/src/agent.js

@@ -780,6 +780,7 @@ export class Agent {
     }
     const note = { role: 'user', content: [{ type: 'text', text: partialSummaryMessage(part, summary) }] };
     this.replaceMessages(part === 'before' ? [note, ...after] : [...before, note]);
+    if (part === 'before') this.cache.noteCompacted(); // from its first message on: nothing of it is cached (the start of "after" still is)
     if (part === 'after') this.todos = []; // what they were about may be summarized away; the model keeps them in the summary
     this.lastContextTokens = estimateTokens(this.messages) + estimateTokens(this.toolSchemas()) + 2000;
     this.tokensSinceUsage = 0;
@@ -809,6 +810,7 @@ export class Agent {
     }
     const todoNote = this.todos.length ? `\n\n<system-reminder>Current todo list:\n${this.todos.map((t) => `- [${t.status}] ${t.content}`).join('\n')}</system-reminder>` : '';
     this.replaceMessages([{ role: 'user', content: [{ type: 'text', text: continuationMessage(summary, { auto }) + todoNote }] }]);
+    this.cache.noteCompacted();
     this.refreshSystemPrompt?.(); // the conversation starts over: it may start from a freshly built system prompt
     this.fileState.clear();
     if (!this.isSubagent) this.checkpoints?.markConversationStale(); // the checkpoints are the main conversation's: a sub-agent's own compaction does not end them

package/src/api.js

@@ -10,6 +10,7 @@ import { readGatewayLogin, fetchGatewayModels, cachedGatewayModel, gatewayEffort
 import { createCodexFetch, codexModels, codexEffort, nearestEffort } from './codex/client.js';
 import { SIGNATURE_PREFIX } from './codex/translate-request.js';
 import { fitImagesIn } from './utils/images.js';
+import { costOf } from './pricing.js';
 
 let cached = null;
 
@@ -342,6 +343,14 @@ export function isAbort(err) {
   return err?.name === 'AbortError' || err instanceof Anthropic.APIUserAbortError || /^(?:request was )?aborted\.?$/i.test(err?.message || '');
 }
 
+// USD for a request at the list prices (see pricing.js), by the model that answered, else the one asked for;
+// null when neither has a price. A cost goes to config.onCost.
+function charge(config, requested, served, usage) {
+  const cost = costOf(served, usage) ?? costOf(requested, usage);
+  if (cost > 0) config.onCost?.(cost);
+  return cost;
+}
+
 // Stream a message. `onEvent` receives:
 //   {type:'block_start', index, block}
 //   {type:'text', index, text}          text delta
@@ -354,7 +363,8 @@ export function isAbort(err) {
 //   {type:'rate_limit_resume', waitedMs}   the repeated request was accepted: the pause is over
 //   {type:'reset'}                      partial output from a failed attempt must be discarded
 // `waitForRateLimit: false` reports a rate limit as an error instead of waiting for it (side queries
-// where nobody wants to sit through a pause). Returns {message, usage, stopReason}.
+// where nobody wants to sit through a pause). Returns {message, usage, stopReason, model, cost, cache}.
+// What each request costs (an interrupted one too) goes to config.onCost, the conversation's running total.
 export async function streamMessage(config, request, { signal, onEvent = () => {}, waitForRateLimit = true } = {}) {
   if (signal?.aborted) throw Object.assign(new Error('aborted'), { name: 'AbortError', partial: [] });
   // A token that has expired (or is about to) is renewed first, as the official client does.
@@ -382,6 +392,10 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
   for (;;) {
     let emitted = false;
     const startedAt = Date.now(); // the cache TTL counts from the start of the request, not from the end of the reply
+    const blocks = [];
+    const jsonBufs = [];
+    let usage = {};
+    let model = params.model;
     try {
       const stream = await client.messages.create(params, options);
       if (paused) {
@@ -389,11 +403,7 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
         paused = null;
         onEvent({ type: 'rate_limit_resume', waitedMs: overloaded ? retryState.overloadedWaitMs : retryState.waitedMs, ...(overloaded ? { overloaded } : {}) });
       }
-      const blocks = [];
-      const jsonBufs = [];
-      let usage = {};
       let stopReason = null;
-      let model = params.model;
       let stopped = false;
       for await (const ev of stream) {
         switch (ev.type) {
@@ -457,9 +467,15 @@ export async function streamMessage(config, request, { signal, onEvent = () => {
         const key = cacheKey(config, params.model, login);
         cacheRefused.set(key, new Set([...(cacheRefused.get(key) || []), ...refused]));
       }
-      return { message: { role: 'assistant', content }, usage, stopReason, model, cache: { ...cachePlanOf(params), fingerprint: fingerprint(params), at: startedAt } };
+      const cost = charge(config, params.model, model, usage);
+      return { message: { role: 'assistant', content }, usage, stopReason, model, cost, cache: { ...cachePlanOf(params), fingerprint: fingerprint(params), at: startedAt } };
     } catch (raw) {
-      if (signal?.aborted || isAbort(raw)) throw Object.assign(new Error('aborted'), { name: 'AbortError', partial: raw?.partial || [] });
+      if (signal?.aborted || isAbort(raw)) {
+        // An interrupted reply is billed for what it had read and written: the output so far is estimated.
+        const written = blocks.reduce((n, b) => n + (b?.text?.length || 0) + (b?.thinking?.length || 0), 0) + jsonBufs.join('').length;
+        charge(config, params.model, model, { ...usage, output_tokens: Math.max(usage.output_tokens || 0, Math.ceil(written / 4)) });
+        throw Object.assign(new Error('aborted'), { name: 'AbortError', partial: raw?.partial || [] });
+      }
       const err = describeError(raw, config);
       // The token was refused. A running native Claude Code session may have renewed the shared token
       // while this request was in flight: read it again. If it is the same one, it may have been revoked

package/src/cache.js

@@ -80,6 +80,7 @@ export class CacheStats {
     this.ttl = '5m';
     this.model = null; // the model that answered the last request
     this.effort = null;
+    this.clockUntil = null; // the footer's prompt cache clock (see clock): null shows none
   }
 
   // The history was cut or replaced (compaction, /rewind, /resume): the next request will not find the old
@@ -88,6 +89,21 @@ export class CacheStats {
     this.expected = null;
   }
 
+  // A compaction replaced the conversation: none of it is in the cache until the next response.
+  noteCompacted() {
+    this.noteRewrite();
+    if (this.clockUntil != null) this.clockUntil = 0;
+  }
+
+  // The prompt cache clock of the footer, as in Claude Code's VS Code extension: the minutes left before what
+  // the last request left in the cache runs out (each response that used the cache starts it again), or cold
+  // once it has run out and right after a compaction, until the next response. null before any response
+  // reported cache use. A resumed conversation starts from the clockUntil its session file kept.
+  clock(now = Date.now()) {
+    if (this.clockUntil == null) return null;
+    return now < this.clockUntil ? { minutes: Math.ceil((this.clockUntil - now) / 60_000) } : { cold: true };
+  }
+
   // One finished request. `at` is when it started: the TTL counts from there, not from the end of the reply.
   record({ usage, fingerprint: fp = null, ttl = '5m', caching = true, at = Date.now() }) {
     const u = usage || {};
@@ -107,6 +123,7 @@ export class CacheStats {
     this.expected = caching ? read + write : null;
     this.expiresAt = at + TTL_MS[ttl];
     this.ttl = ttl;
+    if (caching && (read || write)) this.clockUntil = this.expiresAt;
     if (fp) {
       this.prev = fp;
       this.model = fp.model;

package/src/commands.js

@@ -463,6 +463,7 @@ export function buildCommands(app) {
       const b = a.subUsage;
       const cacheLines = a.cache.describe();
       out([
+        `Total cost:    ${formatUsd(app.cost)} ${c.dim('for this conversation, at list prices (sub-agents, compaction and side requests included)')}`,
         `Total input:   ${formatTokens(u.input + u.cacheRead + u.cacheWrite)} tokens ${c.dim(`(${formatTokens(u.cacheRead)} cache read, ${formatTokens(u.cacheWrite)} cache write${u.cacheWrite1h ? `, ${formatTokens(u.cacheWrite1h)} of it for 1 hour` : ''})`)}`,
         `Total output:  ${formatTokens(u.output)} tokens`,
         `API requests:  ${u.requests}${u.compactions ? c.dim(` + ${u.compactions} to compact the conversation`) : ''}`,
@@ -623,7 +624,7 @@ export function buildCommands(app) {
       reloadConfig();
       app.screen.setFull(want === 'fullscreen');
       out(want === 'fullscreen'
-        ? `Fullscreen: the input box stays at the bottom; scroll with the wheel, PgUp/PgDn, ctrl+Home/End. To select text, hold Shift while dragging. (Saved in ${file})`
+        ? `Fullscreen: the input box stays at the bottom; scroll with the wheel, PgUp/PgDn, ctrl+Home/End; drag to select and copy; ctrl+f to find in the conversation. (Saved in ${file})`
         : `Default renderer: the conversation scrolls in the terminal. (Saved in ${file})`);
     },
   });

package/src/pricing.js

@@ -0,0 +1,59 @@
+// What a request costs, in USD, for the running total of a conversation (the footer, /cost). The prices are the
+// official per-million-token ones the gateway bills at (its pricing.mjs); a gateway upstream group's multiplier
+// (1 unless the account is set otherwise) is not known here. A Claude model that is not in the table is priced
+// as the current model of its family, as the gateway serves it. longContext: a prompt (input + cache reads +
+// cache writes) above `threshold` tokens is billed at those prices.
+
+const PRICES = [
+  { id: 'claude-fable-5-1', family: 'fable', input: 10, output: 50, cacheWrite5m: 12.5, cacheWrite1h: 20, cacheRead: 0.25 },
+  { id: 'claude-opus-5-5', family: 'opus', input: 4, output: 20, cacheWrite5m: 5, cacheWrite1h: 8, cacheRead: 0.2 },
+  { id: 'claude-sonnet-5-5', family: 'sonnet', input: 2, output: 10, cacheWrite5m: 2.5, cacheWrite1h: 4, cacheRead: 0.1 },
+  {
+    id: 'claude-haiku-5-5', family: 'haiku', input: 0.1, output: 0.5, cacheWrite5m: 0.125, cacheWrite1h: 0.2, cacheRead: 0.01,
+    longContext: { threshold: 100_000, input: 0.5, output: 2.5, cacheWrite5m: 0.625, cacheWrite1h: 1, cacheRead: 0.05 },
+  },
+  {
+    id: 'gpt-6-astra', input: 10, output: 50, cacheRead: 1, cacheWrite5m: 12.5, cacheWrite1h: 12.5,
+    longContext: { threshold: 272_000, input: 20, output: 75, cacheWrite5m: 25, cacheWrite1h: 25, cacheRead: 2 },
+  },
+  {
+    id: 'gpt-6-1-sol', input: 2, output: 10, cacheRead: 0.1, cacheWrite5m: 2.5, cacheWrite1h: 2.5,
+    longContext: { threshold: 272_000, input: 4, output: 15, cacheWrite5m: 5, cacheWrite1h: 5, cacheRead: 0.2 },
+  },
+  {
+    id: 'gpt-6-luna', input: 0.1, output: 0.5, cacheRead: 0.01, cacheWrite5m: 0.125, cacheWrite1h: 0.125,
+    longContext: { threshold: 272_000, input: 0.2, output: 0.75, cacheWrite5m: 0.25, cacheWrite1h: 0.25, cacheRead: 0.02 },
+  },
+];
+
+// claude-opus-5-5, anthropic/claude-opus-5-5[1m], claude-haiku-5-5-20261001, gpt-6.1-sol:high -> the table's id form
+function cleanModel(model) {
+  const value = String(model || '').trim().toLowerCase();
+  return (value.includes('/') ? value.slice(value.lastIndexOf('/') + 1) : value)
+    .replace(/\[1m\]$/, '')
+    .replace(/[:@](none|minimal|low|medium|high|xhigh|max|ultra)$/, '')
+    .replace(/(\d)\.(\d)/g, '$1-$2')
+    .replace(/-\d{8}$/, '');
+}
+
+// The prices of a model, or null when it has none here (a model of another endpoint).
+export function priceOf(model) {
+  const id = cleanModel(model);
+  const exact = PRICES.find((p) => p.id === id);
+  if (exact) return exact;
+  const family = id.startsWith('claude-') && id.match(/\b(fable|opus|sonnet|haiku)\b/)?.[1];
+  return (family && PRICES.find((p) => p.family === family)) || null;
+}
+
+// USD for one request's usage as the API reports it; null for a model with no price.
+export function costOf(model, usage = {}) {
+  const price = priceOf(model);
+  if (!price) return null;
+  const n = (v) => Math.max(0, Number(v) || 0);
+  const input = n(usage.input_tokens);
+  const read = n(usage.cache_read_input_tokens);
+  const oneHour = n(usage.cache_creation?.ephemeral_1h_input_tokens);
+  const writes = Math.max(n(usage.cache_creation_input_tokens), n(usage.cache_creation?.ephemeral_5m_input_tokens) + oneHour);
+  const p = price.longContext && input + read + writes > price.longContext.threshold ? price.longContext : price;
+  return (input * p.input + n(usage.output_tokens) * p.output + read * p.cacheRead + (writes - oneHour) * p.cacheWrite5m + oneHour * p.cacheWrite1h) / 1e6;
+}

package/src/print.js

@@ -53,8 +53,16 @@ export async function runPrint({ prompt, flags, cwd, stdout = process.stdout, st
   };
   const runtime = await createRuntime({ cwd, flags, io });
   let store = new SessionStore(cwd);
+  let cost = 0; // what this run's requests cost (total_cost_usd)
+  let conversationCost = 0; // and the conversation's, kept with the session
+  runtime.config.onCost = (usd) => {
+    cost += usd;
+    conversationCost += usd;
+    store.setCost(conversationCost);
+  };
   if (flags.resumeFile) {
     const loaded = SessionStore.load(flags.resumeFile);
+    conversationCost = loaded.cost;
     runtime.agent.messages = loaded.messages;
     runtime.agent.restoreFileState(loaded.messages, loaded.times);
     runtime.agent.lastActivityAt = loaded.lastAt;
@@ -97,6 +105,7 @@ export async function runPrint({ prompt, flags, cwd, stdout = process.stdout, st
       session_id: store.id,
       duration_ms: Date.now() - started,
       num_turns: a.usage.requests,
+      total_cost_usd: Number(cost.toFixed(6)),
       usage: { input_tokens: used.input, output_tokens: used.output, cache_read_input_tokens: used.cacheRead, cache_creation_input_tokens: used.cacheWrite },
     });
   } else {

package/src/restart.js

@@ -2,6 +2,7 @@
 // process to the next, the check that the new code starts before it is trusted, and the watch on the
 // source files.
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
@@ -83,18 +84,34 @@ export function runSelfCheck({ root = INSTALL_DIR, signal, timeoutMs = 60_000 }
 
 // Watch the program's own source (src/ and bin/) and call `onChange(file)` once the files have stopped
 // changing for a moment. Returns {close()}. A platform that cannot watch just never calls back.
+// Only a change of content counts: Windows also reports a file whose last access time was updated, which
+// reading it does (at most once an hour: another window starting, npm packing it, a search).
 export function watchSource(root, onChange) {
   const watchers = [];
   let timer = null;
-  const hit = (_event, name) => {
-    if (name && !/\.(m?js|json)$/i.test(String(name))) return;
+  const SOURCE = /\.(m?js|json)$/i;
+  const digest = (file) => { try { return crypto.createHash('sha1').update(fs.readFileSync(file)).digest('base64'); } catch { return null; } };
+  const known = new Map(); // file -> digest of its content when last seen (null: not there)
+  for (const dir of ['src', 'bin']) {
+    let names = [];
+    try { names = fs.readdirSync(path.join(root, dir), { recursive: true }); } catch { /* not there */ }
+    for (const name of names) if (SOURCE.test(name)) known.set(path.join(root, dir, name), digest(path.join(root, dir, name)));
+  }
+  const hit = (dir) => (_event, name) => {
+    if (name && !SOURCE.test(String(name))) return;
+    if (name) {
+      const file = path.join(root, dir, String(name));
+      const now = digest(file);
+      if (now === (known.get(file) ?? null)) return;
+      known.set(file, now);
+    }
     clearTimeout(timer);
     timer = setTimeout(() => { try { onChange(String(name || '')); } catch { /* the callback's problem */ } }, 400);
     timer.unref?.();
   };
   for (const dir of ['src', 'bin']) {
     try {
-      const watcher = fs.watch(path.join(root, dir), { recursive: true, persistent: false }, hit);
+      const watcher = fs.watch(path.join(root, dir), { recursive: true, persistent: false }, hit(dir));
       watcher.on('error', () => { /* a directory that vanished, a watch limit: not worth a crash */ });
       watchers.push(watcher);
     } catch { /* not supported here */ }

package/src/session.js

@@ -77,6 +77,15 @@ export class SessionStore {
   // The name the user gave the conversation with /rename (null: none again); it wins over the topic.
   setName(name) { this.append({ type: 'meta', name, at: Date.now() }); }
   reset(messages) { this.append({ type: 'reset', messages, at: Date.now() }); }
+  // What the conversation's requests have cost so far (USD, see pricing.js), written after each one; the newest wins.
+  setCost(usd) { this.append({ type: 'meta', cost: usd, at: Date.now() }); }
+  // Until when the conversation's prompt cache lasts (ms since epoch; 0: cold), for the footer's clock of a
+  // resumed conversation (see CacheStats.clock). Written after each of its requests and compactions.
+  setCacheUntil(until) {
+    if (until == null || until === this.cacheUntil) return;
+    this.cacheUntil = until;
+    this.append({ type: 'meta', cacheUntil: until, at: Date.now() });
+  }
   // The system prompt this conversation runs behind, kept so that a resumed one continues behind the same prompt
   // and so with the prompt cache it already has (see runtime.resumeSystemPrompt). Written when it first appears
   // and whenever it changes (after a compaction); the newest one wins when the session is loaded.
@@ -114,6 +123,8 @@ export class SessionStore {
       topic: typeof meta.topic === 'string' && meta.topic.trim() ? meta.topic : null,
       name: typeof meta.name === 'string' && meta.name.trim() ? meta.name : null,
       systemPrompt: typeof meta.systemPrompt === 'string' && meta.systemPrompt.trim() ? meta.systemPrompt : null,
+      cost: Number(meta.cost) > 0 ? Number(meta.cost) : 0,
+      cacheUntil: Number.isFinite(meta.cacheUntil) && meta.cacheUntil >= 0 ? meta.cacheUntil : null,
     };
   }
 

package/src/ui/ansi.js

@@ -51,6 +51,8 @@ export const c = {
   plan: hex('#48968c'),
   edits: hex('#af87ff'),
   code: hex('#b1b9f9'),
+  userBg: hex('#373737', true), // the band behind the user's messages (see renderUserMessage)
+  userText: hex('#e4e4e4'),
   diffAdd: hex('#225c2b', true),
   diffDel: hex('#7a2936', true),
   diffAddWord: hex('#38a660', true),

package/src/ui/render.js

@@ -1,6 +1,6 @@
 // Formatting of transcript items: user prompts, tool calls and results, diffs, todos.
 
-import { c, stringWidth, truncate, padEnd, wordWrap, wrapLine } from './ansi.js';
+import { c, colorEnabled, stringWidth, truncate, padEnd, wordWrap, wrapLine } from './ansi.js';
 import { displayPath } from '../utils/paths.js';
 import { renderMarkdown } from './markdown.js';
 
@@ -129,14 +129,19 @@ export function renderToolResult(entry, { verbose = false, width = 100, cwd }) {
   return resultLines(shown);
 }
 
+// What the user wrote, on a band of background colour across the window, so that it stands apart from the replies
+// (as in Claude Code). The band is the rest of each row erased in that colour (\x1b[K), which needs no padding and
+// so fits any width the window is given later.
+const userRow = (s) => (colorEnabled ? c.userBg(s + '\x1b[K') : s);
+
 export function renderUserMessage(text, width) {
   const lines = text.replace(/\r\n/g, '\n').split('\n');
   const out = [];
   lines.forEach((l, i) => {
     const wrapped = wordWrap(l, Math.max(10, width - 3));
-    wrapped.forEach((wl, j) => out.push((i === 0 && j === 0 ? c.gray('> ') : '  ') + c.gray(wl)));
+    wrapped.forEach((wl, j) => out.push(userRow((i === 0 && j === 0 ? c.gray('> ') : '  ') + c.userText(wl))));
   });
-  if (out.length > 30) return [...out.slice(0, 25), c.dim(`  … +${out.length - 25} lines`)];
+  if (out.length > 30) return [...out.slice(0, 25), userRow(c.gray(`  … +${out.length - 25} lines`))];
   return out;
 }
 

package/src/ui/repl.js

@@ -8,7 +8,7 @@ import readline from 'node:readline';
 import { spawn } from 'node:child_process';
 import { c, ESC, stringWidth, truncate, padEnd, wordWrap, colorEnabled } from './ansi.js';
 import { Screen, queryCursorRow, mouseFilter } from './screen.js';
-import { Editor } from './editor.js';
+import { Editor, topBorder } from './editor.js';
 import { SelectDialog } from './dialogs.js';
 import { MarkdownStream, renderMarkdown } from './markdown.js';
 import {
@@ -18,7 +18,7 @@ import { createRuntime } from '../runtime.js';
 import { SessionStore, firstUserText } from '../session.js';
 import { defaultEffort, effortSupported, effortToSend, quickQuery } from '../api.js';
 import { CONFIG_DIR, VERSION, APP_NAME, INSTALL_DIR } from '../config.js';
-import { readGatewayLogin } from '../gateway.js';
+import { readGatewayLogin, formatUsd } from '../gateway.js';
 import { TOPIC_TITLE_SYSTEM, topicTitlePrompt } from '../prompts.js';
 import { buildCommands } from '../commands.js';
 import { canRestart, writeRestartState, runSelfCheck, watchSource, restartNote, RESTART_EXIT_CODE, MAX_RESTARTS, RESTART_WINDOW_MS } from '../restart.js';
@@ -31,7 +31,7 @@ import { readClipboardImage, imageFromFile, watchClipboard, writeClipboard, read
 import { fitImagesIn } from '../utils/images.js';
 import { downloadsDir, filesToSend, formatBytes } from '../utils/downloads.js';
 import { copyUnique } from '../transfer.js';
-import { checkForUpdate, installUpdate, installedVersion, isNewer, CHECK_EVERY_MS } from '../updater.js';
+import { checkForUpdate, installUpdate, installedVersion, installedByNpm, isNewer, CHECK_EVERY_MS } from '../updater.js';
 import { PeerNode, peersEnabled, findPeer, resolvePeer, machineName, cleanName, peerMessagePrompt } from '../peers.js';
 import { RemoteControl, transcriptItems, onlineEnabled, REMOTE_WIDTH } from '../remote.js';
 import { qrLines } from '../qr.js';
@@ -196,6 +196,7 @@ export class App {
     this.remotePeersTimer = null;
     this.transfers = new Map(); // files on their way to or from other sessions, for the footer
     this.transferSeq = 0;
+    this.cost = 0; // what this conversation's requests have cost so far (USD at list prices): the footer and /cost
     this.fileIndex = new FileIndex(cwd, () => this.runtime?.config);
     this.store = new SessionStore(cwd);
     // What the terminal prints goes to the remote page too, except what it is told about as events.
@@ -245,6 +246,12 @@ export class App {
     this.runtime = await createRuntime({ cwd: this.cwd, flags: this.flags, io: this });
     // The conversation's id, sent to the gateway with each request (see streamMessage); it follows /clear and /resume.
     Object.defineProperty(this.runtime.config, 'sessionId', { get: () => this.store.id, configurable: true });
+    // Every request's cost (the conversation's, its sub-agents', side queries'), kept with the session.
+    this.runtime.config.onCost = (usd) => {
+      this.cost += usd;
+      this.store.setCost(this.cost);
+      this.screen.schedule();
+    };
     this.commands = buildCommands(this);
     if (pinOff(this.config.env.CLAUDE_PRO_PIN_INPUT)) { this.screen.pin = false; this.screen.pinned = null; }
     // What the session showed before a restart: scrolled back to in fullscreen, repainted after a resize otherwise.
@@ -275,7 +282,11 @@ export class App {
     this.autoStartRemote(restart);
 
     this.screen.setLive((w) => this.renderLive(w));
-    this.spinnerTimer = setInterval(() => { if (this.busy || this.active.length) this.screen.schedule(); }, 120);
+    this.spinnerTimer = setInterval(() => {
+      const clock = this.cacheClock(); // the footer's clock counts down while nothing else is drawn
+      if (this.busy || this.active.length || clock !== this.shownClock) this.screen.schedule();
+      this.shownClock = clock;
+    }, 120);
     if (restart) this.continueAfterRestart(restart);
     else if (initialPrompt?.trim()) this.onSubmit(initialPrompt, initialPrompt);
     // Nothing configured yet: the gateway is the default, and its login comes first, as in Claude Code.
@@ -992,9 +1003,10 @@ export class App {
     if (!canRestart() || /^(0|false|no|off)$/i.test(this.config.env.CLAUDE_PRO_AUTO_RESTART || '')) return;
     this.sourceWatch = watchSource(INSTALL_DIR, (file) => {
       this.sourceChanged = file || true;
-      // another window (or npm) installed a new version: say so, and load it once this session is idle
+      // another window (or npm) installed a new version: say so, and load it once this session is idle. In a
+      // source checkout a newer version in package.json is a release being made, not an install.
       const disk = installedVersion();
-      if (disk !== VERSION && isNewer(disk, VERSION) && this.updateRestart !== disk) {
+      if (installedByNpm() && disk !== VERSION && isNewer(disk, VERSION) && this.updateRestart !== disk) {
         this.updateRestart = disk;
         this.pendingUpdate = null;
         this.notice(`${APP_NAME} ${disk} was installed (by another window or npm); this one restarts to load it ${this.working() ? 'once its work is done' : 'now'}.`);
@@ -1208,6 +1220,13 @@ export class App {
       if (key.name === 'pagedown') { this.screen.scrollBy(-half); return; }
       if (key.ctrl && key.name === 'home') { this.screen.scrollBy('top'); return; }
       if (key.ctrl && key.name === 'end') { this.screen.scrollBy('bottom'); return; }
+      // ctrl+f looks for what is selected, if anything
+      if (key.ctrl && key.name === 'f' && !this.dialogs.length) {
+        const seed = this.screen.selection ? this.screen.selectedText() : '';
+        this.screen.clearSelection();
+        this.openFind(seed);
+        return;
+      }
       // A selection: ctrl+c copies it (and does not interrupt), esc only clears it, any other key clears it and
       // then does what it does.
       if (this.screen.selection) {
@@ -1216,6 +1235,7 @@ export class App {
         if (key.name === 'escape') return;
       }
     }
+    if (key.ctrl && key.name === 'c' && this.finder && !this.dialogs.length) { this.closeFind(); return; } // not the hidden input's text
     if (key.ctrl && key.name === 'c') { this.onCtrlC(); return; }
     const dialog = this.dialogs[0];
     if (dialog) {
@@ -1223,6 +1243,8 @@ export class App {
       this.screen.schedule();
       return;
     }
+    if (key.ctrl && key.name === 'f') { this.openFind(); return; }
+    if (this.finder) { this.findKey(str, key); this.screen.schedule(); return; }
     if (key.name === 'tab' && key.shift) { this.runtime.modes.toggle(); this.screen.schedule(); return; }
     // alt+v like Claude Code on Windows (ctrl+v is the terminal's own text paste there).
     if ((key.meta || key.ctrl) && key.name === 'v') { this.pasteImage(); return; }
@@ -1378,11 +1400,102 @@ export class App {
       ['PgUp/PgDn, wheel to scroll', 'ctrl + home/end to the top/bottom'],
       ['# to memorize', 'ctrl + t to toggle todos'],
       ['\\⏎ or alt+⏎ for newline', 'ctrl + l to redraw, ctrl + d to exit'],
-      ['alt + v to paste an image', ''],
+      ['alt + v to paste an image', 'ctrl + f to find in the conversation'],
     ];
     return rows.map(([a, b]) => c.dim('  ' + padEnd(a, 30) + b));
   }
 
+  // ---------------------------------------------------------------- finding in the conversation (ctrl+f)
+  //
+  // As in VS Code: a box takes the input box's place, the conversation shows the matches as they are typed, the
+  // current one apart, and goes to it. In a conversation the newest matter most: the first one shown is the
+  // nearest above the bottom of the view, enter (or ↑) goes on to older ones, shift+enter (or ↓) back to newer
+  // ones, round from either end. Esc closes the box and leaves the view where it is. The text typed last comes
+  // back selected (typing replaces it), or what is selected with the mouse. Fullscreen only: in the classic
+  // renderer the conversation is in the terminal's own scrollback.
+
+  openFind(seed = '') {
+    if (!this.screen.full) { this.flash('ctrl+f finds in the conversation in fullscreen (/tui); here use the terminal\'s own find', 'warn'); return; }
+    if (this.finder && !seed.trim()) { this.finder.selected = Boolean(this.finder.text); this.screen.schedule(); return; } // open: select what is typed
+    const text = (seed.split('\n').find((l) => l.trim()) || '').trim() || this.lastFind || '';
+    if (!this.finder) this.screen.openFind();
+    this.finder = { text, cursor: text.length, selected: Boolean(text), pasting: null };
+    this.screen.setFind(text);
+    this.screen.schedule();
+  }
+
+  closeFind() {
+    if (!this.finder) return;
+    this.lastFind = this.finder.text;
+    this.finder = null;
+    this.screen.closeFind();
+    this.screen.schedule();
+  }
+
+  findKey(str, key) {
+    const f = this.finder;
+    const name = key.name;
+    const edit = (text, cursor) => {
+      Object.assign(f, { text, cursor, selected: false });
+      this.screen.setFind(text);
+    };
+    const insert = (s) => {
+      const t = s.replace(/[\r\n\t]+/g, ' ');
+      if (!t) return;
+      if (f.selected) edit(t, t.length);
+      else edit(f.text.slice(0, f.cursor) + t + f.text.slice(f.cursor), f.cursor + t.length);
+    };
+    if (name === 'paste-start') { f.pasting = ''; return; }
+    if (f.pasting !== null) {
+      if (name === 'paste-end') { const t = f.pasting.split(/\r?\n/).find((l) => l.trim()) || ''; f.pasting = null; insert(t.trim()); }
+      else if (name === 'return' || name === 'enter') f.pasting += '\n';
+      else if (str) f.pasting += str;
+      return;
+    }
+    if (name === 'escape') { this.closeFind(); return; }
+    const back = (name === 'return' && (key.meta || key.shift)) || name === 'enter' || key.sequence === '\x1b[13;2u' || (name === 'f3' && key.shift);
+    if (back || name === 'down' || (key.ctrl && name === 'n')) { f.selected = false; this.screen.findStep(-1); return; }
+    if (name === 'return' || name === 'f3' || name === 'up' || (key.ctrl && name === 'p')) { f.selected = false; this.screen.findStep(1); return; }
+    const chars = [...f.text.slice(0, f.cursor)];
+    if (name === 'backspace') {
+      if (f.selected) edit('', 0);
+      else if (chars.length) { const keep = chars.slice(0, -1).join(''); edit(keep + f.text.slice(f.cursor), keep.length); }
+      return;
+    }
+    if (name === 'delete') {
+      if (f.selected) edit('', 0);
+      else if (f.cursor < f.text.length) { const next = [...f.text.slice(f.cursor)].slice(1).join(''); edit(f.text.slice(0, f.cursor) + next, f.cursor); }
+      return;
+    }
+    if (key.ctrl && name === 'u') { edit('', 0); return; }
+    if (name === 'left') { f.selected = false; f.cursor = chars.slice(0, -1).join('').length; return; }
+    if (name === 'right') { f.selected = false; f.cursor = Math.min(f.text.length, f.cursor + ([...f.text.slice(f.cursor)][0]?.length || 0)); return; }
+    if (name === 'home' || (key.ctrl && name === 'a')) { f.selected = false; f.cursor = 0; return; }
+    if (name === 'end' || (key.ctrl && name === 'e')) { f.selected = false; f.cursor = f.text.length; return; }
+    if (str && !key.ctrl && !key.meta && !/[\x00-\x1f\x7f]/.test(str)) insert(str);
+  }
+
+  // The find box, in the input box's place: what is typed (selected: in reverse video), and how many matches.
+  renderFind(width) {
+    const f = this.finder;
+    const boxW = Math.max(20, width - 1);
+    const textW = boxW - 6;
+    const s = this.screen.findStatus();
+    const count = !f.text ? '' : s?.total ? `${s.index + 1}/${s.total}` : c.red('No results');
+    const title = { left: 'Find in the conversation', right: count };
+    // the part of the text that fits, the cursor in it
+    let before = f.text.slice(0, f.cursor);
+    while (before && stringWidth(before) > textW - 1) before = [...before].slice(1).join('');
+    const shown = truncate(before + f.text.slice(f.cursor), textW, '');
+    const content = f.selected && shown ? c.inverse(shown) : shown;
+    const lines = [
+      topBorder(boxW, c.yellow, title),
+      c.yellow('│') + ' ' + c.yellow('⌕') + ' ' + padEnd(content, textW) + ' ' + c.yellow('│'),
+      c.yellow('╰' + '─'.repeat(boxW - 2) + '╯'),
+    ];
+    return { lines, cursor: { row: 1, col: 4 + stringWidth(before) } };
+  }
+
   // ---------------------------------------------------------------- turns
 
   // Where a mentioned path is (null when there is no such file): relative to the project root, which is
@@ -1674,6 +1787,8 @@ export class App {
       this.remote?.register().catch(() => {});
     }
     this.firstPrompt = loaded.title;
+    this.cost = loaded.cost;
+    this.agent.cache.clockUntil = this.store.cacheUntil = loaded.cacheUntil;
     this.agent.messages = loaded.messages;
     this.agent.restoreFileState(loaded.messages, loaded.times);
     this.agent.lastActivityAt = loaded.lastAt; // a long pause before this turn clears old tool results, as it would have
@@ -1711,6 +1826,7 @@ export class App {
     this.topic = null;
     this.customTitle = null;
     this.firstPrompt = null;
+    this.cost = 0;
     this.remote?.resync();
   }
 
@@ -1987,7 +2103,10 @@ export class App {
   messageAdded(msg, agent) { if (this.isMain(agent)) this.store.message(msg); }
   systemPrompt(text, agent) { if (this.isMain(agent)) this.store.setSystemPrompt(text); }
   messagesReplaced(msgs, agent) { if (this.isMain(agent)) this.store.reset(msgs); }
-  usage() { this.screen.schedule(); }
+  usage(_u, agent) {
+    if (this.isMain(agent)) this.store.setCacheUntil(agent.cache.clockUntil); // the clock of a resumed conversation
+    this.screen.schedule();
+  }
 
   compactStart(auto, agent) {
     if (!this.isMain(agent)) return;
@@ -2008,6 +2127,7 @@ export class App {
     this.status = null;
     if (err) return;
     this.lastSummary = summary;
+    this.store.setCacheUntil(agent.cache.clockUntil);
     const what = part === 'before' ? 'The earlier part of the conversation was summarized' : part === 'after' ? 'The conversation from that message on was summarized' : 'Conversation compacted';
     this.screen.log(c.dim(`✻ ${what} (the summary is in context; /context to see usage)`), '');
   }
@@ -2120,11 +2240,12 @@ export class App {
     }
     if (lines.length) lines.push('');
     const placeholder = this.busy ? 'Type a message to queue it for the agent…' : (this.agent.messages.length ? '' : 'Try "explain this codebase" or "fix the failing test"');
-    const r = this.editor.render(width, { placeholder, title: this.boxTitle() });
+    const r = this.finder ? this.renderFind(width) : this.editor.render(width, { placeholder, title: this.boxTitle() });
     const top = lines.length;
     lines.push(...r.lines);
     if (r.cursor) cursor = { row: top + r.cursor.row, col: r.cursor.col };
-    if (this.editor.suggestions) lines.push(...this.editor.renderSuggestions(w));
+    if (this.finder) lines.push(c.dim(truncate('  ⏎ or ↑ older · shift+⏎ or ↓ newer · PgUp/PgDn scroll · esc to close', w)));
+    else if (this.editor.suggestions) lines.push(...this.editor.renderSuggestions(w));
     else if (this.editor.text === '?') lines.push(...this.shortcutsHelp());
     else lines.push(this.footer(w));
     return { lines, cursor };
@@ -2140,6 +2261,15 @@ export class App {
     return { left: shown.replace(/\\/g, '/'), right: name && this.remote?.online ? `⇄ ${name}` : name };
   }
 
+  // The prompt cache clock, as in Claude Code's VS Code extension: the minutes the conversation's cache has left
+  // ("◷ 12m"), or the icon alone in red once it has run out or right after a compaction, until the next response:
+  // the next message then writes the whole conversation to the cache again. Nothing before a response reported
+  // cache use.
+  cacheClock() {
+    const clock = this.agent?.cache.clock();
+    return !clock ? '' : clock.cold ? c.red('◷') : c.dim(`◷ ${clock.minutes}m`);
+  }
+
   footer(w) {
     const mode = this.runtime.modes.mode;
     let left;
@@ -2174,8 +2304,13 @@ export class App {
     // An effort that is not set is not sent: the API then uses the model's default, which is shown instead.
     const level = effort || defaultEffort(cfg.mainModel.id, cfg);
     const info = c.dim(level ? `${model} · effort ${level}` : model);
+    // Before the model: the prompt cache clock, then what the conversation has cost so far; when room is short
+    // the cost goes first, then the clock.
+    const spent = this.cost > 0 ? c.dim(formatUsd(this.cost)) : '';
+    const clock = this.cacheClock();
+    const join = (...parts) => parts.filter(Boolean).join(c.dim(' · '));
     const room = w - stringWidth(left) - 1;
-    const right = [notice && info ? `${notice}${c.dim(' · ')}${info}` : '', notice, info].find((r) => r && stringWidth(r) < room) || '';
+    const right = [join(notice, clock, spent, info), join(notice, clock, info), join(notice, info), notice, info].find((r) => r && stringWidth(r) < room) || '';
     const gap = room - stringWidth(right);
     return right ? left + ' '.repeat(gap) + right : left;
   }

package/src/ui/screen.js

@@ -43,6 +43,10 @@ const FULL_KEEP = 20_000; // fullscreen: lines of the conversation kept to scrol
 const ALT_ON = '\x1b[?1049h\x1b[?1002h\x1b[?1006h';
 const ALT_OFF = '\x1b[?1002l\x1b[?1006l\x1b[?1049l';
 const MULTI_CLICK_MS = 450;
+// A search (ctrl+f): the matches, the current one, and how many are looked for at most.
+const FIND_MATCH = '\x1b[30;43m';
+const FIND_CURRENT = '\x1b[30;48;5;208m';
+const FIND_MAX = 10_000;
 
 // The part of `plain` (no escape codes) between columns `from` (included) and `to` (not).
 function sliceCols(plain, from, to) {
@@ -146,6 +150,8 @@ export class Screen {
     this.lastArea = 0; // fullscreen: rows the conversation had on screen at the last draw
     this.viewMap = []; // fullscreen: what each row of the conversation area shows, {line, sub} (null: blank)
     this.barRow = null; // fullscreen: the row of the "Jump to bottom" bar, when it is shown
+    this.finding = null; // fullscreen: a search in the conversation (ctrl+f), see openFind
+    this.dropped = 0; // fullscreen: lines dropped from the top of the history so far (the first one's number)
     this.selection = null; // fullscreen: {anchor, focus}, points {line, sub, col} of the conversation (history line, wrapped row, column)
     this.dragging = false;
     this.lastClick = { at: 0, x: 0, y: 0, count: 0 };
@@ -270,11 +276,163 @@ export class Screen {
     return to > from ? [from, to] : null;
   }
 
+  // A row of the conversation as drawn: the selection in reverse video, the matches of a search highlighted (the
+  // current one apart). Such a row loses its own colours.
   paintRow(e) {
-    const cols = this.selectedCols(e);
-    if (!cols) return e.text;
-    const plain = stripAnsi(e.text);
-    return sliceCols(plain, 0, cols[0]) + '\x1b[7m' + sliceCols(plain, cols[0], cols[1]) + '\x1b[27m' + sliceCols(plain, cols[1], Infinity);
+    const sel = this.selectedCols(e);
+    const hits = this.finding?.byRow.get(`${e.line}:${e.sub}`);
+    if (!sel && !hits) return e.text;
+    const style = (col) => {
+      if (sel && col >= sel[0] && col < sel[1]) return '\x1b[7m';
+      const hit = hits?.find((h) => col >= h.from && col < h.to);
+      return !hit ? '' : hit.match === this.finding.matches[this.finding.index] ? FIND_CURRENT : FIND_MATCH;
+    };
+    let out = '';
+    let open = '';
+    let col = 0;
+    for (const g of graphemes(stripAnsi(e.text))) {
+      const s = style(col);
+      if (s !== open) { out += '\x1b[0m' + s; open = s; }
+      out += g;
+      col += graphemeWidth(g);
+    }
+    return out + (open ? '\x1b[0m' : '');
+  }
+
+  // ------------------------------------------------------------ finding text (fullscreen, ctrl+f)
+  //
+  // `finding`: {query, matches, byRow, index, anchor, key}. Matches are newest first (from the bottom of the
+  // conversation up): {abs, offset, line, sub, col, fromEnd}, `abs` the line counted from the first line ever
+  // printed (so that it survives lines dropped from the top), `offset` where it starts in the line's text, and
+  // `fromEnd` the rows from its first row to the end of the conversation. `byRow` maps "line:sub" to the column
+  // ranges to highlight, {from, to, match}. A match may go on over the rows a long line was wrapped onto.
+
+  // Start finding: the first match shown is the nearest one above the bottom of the view as it is now.
+  openFind() {
+    this.takeStatic();
+    this.finding = { query: '', matches: [], byRow: new Map(), index: -1, anchor: this.scroll, cols: 0, dropped: -1, scanned: -1 };
+  }
+
+  closeFind() {
+    if (!this.finding) return;
+    this.finding = null;
+    this.draw();
+  }
+
+  // Look for `query` as typed, in any case; shows the first match (see openFind). {index, total}: index is 0 for
+  // the newest match.
+  setFind(query) {
+    const f = this.finding;
+    if (!f) return null;
+    f.query = query;
+    f.cols = 0; // all of it again
+    f.index = -1;
+    this.refreshFind();
+    if (f.matches.length) {
+      const at = f.matches.findIndex((m) => m.fromEnd >= f.anchor);
+      f.index = at >= 0 ? at : f.matches.length - 1;
+      this.revealMatch();
+    }
+    this.draw();
+    return this.findStatus();
+  }
+
+  // The next match up (`dir` 1: older) or down (-1: newer), round from either end.
+  findStep(dir) {
+    const f = this.finding;
+    if (!f) return null;
+    this.refreshFind();
+    const n = f.matches.length;
+    if (n) {
+      f.index = ((f.index < 0 ? 0 : f.index + dir) % n + n) % n;
+      this.revealMatch();
+    }
+    this.draw();
+    return this.findStatus();
+  }
+
+  findStatus() {
+    const f = this.finding;
+    if (!f) return null;
+    this.refreshFind();
+    return { query: f.query, index: f.index, total: f.matches.length };
+  }
+
+  // The matches again when the conversation or the width changed since they were found; the current one stays.
+  // Lines added at the end (output while the search is open) are searched on their own.
+  refreshFind() {
+    const f = this.finding;
+    const cols = this.width;
+    if (!f || (f.cols === cols && f.dropped === this.dropped && f.scanned === this.history.length)) return;
+    if (!f.query) {
+      Object.assign(f, { matches: [], byRow: new Map(), index: -1, cols, dropped: this.dropped, scanned: this.history.length });
+      return;
+    }
+    if (f.cols === cols && f.dropped === this.dropped && f.scanned < this.history.length) {
+      const added = this.scanFind(f, f.scanned, this.history.length, cols);
+      for (const m of f.matches) m.fromEnd += added.rows;
+      f.matches = [...added.matches, ...f.matches];
+      if (f.index >= 0) f.index += added.matches.length;
+      f.scanned = this.history.length;
+      return;
+    }
+    const current = f.matches[f.index];
+    f.byRow = new Map();
+    f.matches = this.scanFind(f, 0, this.history.length, cols).matches;
+    Object.assign(f, { cols, dropped: this.dropped, scanned: this.history.length });
+    const same = current ? f.matches.findIndex((m) => m.abs === current.abs && m.offset === current.offset) : -1;
+    f.index = same >= 0 ? same : Math.min(f.index, f.matches.length - 1);
+  }
+
+  // The matches of f.query in history lines [from, to), newest first, entered in f.byRow; `rows`: the rows those
+  // lines take (fromEnd counts from the end of line to - 1).
+  scanFind(f, from, to, cols) {
+    const re = new RegExp(f.query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'giu');
+    const matches = [];
+    let rowsAfter = 0;
+    for (let line = to - 1; line >= from; line--) {
+      const rows = this.wrappedAt(line, cols);
+      if (matches.length < FIND_MAX) {
+        const plains = rows.map((r) => stripAnsi(r));
+        const text = plains.join('');
+        const starts = [];
+        for (let k = 0, at = 0; k < plains.length; at += plains[k].length, k++) starts.push(at);
+        // offset -> {sub, col}: the row it falls on, and the column there (`end`: an end offset belongs to the row before)
+        const place = (offset, end = false) => {
+          let sub = plains.length - 1;
+          while (sub > 0 && (end ? starts[sub] >= offset : starts[sub] > offset)) sub--;
+          return { sub, col: stringWidth(plains[sub].slice(0, offset - starts[sub])) };
+        };
+        const found = [];
+        for (const m of text.matchAll(re)) {
+          if (!m[0]) continue;
+          const a = place(m.index);
+          const b = place(m.index + m[0].length, true);
+          const match = { abs: this.dropped + line, offset: m.index, line, sub: a.sub, col: a.col, fromEnd: rowsAfter + rows.length - 1 - a.sub };
+          for (let sub = a.sub; sub <= b.sub; sub++) {
+            const k = `${line}:${sub}`;
+            if (!f.byRow.has(k)) f.byRow.set(k, []);
+            f.byRow.get(k).push({ from: sub === a.sub ? a.col : 0, to: sub === b.sub ? b.col : Infinity, match });
+          }
+          found.push(match);
+        }
+        matches.push(...found.reverse());
+      }
+      rowsAfter += rows.length;
+    }
+    return { matches, rows: rowsAfter };
+  }
+
+  // Scroll so that the current match is on screen: where it is if it is already in view, else in the middle.
+  revealMatch() {
+    const m = this.finding?.matches[this.finding.index];
+    if (!m || !this.full) return;
+    const area = Math.max(1, this.lastArea || this.height - 6);
+    const lowest = this.scroll + (this.scroll > 0 ? 1 : 0); // the "Jump to bottom" bar covers the last row
+    if (m.fromEnd >= lowest && m.fromEnd < this.scroll + area) return;
+    const max = Math.max(0, this.totalRows(this.width) - area);
+    this.scroll = Math.max(0, Math.min(max, m.fromEnd - Math.floor(area / 2)));
+    if (!this.scroll) this.unseen = 0;
   }
 
   // The text selected, as it was printed: rows a long line was wrapped onto are joined again.
@@ -407,6 +565,7 @@ export class Screen {
     const layout = this.layoutLive(cols);
     const area = Math.max(0, screenRows - layout.rows.length);
     this.lastArea = area;
+    if (this.finding) this.refreshFind();
     const shown = this.view(area, cols);
     this.viewMap = shown;
     const top = shown.map((e) => (e ? this.paintRow(e) : ''));
@@ -474,6 +633,7 @@ export class Screen {
       const drop = this.history.length - keep;
       this.history.splice(0, drop);
       this.wrapped.splice(0, drop);
+      this.dropped += drop;
       if (this.selection) {
         for (const p of [this.selection.anchor, this.selection.focus]) p.line -= drop;
         if (this.selection.anchor.line < 0 || this.selection.focus.line < 0) this.selection = null;
@@ -630,6 +790,7 @@ export class Screen {
 
   clearScreen() {
     if (this.full) {
+      this.dropped += this.history.length;
       this.history = [];
       this.wrapped = [];
       this.selection = null;