@yanzc/claude-pro 0.5.4 → 0.5.6

package/README.md

@@ -161,7 +161,7 @@ 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）或该模型不支持时只显示模型；窄窗口放不下时先让位给"上下文快满"等提示，再不行就不显示。
+- **页脚**：输入框下方右侧常驻当前模型和 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 的账户以网关流水为准。
 - **缩放窗口**：拖动期间不重绘，停下约 80ms 后从左上角整屏绝对重绘一次，输入框不会再留下残影。注意：很短的会话里这次重绘会覆盖终端上方 shell 的内容。
 
 ## 自动重启：改了自己的代码马上生效

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "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

@@ -7,7 +7,7 @@ import { streamMessage, contextTokens, isAbort } from './api.js';
 import { compactPrompt, partialCompactPrompt, partialSummaryMessage, continuationMessage, PLAN_MODE_REMINDER, SUMMARY_SYSTEM } from './prompts.js';
 import { toolResultsDir } from './session.js';
 import { rebuildFileState } from './filestate.js';
-import { CacheStats } from './cache.js';
+import { CacheStats, TTL_MS } from './cache.js';
 import { resolvePath } from './utils/paths.js';
 import { fitImagesIn } from './utils/images.js';
 
@@ -359,6 +359,14 @@ export class Agent {
     return out;
   }
 
+  // Is the conversation's prompt cache known to have run out? From the last request of this process when there was
+  // one, else (a resumed or restarted conversation) from when the last message was added, which is after its
+  // request started: that guess errs towards warm. Not knowing counts as warm.
+  cacheExpired(now = Date.now()) {
+    if (this.cache.expected != null) return now >= this.cache.expiresAt;
+    return this.lastActivityAt > 0 && now - this.lastActivityAt >= TTL_MS[this.config.cacheTtl('main')];
+  }
+
   // A new request from the user goes back to the effort the user chose, after the Effort tool changed it for
   // the one before. A request that a restart continues keeps it.
   endEffortBoost() {
@@ -728,8 +736,12 @@ export class Agent {
   // the biggest request there is). Only if that does not give a summary (the model went on calling tools, or
   // the request is too long by the size of the instruction) the plainer request is made: a short system prompt
   // and no effort, which cannot share the cache, but is smaller and cannot be led astray by the main prompt.
+  // The messages are marked for the cache only where that can be read: no request after the summary starts with
+  // this history, so writing it (25% over the plain input price) pays only for reading what is already there.
+  // When the cache is known to have run out, and in the plain request, only the tools and system prompt are marked.
   async requestSummary(messages, { signal, onEvent }) {
-    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', ...(this.effort ? { effort: this.effort } : {}), ...request }, { signal, onEvent });
+    const cacheMessages = !this.cacheExpired();
+    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', cacheMessages, ...(this.effort ? { effort: this.effort } : {}), ...request }, { signal, onEvent });
     try {
       const res = await call({ system: this.currentSystem() });
       this.recordUsage(res, 'summary');
@@ -737,7 +749,7 @@ export class Agent {
     } catch (err) {
       if (isAbort(err) || signal?.aborted || !err.promptTooLong) throw err;
     }
-    const res = await call({ system: SUMMARY_SYSTEM, effort: null });
+    const res = await call({ system: SUMMARY_SYSTEM, effort: null, cacheMessages: false });
     this.recordUsage({ ...res, cache: { ...res.cache, caching: false } }, 'summary'); // made to miss: not a miss to report
     return res;
   }

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/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`) : ''}`,

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,8 @@ 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() }); }
   // 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 +116,7 @@ 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,
     };
   }
 

package/src/ui/repl.js

@@ -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.
@@ -992,9 +999,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'}.`);
@@ -1674,6 +1682,7 @@ export class App {
       this.remote?.register().catch(() => {});
     }
     this.firstPrompt = loaded.title;
+    this.cost = loaded.cost;
     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 +1720,7 @@ export class App {
     this.topic = null;
     this.customTitle = null;
     this.firstPrompt = null;
+    this.cost = 0;
     this.remote?.resync();
   }
 
@@ -2174,8 +2184,11 @@ 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.
+    const spent = this.cost > 0 ? c.dim(formatUsd(this.cost)) : '';
+    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, spent, info), join(notice, info), notice, info].find((r) => r && stringWidth(r) < room) || '';
     const gap = room - stringWidth(right);
     return right ? left + ' '.repeat(gap) + right : left;
   }