@yalieny/pi-better-cost-display-footer 2.1.2 → 2.3.0

package/README.md

@@ -6,6 +6,7 @@ pi 扩展:脚本化多段计价动态列表 + footer 增强。
 - **计费自愈**:每轮比对期望 cost(配置 × 当前档位)与实际参与计费的 `ctx.model.cost`,不一致则重注册纠正;连续 3 次未收敛则停止重试并在 footer 显式告警(金额前 `≈`、标签加 `?`),不再静默错价.
 - **档位标签**:价格后紧跟当前档位标签(如 `¥0.047(梁文峰)`),按档位 id 配置文案与颜色;未配置标签的档位不显示。
 - **CH 精度**:footer 缓存命中率小数位可配(默认 1 位)。
+- **tok/s 速率(思考/正文分相位)**:footer 常显 —— 流式中只显示当前相位的实时值 `⚡45.2t/s`(思考中/出字中都是这个形式,无前缀,2s 滚动窗口);assistant 消息结束(工具执行前)后冻结,只在冻结态带前缀,固定三档 `⚡(175.1/r31.8/o613.4)t/s` = 总吞吐 / 思考(r标识) / 正文(o标识),无值打 `-` 占位:本条无思考就是 `⚡(334.8/r-/o336.2)t/s`(无思考时总与正文本就重合)。分母均从各相位首 delta 起算,不含首 token 延迟与工具执行时长。实时值为估算(字符折算 token),思考/正文各自的折算比由真实 `usage.output`/`usage.reasoning` EMA 自校准(初始 4,限幅 0.5~8);异常速率(>1000 t/s)丢弃。注:DeepSeek 在工具循环的续写消息里经常不吐思考,所以 r 档会时有时无(显示为 `-`)。
 - **货币符号**:按 provider 配置计费金额符号(默认 `$`)。
 - **配置升级**:旧版顶层计价配置与 `peakWindows` 首次启动自动迁移为 provider 分层 + `tierFn` 格式(语义不变)。
 
@@ -108,6 +109,40 @@ node --experimental-strip-types test/drift-probe.ts      # 端到端:守卫重
 - 模型缺少当前档位价格时保持原价并打日志。
 - cost 仅影响 pi 本地用量统计,不影响 API 实际账单。
 
+## footer 与 pi 升级
+
+本扩展不再复刻 pi 的 footer。它在 `session_start` 加载已安装 pi 自己的
+`dist/modes/interactive/components/footer.js`（路径由 `pi` 的 bin 反推），把内置的
+`FooterComponent` 包一层，只在**渲染结果上打补丁**：
+
+1. 金额符号（`currencySymbol`，内置硬编码 `$`）。
+2. CH 小数位（`cacheHitRatePrecision`，内置硬编码 1 位）。
+3. context 占用条（`█░░░░░░░░░ 10.5%/1.0M`；外观抄 `pi-cc-extensions` 的 `barGauge`，≥80% 转 warning、≥95% 转 error）。
+4. 档位标签（内置没有）。
+5. tok/s 速率段（内置没有）。
+6. pwd 行：cwd 只显示最底层目录（抄 cc），分支换成 `⎇ 分支` 底色 chip（图标抄 look pack），后跟 git 变更行数 `+12 −3`（数据与刷新抄 cc：`git diff --numstat HEAD`，启动查一次 + 10s 轮询 + 分支变化重查，跳过二进制行）。
+7. 右侧：模型（含 `(provider)` 前缀）上底色 chip（抄 look pack），thinking 级别上色（抄 cc；分隔符沿用内置的 `•`）。
+
+pwd 行、统计段布局、对齐、截断、状态行、以及 pi 以后新增的字段，全部用内置渲染：
+pi 改 footer 会自动跟随，不会用旧版布局覆盖。补丁只改行的文本，并按补白收缩保证行宽不变。
+空间不够时按 速率 → 标签 → 占用条 的顺序舍弃。
+
+降级（都不会弄坏 footer）：
+
+- 拿不到内置组件（单文件二进制、源码运行、构造失败）→ 不替换，直接用 pi 自带 footer，并提醒一次。
+- 内置 stats 行结构不认识（补丁打不上）→ 内置原样渲染，提醒一次；`/cost-tier` 的 `footer:` 一行给出状态。
+
+## footer 控制权（与其他扩展共存）
+
+pi 没有“叠加 footer”的扩展点。两家扩展都调 `setFooter` 时，后调用的直接覆盖前一个
+（顺序 = `settings.packages` 顺序）。已知的竞争者：`pi-cc-extensions`（`enableCustomFooter: true`，
+两行 chips 状态栏）与 `awesome-pi-themes` 的 look pack。
+
+本插件是通用插件，不做针对某个扩展的特例，总是接管 footer。要同时用对方的 footer，
+就关掉一个（cc：`/ccstyle`，或 `"enableCustomFooter": false`）。
+
 ## 变更记录
 
+- **2.3.0** footer 改为“增量补丁”而非整段复刻：加载并包装 pi 自己的 `FooterComponent`，只在渲染结果上换金额符号、改 CH 小数位、加 context 占用条、加档位标签与 tok/s；pwd 行改为“`⎇ 分支` 底色 chip + git 变更行数”，右侧模型上 chip、thinking 上色（分隔符沿用内置）。占用条抄 `pi-cc-extensions` 的 `barGauge`，分支图标与分隔符抄 look pack，git 变更行数（含 10s 轮询与分支变化重查）抄 cc。pi 升级 footer（新字段、新布局）自动跟随，不再覆盖。拿不到内置组件或布局变化时降级为 pi 自带 footer 并提醒一次。
+- **2.2.0** footer 新增 tok/s 速率(思考/正文分相位):流式中显示当前相位实时值 `⚡45.2t/s`(无前缀,2s 滚动窗口),assistant `message_end` 用真实 `usage` 冻结为固定三档 `⚡(175.1/r31.8/o613.4)t/s`(总/思考/正文,无值打 `-` 占位);分母从各相位首 delta 起算,不含首 token 延迟与工具执行时长(定稿用 message_end 而非 turn_end)。实时值为估算,思考/正文各自的折算比由真实 token EMA 自校准(初始 4,限幅 0.5~8);异常速率(>1000 t/s)丢弃;无效 `usage`(失败/中止)不覆盖定稿值。/cost-tier 新增两档折算比。
 - **2.1.2** 修复"档位标签正确但计费金额按错档结算":注册守卫改为按实际计费 cost 判定漂移(不再只看档位字符串),注册失败不再写入守卫(下一轮自动重试);漂移 3 次未收敛转为 footer 可见告警(`≈` + 标签 `?`);新增 `/cost-tier` 诊断命令与注册失败一次性提示。方案见 `docs/fix-plan-stale-cost-tier.md`。

package/extensions/pi-better-cost-display-footer.ts

@@ -35,12 +35,15 @@
 //   （不再限定 deepseek 官方，其余 provider 同样适用）。
 // - 自定义 footer 与 CH 精度：所有 provider 适用；未配置模型仅修改 CH，其余保持内置默认。
 //
-// 计费显示：用 ctx.ui.setFooter 替换内置 footer（升级安全，扩展代码不随 pi 更新）。
-// 复刻内置 footer 渲染（footer.js），并加两处增强：
+// 计费显示：复用 pi 自己的 footer 组件（ctx.ui.setFooter 包一层），只在渲染结果上打补丁：
 //   1. 激活模型有动态计价配置时，价格后紧跟档位标签（labels 按档位 id 查，未配置则不显示标签）：
 //      如 ¥0.047（梁文峰）。color 支持主题色名或 #rrggbb。
 //   2. CH 缓存命中率小数位由 cacheHitRatePrecision 控制（内置硬编码 1 位），所有 provider 适用。
 //   3. 计费金额符号由各 provider 的 currencySymbol 控制（内置硬编码 $）。
+//   4. tok/s 速率段（本插件新增）。
+// 布局、对齐、截断、pi 新增字段全部沿用内置渲染：pi 升级 footer 自动跟随，不会用旧版布局覆盖。
+// 与其他扩展抢 footer：pi 没有“叠加”扩展点，两家都调 setFooter 时后调用的直接覆盖前一个；
+// 本插件总是接管 footer（通用插件，不针对某个扩展写特例）。
 //
 // 注意：
 // - 旧版顶层计价字段与 provider 级 peakWindows 首次读取时自动迁移并写回配置文件。
@@ -48,15 +51,17 @@
 // - provider 必须在 models.json 中有定义：扩展读取其完整模型定义，仅替换 cost 后整体重注册
 //   （registerProvider 的 models 是整体替换语义）。未列出的模型保持原价。
 // - cost 仅影响 pi 本地用量统计，不影响 API 实际账单。
-// - ponytail: 自定义 footer 是内置 modes/interactive/components/footer.js 的复刻，
-//   全部数据来自公开 API（ctx.sessionManager / ctx.getContextUsage / ctx.model /
-//   footerData），内置的 xp 实验标记与 auto-compact 开关状态未复刻。
-//   若 pi 调整 footer 布局需对照同步；上限 = 内置无"统计段追加"扩展点，
-//   升级路径 = 给内置 footer 增加 stats 追加 hook。
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, relative, resolve, sep, isAbsolute } from "node:path";
+// - ponytail: footer 用“加载 pi 自己的 FooterComponent + 打补丁”，不再整段复刻布局。
+//   依赖 3 个内部约定：<pi>/dist/modes/interactive/components/footer.js 路径、
+//   FooterComponent(session, footerData) 构造、stats 行 = dim(统计段) + dim(补白 + 右侧)。
+//   任一不成立 → 补丁不生效（一次性提醒），footer 仍由 pi 自己渲染；主题经 globalThis Proxy 共享，颜色一致。
+//   上限 = 内置无“统计段追加”扩展点；升级路径 = 给内置 footer 增加 stats 追加 hook。
+import { readFileSync, writeFileSync, existsSync, mkdirSync, realpathSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { join, dirname } from "node:path";
 import { homedir } from "node:os";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { pathToFileURL } from "node:url";
+import { visibleWidth, truncateToWidth } from "@earendil-works/pi-tui";
 import type {
   ExtensionAPI,
   ExtensionContext,
@@ -194,6 +199,201 @@ let footerLabel: FooterLabel | null = null;
 /** ponytail: 漂移重试预算固定 3 次，不做指数退避；真出现抖动再把预算做成配置项 */
 const DRIFT_RETRY_LIMIT = 3;
 
+/* ---------- tok/s 实时速率（思考 / 正文分相位） ---------- */
+
+/** ponytail: 窗口与折算上限固定；窗口 2s 是 GUI 可读性的取舍，不做配置项 */
+const SPEED_WINDOW_MS = 2000;
+/** 初始“字符/token”比：与 pi 自身（pi-ai estimate）的 4 一致，随后用真实 token 校准 */
+const SPEED_CHARS_PER_TOKEN_DEFAULT = 4;
+/** 校准比限幅：0.5（CJK 密集）~ 8（思考/结构化短词） */
+const SPEED_RATIO_MIN = 0.5;
+const SPEED_RATIO_MAX = 8;
+/** 校准 EMA 系数：每条消息往实测值靠 30%，数条内收敛 */
+const SPEED_CALIBRATION_ALPHA = 0.3;
+/** 超过该速率视为异常样本（t/s），丢弃并沿用上次值 */
+const SPEED_MAX = 1000;
+
+/** 相位：r = 思考（reasoning），o = 正文（output − reasoning，含工具调用参数） */
+type SpeedPhaseKind = "r" | "o";
+
+/** 单相位的 2s 滚动窗口累计 */
+interface SpeedPhase {
+  /** 本相位首个 delta 时刻；null = 本相位无产出 */
+  firstMs: number | null;
+  /** 本相位最近一个 delta 时刻（相位时长 = last − first） */
+  lastMs: number;
+  chars: number;
+  /** 已计入窗口的估算 token（单调，与窗口裁剪解耦，避免裁剪后重复计数） */
+  tokens: number;
+  samples: { t: number; n: number }[];
+  /** 本相位最近一次实时速率 */
+  rate: number | null;
+}
+
+/** 定稿三档速率；null = 该档无法计算 */
+interface SpeedFinal {
+  /** 总吞吐 = output / (首 delta → message_end) */
+  total: number | null;
+  /** 思考 = reasoning / 思考段时长 */
+  r: number | null;
+  /** 正文 = (output − reasoning) / 正文段时长 */
+  o: number | null;
+}
+
+function newPhase(): SpeedPhase {
+  return { firstMs: null, lastMs: 0, chars: 0, tokens: 0, samples: [], rate: null };
+}
+
+/** 各相位“字符/token”校准比：跨消息保留 */
+const speedRatio: Record<SpeedPhaseKind, number> = {
+  r: SPEED_CHARS_PER_TOKEN_DEFAULT,
+  o: SPEED_CHARS_PER_TOKEN_DEFAULT,
+};
+
+/**
+ * 速率状态：每个 delta 按相位进各自的滚动窗口 → assistant message_end 用真实 usage
+ * （output / reasoning）定稿三档并校准折算比。流式中显示当前相位实时值，空闲显示定稿三档。
+ *
+ * 为何实时值只能估算：没有任何 provider 在流中回传逐块累计 output token（Anthropic 的
+ * message_delta / Bedrock 的 metadata / OpenAI 的 include_usage 都只在末尾给一次），
+ * 只能由文本长度推；真值用于定稿与校准。
+ *
+ * 为何用 message_end 而非 turn_end 定稿：agent-loop 顺序是
+ * turn_start → 流式 message_* → 执行工具 → turn_end，用 turn_end 会把工具执行时长算进分母
+ * （流 200 token 后跑 60s 构建 → 报 3 t/s）。message_end 就在流式结束、工具开始前。
+ *
+ * 为何分相位：两段速度差一个数量级（实测 deepseek-flash：思考 ~32 t/s、正文 ~613 t/s），
+ * 混在一起的平均既不代表“模型在跑”也不代表“字出来的速度”。
+ */
+const speed = {
+  think: newPhase(),
+  text: newPhase(),
+  /** 当前正在产出的相位；null = 空闲（显示定稿值） */
+  active: null as SpeedPhaseKind | null,
+  /** 本条消息首 delta 时刻（总口径分母起点） */
+  firstMs: null as number | null,
+  /** 最近一条消息的定稿三档 */
+  final: null as SpeedFinal | null,
+};
+
+/** 速率合理区间（t/s）；异常样本返回 null */
+function reasonableRate(rate: number): number | null {
+  return Number.isFinite(rate) && rate > 0 && rate <= SPEED_MAX ? rate : null;
+}
+
+/** 清空单条消息的累计，保留定稿值与校准比（assistant 消息开始时调用） */
+export function resetSpeedTurn(): void {
+  speed.think = newPhase();
+  speed.text = newPhase();
+  speed.active = null;
+  speed.firstMs = null;
+}
+
+/** 会话开始/切换：全部清空（含定稿值与校准比，避免沿用上个会话的数字） */
+export function resetSpeedSession(): void {
+  speed.final = null;
+  speedRatio.r = SPEED_CHARS_PER_TOKEN_DEFAULT;
+  speedRatio.o = SPEED_CHARS_PER_TOKEN_DEFAULT;
+  resetSpeedTurn();
+}
+
+/** 相位实时速率：窗口内 token / 实际耗时（窗口不满时按相位首 delta 起算） */
+function phaseLiveRate(p: SpeedPhase, nowMs: number): number | null {
+  if (p.firstMs === null) return null;
+  const cutoff = nowMs - SPEED_WINDOW_MS;
+  p.samples = p.samples.filter((s) => s.t >= cutoff);
+  const elapsedSec = (nowMs - Math.max(cutoff, p.firstMs)) / 1000;
+  if (elapsedSec <= 0) return null;
+  const tokens = p.samples.reduce((sum, s) => sum + s.n, 0);
+  const measured = reasonableRate(tokens / elapsedSec);
+  if (measured !== null) p.rate = measured;
+  return p.rate;
+}
+
+/**
+ * 消费一片流式文本（按相位累计），返回该相位的实时速率
+ * @param kind - "r" 思考 / "o" 正文（含工具调用参数）
+ */
+export function pushSpeedDelta(kind: SpeedPhaseKind, delta: string, nowMs: number): number | null {
+  const p = kind === "r" ? speed.think : speed.text;
+  if (delta.length > 0) {
+    speed.active = kind;
+    if (speed.firstMs === null) speed.firstMs = nowMs;
+    if (p.firstMs === null) p.firstMs = nowMs;
+    p.lastMs = nowMs;
+    p.chars += delta.length;
+    // 字符按折算比换算 token，只把新增量入窗口（累计量单调，裁剪后不会重复计数）
+    const target = Math.round(p.chars / speedRatio[kind]);
+    if (target > p.tokens) {
+      p.samples.push({ t: nowMs, n: target - p.tokens });
+      p.tokens = target;
+    }
+  }
+  return phaseLiveRate(p, nowMs);
+}
+
+/** 用真实 token 校准某相位的“字符/token”比；样本无效时保持原值 */
+function calibrate(kind: SpeedPhaseKind, chars: number, realTokens: number): void {
+  if (realTokens <= 0 || chars <= 0) return;
+  const measured = Math.min(SPEED_RATIO_MAX, Math.max(SPEED_RATIO_MIN, chars / realTokens));
+  speedRatio[kind] =
+    speedRatio[kind] * (1 - SPEED_CALIBRATION_ALPHA) + measured * SPEED_CALIBRATION_ALPHA;
+}
+
+/** 相位时长（首 → 末 delta，秒）；样本不足返回 null */
+function phaseSpanSec(p: SpeedPhase): number | null {
+  if (p.firstMs === null || p.lastMs <= p.firstMs) return null;
+  return (p.lastMs - p.firstMs) / 1000;
+}
+
+/**
+ * 消息结束（流式刚结束、工具还没开始）：用真实 usage 定稿三档速率并校准折算比。
+ * 分母 = 相位首 delta → 相位末 delta（总口径为首 delta → message_end），
+ * 不含首 token 延迟与工具执行时长。
+ * @param output - usage.output（含思考）
+ * @param reasoning - usage.reasoning（思考 token，output 的子集；provider 不报时为 0）
+ */
+export function finishSpeedTurn(output: number, nowMs: number, reasoning = 0): SpeedFinal | null {
+  const { think, text, firstMs } = speed;
+  const reasoningTokens = Math.max(0, Math.min(reasoning, output));
+  const textTokens = output - reasoningTokens;
+  calibrate("r", think.chars, reasoningTokens);
+  calibrate("o", text.chars, textTokens);
+  const totalSec = firstMs === null ? null : (nowMs - firstMs) / 1000;
+  const thinkSec = phaseSpanSec(think);
+  const textSec = phaseSpanSec(text);
+  const final: SpeedFinal = {
+    total: output > 0 && totalSec !== null && totalSec > 0 ? reasonableRate(output / totalSec) : null,
+    r: reasoningTokens > 0 && thinkSec !== null ? reasonableRate(reasoningTokens / thinkSec) : null,
+    o: textTokens > 0 && textSec !== null ? reasonableRate(textTokens / textSec) : null,
+  };
+  resetSpeedTurn();
+  // 有真值才覆盖：失败/中止的消息 usage 可能全 0
+  if (final.total !== null || final.r !== null || final.o !== null) speed.final = final;
+  return speed.final;
+}
+
+/**
+ * footer 的 tok/s 片段：流式中 `⚡12.3t/s`（当前相位实时值，不加前缀）；空闲固定三档
+ * `⚡(175.1/r31.8/o613.4)t/s`（总/思考/正文，总档靠位置识别，r/o 带标识），无值打 `-` 占位
+ */
+export function formatSpeedPart(): string {
+  if (speed.active !== null) {
+    const p = speed.active === "r" ? speed.think : speed.text;
+    if (p.rate !== null) return `⚡${p.rate.toFixed(1)}t/s`;
+  }
+  const f = speed.final;
+  if (!f) return "";
+  const cell = (tag: string, v: number | null) => `${tag}${v === null ? "-" : v.toFixed(1)}`;
+  const total = f.total === null ? "-" : f.total.toFixed(1);
+  return `⚡(${total}/${cell("r", f.r)}/${cell("o", f.o)})t/s`;
+}
+
+/** 当前折算比，供 /cost-tier 诊断 */
+export function speedRatios(): { r: number; o: number } {
+  return { r: speedRatio.r, o: speedRatio.o };
+}
+
 /** 一次性提示：TUI 下扩展的 console.error 不落盘也不可见，错误必须走 ui.notify */
 function notifyOnce(ctx: ExtensionContext, text: string): void {
   if (text === lastErrorText) return;
@@ -423,26 +623,172 @@ function patchProviderConfig(
   return { ...provider, models };
 }
 
-// ---------- 自定义 footer：复刻内置 footer.js + 档位标签 + CH 精度 ----------
+/* ---------- 复用内置 footer（增量补丁，不整段复刻） ---------- */
+
+/**
+ * pi 的内置 footer 组件（dist/modes/interactive/components/footer.js）。
+ * 不再复刻它的布局：直接加载 pi 自己的实现，只在渲染结果上打补丁
+ * （金额符号 / CH 精度 / 档位标签 / tok/s）。pi 改 footer 布局时自动跟随。
+ * 主题在 globalThis 上以 Proxy 共享，拿到的就是当前主题，颜色一致。
+ */
+interface BaseFooterModule {
+  FooterComponent: new (
+    session: unknown,
+    footerData: unknown,
+  ) => { render(width: number): string[] };
+}
+
+/** 加载结果：null = 未加载成功（footer 保持 pi 内置） */
+let baseFooter: BaseFooterModule | null = null;
+/** 只尝试加载一次 */
+let baseFooterLoaded = false;
+/** 未加载成功的原因，供 /cost-tier 与一次性提醒 */
+let baseFooterError: string | null = null;
+/** 补丁失效（内置布局不认识）已提醒过 */
+let footerPatchWarned = false;
+/** 内置组件渲染失败已处理过 */
+let footerDisabled = false;
+
+/**
+ * 定位已安装 pi 的内置 footer 源码。pi 的 bin 指向 <pkg>/dist/bundle/cli.js，
+ * 由此向上最多 6 层找 dist/modes/interactive/components/footer.js。
+ * 找不到（单文件二进制、源码运行）→ null。
+ */
+function upstreamFooterFile(): string | null {
+  const entry = process.argv[1];
+  if (!entry) return null;
+  try {
+    let dir = dirname(realpathSync(entry));
+    for (let i = 0; i < 6; i++) {
+      const candidate = join(dir, "dist", "modes", "interactive", "components", "footer.js");
+      if (existsSync(candidate)) return candidate;
+      dir = dirname(dir);
+    }
+  } catch {
+    // argv[1] 不可解析 → 不定位
+  }
+  return null;
+}
+
+/** 加载 pi 内置 footer 组件；失败不影响计价，只退化为 pi 自带 footer */
+async function loadBaseFooter(): Promise<BaseFooterModule | null> {
+  if (baseFooterLoaded) return baseFooter;
+  baseFooterLoaded = true;
+  const file = upstreamFooterFile();
+  if (!file) {
+    baseFooterError = "未定位到已安装 pi 的 footer.js（单文件二进制或源码运行）";
+    return null;
+  }
+  try {
+    const mod = (await import(pathToFileURL(file).href)) as unknown as BaseFooterModule;
+    if (typeof mod?.FooterComponent === "function") baseFooter = mod;
+    else baseFooterError = `${file} 未导出 FooterComponent`;
+  } catch (err) {
+    baseFooterError = `加载 ${file} 失败：${err instanceof Error ? err.message : String(err)}`;
+  }
+  return baseFooter;
+}
 
-function formatTokens(count: number): string {
-  if (count < 1000) return count.toString();
-  if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-  if (count < 1000000) return `${Math.round(count / 1000)}k`;
-  if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
-  return `${Math.round(count / 1000000)}M`;
+function baseFooterStatusText(): string {
+  if (baseFooter) return "复用内置 footer；补丁：context 占用条 / 金额符号 / CH 精度 / 档位标签 / tok/s";
+  return `未复用内置 footer（${baseFooterError ?? "未尝试加载"}）`;
 }
 
-function formatCwdForFooter(cwd: string, home: string | undefined): string {
-  if (!home) return cwd;
-  const rel = relative(resolve(home), resolve(cwd));
-  const inside =
-    rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
-  return inside ? (rel === "" ? "~" : `~${sep}${rel}`) : cwd;
+/**
+ * 内置 FooterComponent 需要的 session 视图，数据全部来自扩展 ctx。
+ * modelRuntime 未对扩展暴露 → 订阅制保留内置的 kimi-coding 特例。
+ */
+function footerSessionView(ctx: ExtensionContext) {
+  const c = () => activeCtx ?? ctx;
+  return {
+    get state() {
+      return { model: c().model, thinkingLevel: c().thinkingLevel };
+    },
+    sessionManager: {
+      getEntries: () => c().sessionManager.getEntries(),
+      getCwd: () => c().sessionManager.getCwd(),
+      getSessionName: () => c().sessionManager.getSessionName(),
+    },
+    getContextUsage: () => c().getContextUsage(),
+    modelRuntime: { isUsingSubscription: (providerId: string) => providerId === "kimi-coding" },
+  };
 }
 
-function sanitizeStatusText(text: string): string {
-  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+// ---------- footer 补丁：占用条 / 金额符号 / CH 精度 / 档位标签 / tok/s / pwd 行 ----------
+
+/** 去掉 ANSI 转义，只留可见文本 */
+function stripAnsi(text: string): string {
+  return text.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+/** 分支图标（抄 look pack 的 `⎇`，不依赖 Nerd Font） */
+const BRANCH_ICON = "⎇";
+/** 段分隔符（抄 look pack） */
+const SEG_SEP = " │ ";
+/** git 变更行数刷新间隔（抄 pi-cc-extensions） */
+const GIT_REFRESH_INTERVAL_MS = 10_000;
+
+/**
+ * 解析 `git diff --numstat HEAD` 输出：每行前两列是增/删行数，二进制行为 `-\t-` → 跳过。
+ * 抄 pi-cc-extensions 的 parseGitStats。
+ */
+export function parseGitStats(stdout: string): { add: number; del: number } {
+  let add = 0;
+  let del = 0;
+  for (const line of stdout.split("\n")) {
+    const match = /^(\d+)\s+(\d+)/.exec(line);
+    if (!match) continue;
+    add += Number(match[1]);
+    del += Number(match[2]);
+  }
+  return { add, del };
+}
+
+/** 工作区变更行数；undefined = 未查到（非 git 仓库 / 查询失败） */
+let gitStats: { add: number; del: number } | undefined;
+let gitRefreshRunning = false;
+
+/** 查一次 `git diff --numstat HEAD`；结果变化时回调（用于重绘） */
+function refreshGitStats(cwd: string, onChanged: () => void): void {
+  if (gitRefreshRunning) return;
+  gitRefreshRunning = true;
+  execFile("git", ["diff", "--numstat", "HEAD"], { cwd, timeout: 2000 }, (err, stdout) => {
+    gitRefreshRunning = false;
+    if (err) return;
+    const next = parseGitStats(stdout);
+    if (gitStats?.add === next.add && gitStats.del === next.del) return;
+    gitStats = next;
+    onChanged();
+  });
+}
+
+/** 分支标签：`⎇ branch` 做成 accent 底色 chip，后跟 git 变更行数（success/error） */
+function branchLabel(branch: string, stats: { add: number; del: number } | null | undefined, theme: Theme): string {
+  // 带尾空格的 chip 用于后接 ± 数字；无数字时不带尾空格，避免行末多一个空格
+  const chip = (text: string) => theme.bg("selectedBg", theme.fg("accent", text));
+  const icon = `${BRANCH_ICON} ${branch}`;
+  if (!stats) return chip(icon);
+  return `${chip(`${icon} `)}${theme.fg("success", `+${stats.add}`)} ${theme.fg("error", `−${stats.del}`)}`;
+}
+
+/** 内置金额格式 `$0.047` / `$0.047 (sub)`；只改符号，不改数值 */
+const COST_RE = /\$(\d+\.\d+)( \(sub\))?/;
+
+/** context 占用条宽度（格） */
+const BAR_WIDTH = 10;
+/** ≥ 80% 转 warning 色，≥ 95% 转 error 色（同 pi-cc-extensions） */
+const BAR_WARNING = 80;
+const BAR_ERROR = 95;
+
+/**
+ * context 占用条。外观抄 pi-cc-extensions 的 barGauge（其注释：pi-cc-status 风格）：
+ * accent 填充 + dim 空槽，高占用转 warning/error 色。
+ */
+export function barGauge(theme: Theme, percent: number): string {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round((clamped / 100) * BAR_WIDTH);
+  const color = clamped >= BAR_ERROR ? "error" : clamped >= BAR_WARNING ? "warning" : "accent";
+  return theme.fg(color, "█".repeat(filled)) + theme.fg("dim", "░".repeat(BAR_WIDTH - filled));
 }
 
 /** 标签着色：ThemeColor 名走主题，#rrggbb 走 truecolor 直出（SGR 38;2;r;g;b） */
@@ -455,19 +801,182 @@ export function colorize(theme: Theme, color: string, text: string): string {
   return theme.fg(color as ThemeColor, text);
 }
 
-/** 整段包 dim，但跳过 marker（档位标签）保持原色；未找到 marker 时整段 dim */
-function dimSkip(text: string, marker: string, theme: Theme): string {
-  if (!marker) return theme.fg("dim", text);
-  const idx = text.indexOf(marker);
-  if (idx < 0) return theme.fg("dim", text);
+/** 漂移时标签加问号：宁可显示“可疑”，不静默显示错数字 */
+function driftLabelText(text: string): string {
+  return text.endsWith("）") ? `${text.slice(0, -1)}?）` : `${text}?`;
+}
+
+/** 补丁内容：金额符号 / CH 精度来自配置，档位标签 / tok/s 是本插件新增 */
+interface FooterPatchOptions {
+  /** 配置了 currencySymbol 才替换内置的 `$` */
+  symbol?: string;
+  /** 配置了 cacheHitRatePrecision 才改 CH 小数位（内置硬编码 1 位） */
+  precision?: number;
+  /** 计费与档位不符 → 金额前加 `≈` */
+  approx?: boolean;
+  /** tok/s 片段 */
+  speed?: string;
+  label?: FooterLabel;
+  /** context 占用条：true 时把 `10.5%/1.0M` 换成 `████░░░░░░ 10.5%/1.0M` */
+  contextBar?: boolean;
+  /** pwd 行：分支图标 + 变更行数；null = 无 git 数据 */
+  branchStats?: { add: number; del: number } | null;
+  /** 右侧：模型 id 上底色 chip，thinking 级别上色（抄 look pack / cc） */
+  modelId?: string;
+  thinkingLevel?: string;
+}
+
+/**
+ * 把内置 stats 行切成 `stats + dim(补白 + 右侧模型名)` 三段。
+ * 内置结构不认识（行里没有两段 dim）→ null。
+ */
+function splitStatsLine(
+  line: string,
+  theme: Theme,
+): { stats: string; padding: string; right: string; dimOpen: string } | null {
+  const dimOpen = theme.getFgAnsi("dim");
+  const cut = line.lastIndexOf(dimOpen);
+  if (cut <= 0 || !line.slice(0, cut).includes(dimOpen)) return null;
+  const tail = line.slice(cut + dimOpen.length);
+  const padding = /^ */.exec(tail)?.[0] ?? "";
+  return { stats: line.slice(0, cut), padding, right: tail.slice(padding.length), dimOpen };
+}
+
+/**
+ * 增量补丁：只改统计段内的 context 占用条、金额符号、CH 精度，
+ * 并按剩余补白追加速率与档位标签；行宽、对齐、截断、pi 新增的字段全部沿用内置结果。
+ * 空间不够时按 速率 → 标签 → 占用条 的顺序舍弃；结构不认识 → 返回原行（补丁可丢，布局不坏）。
+ */
+function patchFooterStatsLine(
+  line: string,
+  theme: Theme,
+  opts: FooterPatchOptions,
+): { line: string; patched: boolean } {
+  const parts = splitStatsLine(line, theme);
+  if (!parts) return { line, patched: false };
+  const { stats: original, padding, right, dimOpen } = parts;
+  let stats = original;
+  // CH 精度先改：它在金额前，改完再定位金额，下标才准
+  if (opts.precision !== undefined) {
+    stats = stats.replace(
+      /CH(\d+(?:\.\d+)?)%/,
+      (_m, v: string) => `CH${Number(v).toFixed(opts.precision)}%`,
+    );
+  }
+  // 金额：`$数字` 换成配置的符号，可加 ≈；前后插入点一并算好
+  const cost = COST_RE.exec(stats);
+  let costHead = -1;
+  let costTail = -1;
+  if (cost) {
+    const prefix = `${opts.approx ? "≈" : ""}${opts.symbol ?? "$"}`;
+    const numStart = cost.index + 1; // `$` 之后
+    stats = stats.slice(0, cost.index) + prefix + stats.slice(numStart);
+    costHead = cost.index;
+    costTail = cost.index + prefix.length + cost[1].length + (cost[2]?.length ?? 0);
+  }
+  const speed = opts.speed ? `${opts.speed} ` : "";
+  const label = opts.label
+    ? ` ${colorize(theme, opts.label.color, opts.label.text)}${dimOpen}`
+    : "";
+  // context 占用条：插在百分比前（在金额之后，不影响 costHead/costTail 下标）；`?` 时没有百分比，跳过
+  const pct = opts.contextBar ? /(\d+(?:\.\d+)?)%\//.exec(stats) : null;
+  const bar = pct ? `${barGauge(theme, Number(pct[1]))} ` : "";
+  const barAt = pct ? pct.index : -1;
+  const build = (withBar: boolean, withSpeed: boolean, withLabel: boolean): string => {
+    let out = stats;
+    // 占用条先插：它落在金额之后，再按原下标插速率/标签才不错位
+    if (withBar && barAt >= 0) out = out.slice(0, barAt) + bar + out.slice(barAt);
+    const s = withSpeed ? speed : "";
+    const l = withLabel ? label : "";
+    if (costTail < 0) {
+      // 无计费段（cost 为 0 且非订阅）→ 追到统计段末；tok/s 与统计段同色，标签自带颜色
+      const extras = [withSpeed ? theme.fg("dim", speed.trim()) : "", l.trim()].filter(Boolean);
+      return extras.length ? `${out} ${extras.join(" ")}` : out;
+    }
+    return out.slice(0, costHead) + s + out.slice(costHead, costTail) + l + out.slice(costTail);
+  };
+  const base = visibleWidth(original);
+  // 右段：模型（连同内置的 `(provider) ` 前缀）上底色 chip、thinking 级别上色；chip 多占 2 格从补白扣
+  const prefix = /^\(([^)]*)\) /.exec(stripAnsi(right));
+  const chipTarget = opts.modelId
+    ? prefix
+      ? `${prefix[0]}${opts.modelId}`
+      : opts.modelId
+    : "";
+  const chip = chipTarget ? theme.bg("selectedBg", theme.fg("muted", ` ${chipTarget}`)) : "";
+  let patchedRight = right;
+  if (chipTarget && patchedRight.includes(chipTarget)) patchedRight = patchedRight.replace(chipTarget, chip);
+  if (opts.thinkingLevel) {
+    const levelText = opts.thinkingLevel === "off" ? "thinking off" : opts.thinkingLevel;
+    // 分隔符沿用内置的 ` • `，只把级别上色（宽度不变）
+    patchedRight = patchedRight.replace(
+      ` • ${levelText}`,
+      ` • ${theme.getThinkingBorderColor(opts.thinkingLevel)(levelText)}`,
+    );
+  }
+  const rightDelta = patchedRight === right ? 0 : visibleWidth(stripAnsi(patchedRight)) - visibleWidth(stripAnsi(right));
+  // 优先顺序：占用条（本插件新增的显示）> 标签 > 速率；补白用于吸收宽度差
+  for (const [withBar, withLabel, withSpeed] of [
+    [true, true, true],
+    [true, true, false],
+    [true, false, false],
+    [false, false, false],
+  ] as const) {
+    const patchedStats = build(withBar, withLabel, withSpeed);
+    const delta = visibleWidth(patchedStats) - base;
+    const shrink = Math.max(0, delta) + Math.max(0, rightDelta);
+    if (shrink > padding.length) continue;
+    // 宽度差为负（改短了）时补回空格，保持行宽不变
+    const pad =
+      padding.slice(shrink) + " ".repeat(Math.max(0, -delta) + Math.max(0, -rightDelta));
+    return { line: patchedStats + dimOpen + pad + patchedRight, patched: true };
+  }
+  return { line, patched: false };
+}
+
+/**
+ * pwd 行补丁（样式抄 cc 与 look pack）：分支换成 `⎇ branch` 底色 chip，后跟 git 变更行数。
+ * 路径沿用内置的完整显示；无分支时原样返回（调用方靠引用判断）。
+ */
+export function patchFooterPwdLine(line: string, theme: Theme, opts: FooterPatchOptions): string {
+  const text = stripAnsi(line); // 内置 pwd 行只有 dim 一种颜色
+  const branch = /\(([^()]*)\)(?= •|$)/.exec(text);
+  if (!branch) return line;
+  const head = text.slice(0, branch.index).trim();
+  const tail = text.slice(branch.index + branch[0].length); // " • 会话名" 或空
   return (
-    theme.fg("dim", text.slice(0, idx)) +
-    "\x1b[22m" + // 重置亮度，标签不被 dim 压暗
-    marker +
-    theme.fg("dim", text.slice(idx + marker.length))
+    theme.fg("dim", head + SEG_SEP) +
+    branchLabel(branch[1], opts.branchStats, theme) +
+    (tail ? theme.fg("dim", tail) : "")
   );
 }
 
+/**
+ * 在整组 footer 行里打补丁：stats 行（补丁主体）+ 第一行（pwd）。
+ * patched 只反映 stats 行，因为它是布局变化的探测器（pwd 行变了不算布局变）。
+ */
+export function patchFooterLines(
+  lines: string[],
+  theme: Theme,
+  opts: FooterPatchOptions,
+  width = 0,
+): { lines: string[]; patched: boolean } {
+  const next = [...lines];
+  let statsPatched = false;
+  for (let i = 0; i < lines.length; i++) {
+    const result = patchFooterStatsLine(lines[i], theme, opts);
+    if (!result.patched) continue;
+    next[i] = result.line;
+    statsPatched = true;
+    break;
+  }
+  if (lines.length > 0) {
+    const pwd = patchFooterPwdLine(lines[0], theme, opts);
+    if (pwd !== lines[0]) next[0] = width > 0 ? truncateToWidth(pwd, width, theme.fg("dim", "...")) : pwd;
+  }
+  return { lines: next, patched: statsPatched };
+}
+
 /** 本插件视角下的模型对象子集（pi 的 Model 结构兼容，cost 只看四段扁平价） */
 interface ModelLike {
   provider: string;
@@ -564,141 +1073,93 @@ function computeFooterLabel(st: PricingState): FooterLabel | null {
 
 function installCustomFooter(ctx: ExtensionContext): void {
   if (ctx.mode !== "tui") return; // 非 TUI（rpc/json）无 footer 可替换
-  ctx.ui.setFooter((_tui, theme, footerData) => ({
-    invalidate() {},
-    render(width: number) {
-      const c = activeCtx;
-      const sm = c?.sessionManager;
-      // 累计用量：镜像内置 addUsageToTotals 的入口（assistant / toolResult / 摘要与压缩）
-      const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
-      let latestCacheHitRate: number | undefined;
-      for (const entry of sm?.getEntries() ?? []) {
-        let usage;
-        if (entry.type === "message" && entry.message.role === "assistant") {
-          usage = entry.message.usage;
-          const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
-          latestCacheHitRate =
-            promptTokens > 0 ? (usage.cacheRead / promptTokens) * 100 : undefined;
-        } else if (entry.type === "message" && entry.message.role === "toolResult" && entry.message.usage) {
-          usage = entry.message.usage;
-        } else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
-          usage = entry.usage;
+  const Base = baseFooter;
+  if (!Base) {
+    // 拿不到内置组件 → 不覆盖，让 pi 自己渲染 footer（档位标签等增强本会话不生效）
+    ctx.ui.setFooter(undefined);
+    notifyOnce(
+      ctx,
+      `[pi-better-cost-display-footer] footer 增强未启用：${baseFooterError ?? "内置 footer 未加载"}`,
+    );
+    return;
+  }
+  ctx.ui.setFooter((tui, theme, footerData) => {
+    const base = new Base.FooterComponent(footerSessionView(ctx), footerData);
+    // git 变更行数：启动查一次 + 10s 轮询 + 分支变化重查（抄 pi-cc-extensions）
+    const refreshGit = () => refreshGitStats(ctx.cwd, () => tui.requestRender());
+    const unsubBranch = footerData.onBranchChange(() => {
+      refreshGit();
+      tui.requestRender();
+    });
+    refreshGit();
+    const gitTimer = setInterval(refreshGit, GIT_REFRESH_INTERVAL_MS);
+    gitTimer.unref?.();
+    return {
+      invalidate() {},
+      dispose() {
+        clearInterval(gitTimer);
+        unsubBranch?.();
+      },
+      render(width: number) {
+        // 主题可能被运行时切换；ctx.ui.theme 是实时值，footer 工厂入参是装载时的快照
+        const live = activeCtx?.ui.theme ?? theme;
+        let lines: string[];
+        try {
+          lines = base.render(width);
+        } catch (err) {
+          disableFooter(ctx, err);
+          return [];
         }
-        if (!usage) continue;
-        totals.input += usage.input;
-        totals.output += usage.output;
-        totals.cacheRead += usage.cacheRead;
-        totals.cacheWrite += usage.cacheWrite;
-        totals.cost += usage.cost.total;
-      }
-      // 上下文占用（内置逻辑：压缩后 tokens 未知 → "?"）
-      const contextUsage = c?.getContextUsage();
-      const contextWindow = contextUsage?.contextWindow ?? c?.model?.contextWindow ?? 0;
-      const contextPercentValue = contextUsage?.percent ?? 0;
-      const contextPercent =
-        contextUsage?.percent == null ? "?" : contextPercentValue.toFixed(1);
-      const autoIndicator = " (auto)"; // ponytail: 内置 auto-compact 关闭时此处仍显示
-      const contextPercentDisplay =
-        contextPercent === "?"
-          ? `?/${formatTokens(contextWindow)}${autoIndicator}`
-          : `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
-      let contextPercentStr: string;
-      if (contextPercentValue > 90) contextPercentStr = theme.fg("error", contextPercentDisplay);
-      else if (contextPercentValue > 70) contextPercentStr = theme.fg("warning", contextPercentDisplay);
-      else contextPercentStr = contextPercentDisplay;
-      // pwd + git 分支 + 会话名
-      let pwd = formatCwdForFooter(sm?.getCwd() ?? "", process.env.HOME || process.env.USERPROFILE);
-      const branch = footerData.getGitBranch();
-      if (branch) pwd = `${pwd} (${branch})`;
-      const sessionName = sm?.getSessionName();
-      if (sessionName) pwd = `${pwd} • ${sessionName}`;
-      // 统计段
-      const statsParts: string[] = [];
-      if (totals.input) statsParts.push(`↑${formatTokens(totals.input)}`);
-      if (totals.output) statsParts.push(`↓${formatTokens(totals.output)}`);
-      if (totals.cacheRead) statsParts.push(`R${formatTokens(totals.cacheRead)}`);
-      if (totals.cacheWrite) statsParts.push(`W${formatTokens(totals.cacheWrite)}`);
-      if ((totals.cacheRead > 0 || totals.cacheWrite > 0) && latestCacheHitRate !== undefined) {
-        const precision = currentCfg?.cacheHitRatePrecision ?? 1;
-        statsParts.push(`CH${latestCacheHitRate.toFixed(precision)}%`);
-      }
-      // 订阅制 provider 无法从扩展读取 modelRuntime，退化为内置的特例
-      const usingSubscription = c?.model?.provider === "kimi-coding";
-      // 未配置模型只改 CH；金额符号和档位标签保持内置默认
-      const customPricing = getActiveModelPricing(currentCfg, c?.model);
-      const labelInfo = customPricing ? footerLabel : null;
-      // 漂移时标签转 warning 并加问号，金额前缀 ≈：宁可显示“可疑”，不静默显示错数字
-      const drift = customPricing ? footerDrift : false;
-      const labelText = labelInfo
-        ? drift
-          ? labelInfo.text.endsWith("）")
-            ? `${labelInfo.text.slice(0, -1)}?）`
-            : `${labelInfo.text}?`
-          : labelInfo.text
-        : "";
-      const labelStr = labelInfo ? colorize(theme, drift ? "warning" : labelInfo.color, labelText) : "";
-      if (totals.cost || usingSubscription) {
-        const symbol = customPricing?.currencySymbol ?? "$";
-        const costStr = `${drift ? "≈" : ""}${symbol}${totals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
-        statsParts.push(costStr + labelStr);
-      }
-      statsParts.push(contextPercentStr);
-      // 兜底：无计费段时标签置于统计段末尾
-      if (!(totals.cost || usingSubscription) && labelStr) statsParts.push(labelStr);
-      let statsLeft = statsParts.join(" ");
-      // 右侧：模型名 + thinking 档位 + 多 provider 前缀
-      const modelName = c?.model?.id || "no-model";
-      let statsLeftWidth = visibleWidth(statsLeft);
-      if (statsLeftWidth > width) {
-        statsLeft = truncateToWidth(statsLeft, width, "...");
-        statsLeftWidth = visibleWidth(statsLeft);
-      }
-      const minPadding = 2;
-      let rightSide: string = modelName;
-      if (c?.model?.reasoning) {
-        const thinkingLevel = c.thinkingLevel || "off";
-        rightSide =
-          thinkingLevel === "off" ? `${modelName} • thinking off` : `${modelName} • ${thinkingLevel}`;
-      }
-      if (footerData.getAvailableProviderCount() > 1 && c?.model) {
-        const withProvider = `(${c.model.provider}) ${rightSide}`;
-        if (statsLeftWidth + minPadding + visibleWidth(withProvider) <= width) rightSide = withProvider;
-      }
-      const rightSideWidth = visibleWidth(rightSide);
-      let statsLine: string;
-      if (statsLeftWidth + minPadding + rightSideWidth <= width) {
-        const padding = " ".repeat(width - statsLeftWidth - rightSideWidth);
-        statsLine = statsLeft + padding + rightSide;
-      } else {
-        const availableForRight = width - statsLeftWidth - minPadding;
-        if (availableForRight > 0) {
-          const truncatedRight = truncateToWidth(rightSide, availableForRight, "");
-          const padding = " ".repeat(Math.max(0, width - statsLeftWidth - visibleWidth(truncatedRight)));
-          statsLine = statsLeft + padding + truncatedRight;
-        } else {
-          statsLine = statsLeft;
+        try {
+          const result = patchFooterLines(lines, live, footerPatchOptions(), width);
+          if (!result.patched && !footerPatchWarned) {
+            // 内置布局变了（补丁打不上）→ 提醒一次，footer 本身仍由内置渲染
+            footerPatchWarned = true;
+            notifyOnce(
+              ctx,
+              "[pi-better-cost-display-footer] 内置 footer 布局已变，档位标签 / CH 精度等补丁未生效（其余显示正常）",
+            );
+          }
+          return result.lines;
+        } catch {
+          return lines; // 补丁出错 → 用内置原样，绝不让 footer 变空
         }
-      }
-      // 弱化：与内置一致，统计段与右侧分别包 dim；标签段用 \x1b[22m 退出 dim 保持原色
-      // ponytail: 依赖 SGR 22 重置亮度，若主题实现变化需同步
-      const dimStatsLeft = dimSkip(statsLeft, labelStr, theme);
-      const remainder = statsLine.slice(statsLeft.length);
-      const dimRemainder = theme.fg("dim", remainder);
-      const statsLineFinal = dimStatsLeft + dimRemainder;
-      const pwdLine = truncateToWidth(theme.fg("dim", pwd), width, theme.fg("dim", "..."));
-      const lines = [pwdLine, statsLineFinal];
-      // 扩展状态行（MCP 等），按键名排序
-      const extensionStatuses = footerData.getExtensionStatuses();
-      if (extensionStatuses.size > 0) {
-        const statusLine = Array.from(extensionStatuses.entries())
-          .sort(([a], [b]) => a.localeCompare(b))
-          .map(([, text]) => sanitizeStatusText(text))
-          .join(" ");
-        lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
-      }
-      return lines;
-    },
-  }));
+      },
+    };
+  });
+}
+
+/** 内置组件渲染抛错：一次性退化为 pi 自带 footer，不在每帧重试 */
+function disableFooter(ctx: ExtensionContext, err: unknown): void {
+  if (footerDisabled) return;
+  footerDisabled = true;
+  notifyOnce(
+    ctx,
+    `[pi-better-cost-display-footer] 复用内置 footer 失败，改用 pi 自带 footer：${
+      err instanceof Error ? err.message : String(err)
+    }`,
+  );
+  setTimeout(() => ctx.ui.setFooter(undefined), 0);
+}
+
+/** 当前帧的补丁内容（档位标签 / tok/s / 金额符号 / CH 精度） */
+function footerPatchOptions(): FooterPatchOptions {
+  const model = activeCtx?.model;
+  const customPricing = getActiveModelPricing(currentCfg, model);
+  const drift = customPricing ? footerDrift : false;
+  const info = customPricing ? footerLabel : null;
+  const text = info ? (drift ? driftLabelText(info.text) : info.text) : undefined;
+  return {
+    symbol: customPricing?.currencySymbol,
+    precision: currentCfg?.cacheHitRatePrecision,
+    approx: drift,
+    speed: formatSpeedPart(),
+    label: info && text ? { text, color: drift ? "warning" : info.color } : undefined,
+    contextBar: true,
+    branchStats: gitStats ?? null, // 抄 cc：分支后跟 git 变更行数
+    modelId: model?.id,
+    thinkingLevel: activeCtx?.thinkingLevel,
+  };
 }
 
 function apply(pi: ExtensionAPI, ctx: ExtensionContext): void {
@@ -828,6 +1289,8 @@ export default function (pi: ExtensionAPI): void {
         `tierFn: ${fnStatus}`,
         `守卫: ${appliedKey ? "已置位（配置与档位未变则不重注册）" : "未置位（下一轮重注册）"}`,
         `漂移重试: ${driftRetries}/${DRIFT_RETRY_LIMIT}`,
+        `速率折算: 思考 ${speedRatios().r.toFixed(2)} / 正文 ${speedRatios().o.toFixed(2)} 字符/token（真实 token 校准，初始 4）`,
+        `footer: ${baseFooterStatusText()}`,
         `最近注册: ${lastRegisterResult}`,
       ];
       const text = `[pi-better-cost-display-footer]\n${lines.join("\n")}`;
@@ -835,10 +1298,33 @@ export default function (pi: ExtensionAPI): void {
       else console.log(text);
     },
   });
-  pi.on("session_start", (_e, ctx) => {
+  pi.on("session_start", async (_e, ctx) => {
+    resetSpeedSession();
+    footerPatchWarned = false;
+    footerDisabled = false;
+    gitStats = undefined; // 会话可能换了仓库
+    // 加载 pi 自己的 footer 组件：拿不到就不覆盖（用 pi 自带 footer），不当“旧版复刻”卡着新 footer
+    await loadBaseFooter();
     installCustomFooter(ctx);
     apply(pi, ctx);
   });
+  // 速率事件：message_start 清累计（一次 LLM 调用内的估算不跨消息），
+  // message_update 累积流式增量，assistant message_end（工具执行前）用实际 output token 定稿
+  pi.on("message_start", (e) => {
+    if (e.message.role === "assistant") resetSpeedTurn();
+  });
+  // 定稿用 message_end（流式刚结束、工具还没跑）：用 turn_end 会把工具执行时长算进分母
+  pi.on("message_end", (e) => {
+    if (e.message.role !== "assistant") return;
+    const u = e.message.usage;
+    finishSpeedTurn(u?.output ?? 0, Date.now(), u?.reasoning ?? 0);
+  });
+  pi.on("message_update", (e) => {
+    const ev = e.assistantMessageEvent;
+    if (e.message.role !== "assistant" || !("delta" in ev)) return;
+    // 思考与正文分开入窗口：两段速度差一个数量级，混合平均没参考价值
+    pushSpeedDelta(ev.type === "thinking_delta" ? "r" : "o", ev.delta ?? "", Date.now());
+  });
   pi.on("session_shutdown", () => {
     // Pi invalidates session-bound ctx before the next footer render.
     activeCtx = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yalieny/pi-better-cost-display-footer",
-  "version": "2.1.2",
+  "version": "2.3.0",
   "description": "pi extension: scriptable peak/off-peak tier rules per provider with an enhanced footer (tier label, cache-hit-rate precision, custom currency symbol)",
   "keywords": [
     "pi-package",
@@ -9,7 +9,7 @@
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "test": "node --test test/tier.test.ts"
+    "test": "node --test test/tier.test.ts test/speed.test.ts test/footer-patch.test.ts"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",