@yanzc/claude-pro 0.5.6 → 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）或该模型不支持时只显示模型；窄窗口放不下时先让位给"上下文快满"等提示，再不行就不显示。模型前面是**当前对话累计花费**（如 `$1.23 · opus-5-5 · effort high`）：按官方价（和网关扣费同一张价目表，含 5 分钟/1 小时缓存写入、长上下文价）把每个请求算进去，子 agent、压缩、话题标题、WebFetch 都算，按 Esc 中断的请求按已读入的输入和估算的已输出部分算；记在会话文件里，重启、`/resume` 后接着累计，`/clear` 从零开始。`/cost` 第一行也显示它，`-p --output-format json` 的结果带本次运行的 `total_cost_usd`。不认识价格的模型（第三方端点的自定义模型）不计；网关上游分组倍率不是 1 的账户以网关流水为准。
+- **用户的提问**：带一条深灰色背景（横跨整个窗口宽度），和回复一眼就能分开。背景条是用当前背景色清除行尾（`\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.6",
+  "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/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

@@ -624,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/session.js

@@ -79,6 +79,13 @@ export class SessionStore {
   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.
@@ -117,6 +124,7 @@ export class SessionStore {
       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 {
@@ -282,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.
@@ -1216,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) {
@@ -1224,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) {
@@ -1231,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; }
@@ -1386,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
@@ -1683,6 +1788,7 @@ export class App {
     }
     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
@@ -1997,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;
@@ -2018,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)`), '');
   }
@@ -2130,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 };
@@ -2150,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;
@@ -2184,11 +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);
-    // What the conversation has cost so far goes before the model, and is the first to go when room is short.
+    // 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 = [join(notice, spent, info), join(notice, 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;