@yalieny/pi-better-cost-display-footer 2.1.1 → 2.2.0

package/README.md

@@ -2,9 +2,11 @@
 
 pi 扩展:脚本化多段计价动态列表 + footer 增强。
 
-- **多段动态计价**:每个 provider 一个 `tierFn` 脚本函数(JS 表达式字符串)判定当前档位,**档位是任意字符串 id**(`peak` / `flat` / `valley` / `sharp`…),不绑定峰谷语义;在 `session_start` 和每次发送消息时重注册 provider 的 `cost`(仅影响 pi 本地用量统计)。
+- **多段动态计价**:每个 provider 一个 `tierFn` 脚本函数(JS 表达式字符串)判定当前档位,**档位是任意字符串 id**(`peak` / `flat` / `valley` / `sharp`…),不绑定峰谷语义;在 `session_start`、每次发送消息、每次 LLM 调用前重注册 provider 的 `cost`(仅影响 pi 本地用量统计)。
+- **计费自愈**:每轮比对期望 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` 格式(语义不变)。
 
@@ -85,10 +87,19 @@ pi install npm:@yalieny/pi-better-cost-display-footer
 
 该命令把抓取官方价目页、解析价格、更新配置文件的完整任务交给 agent 执行(自然语言指令,无需手动维护价格表)。命令会告知 agent 配置文件位置与 JSON 格式;agent 抓取 [DeepSeek 官方价目页](https://api-docs.deepseek.com/zh-cn/quick_start/pricing) 后更新 `providers.deepseek.models` 下各模型的分档价格,其余字段不动。
 
+## 计价诊断
+
+```bash
+/cost-tier
+```
+
+只读打印当前模型的档位状态:档位、期望费率 vs 实际计费费率、是否漂移、tierFn 编译状态、注册守卫与重试预算、最近一次注册结果。扩展的 `console.error` 在 TUI 下不落盘,排查"标签与金额不符"时用这条命令而不是猜。
+
 ## 测试
 
 ```bash
-npm install && npm test
+npm install && npm test                                  # 纯函数单测(档位判定 / 漂移判定)
+node --experimental-strip-types test/drift-probe.ts      # 端到端:守卫重试与自愈(用系统临时目录隔离配置)
 ```
 
 ## 说明
@@ -97,3 +108,8 @@ npm install && npm test
 - provider 必须在 `models.json` 中有定义;未列出的模型保持原价。
 - 模型缺少当前档位价格时保持原价并打日志。
 - cost 仅影响 pi 本地用量统计,不影响 API 实际账单。
+
+## 变更记录
+
+- **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

@@ -7,6 +7,11 @@
 // 的每次调用）按各 provider 的 tierFn 脚本函数计算当前档位并重注册其 cost，对齐按调用时刻计费。
 // effectiveFrom（含）之前不做任何事。
 //
+// 守卫按“状态”而非“档位字符串”判定：每轮比对期望 cost（配置 × 当前档位）与实际 cost
+// （ctx.model.cost，真正参与计费的对象）。不一致 → 重注册当前 provider 自愈（最多 3 次），
+// 重试用尽仍不符 → footer 显示 ≈ + 标签加 ? 显式告警。注册失败不写守卫，下一轮重试。
+// /cost-tier 命令只读打印上述状态。
+//
 // 档位 = 任意字符串 id（如 "peak" / "flat" / "valley" / "sharp"），不绑定峰值/谷值语义：
 // {
 //   "timezone": "Asia/Shanghai",                  // 计费时区，默认 Asia/Shanghai
@@ -169,7 +174,16 @@ const DEFAULT_CONFIG: DynamicConfig = {
   },
 };
 
-let lastAppliedKey: string | null = null;
+/** 注册守卫：只在全部注册成功时写入，失败保持旧值 → 下一轮 key 不等自动重试 */
+let appliedKey: string | null = null;
+/** 同一漂移状态的连续重注册次数，超 DRIFT_RETRY_LIMIT 后只告警不再重试 */
+let driftRetries = 0;
+/** 最近一次提醒的失败文案，变化时才弹，避免每轮抖动 */
+let lastErrorText: string | null = null;
+/** 最近一次注册结果，供 /cost-tier 诊断 */
+let lastRegisterResult = "尚未注册";
+/** 当前模型计费 cost 与档位不符，footer 降级显示（≈ + 标签加 ?） */
+let footerDrift = false;
 /** 最近一次事件的 ctx，footer 闭包读取；随 input/model_select 事件刷新 */
 let activeCtx: ExtensionContext | null = null;
 /** 当前生效配置，apply() 时刷新，footer 每帧直接读，避免频繁读盘 */
@@ -177,6 +191,212 @@ let currentCfg: DynamicConfig | null = null;
 /** 当前档位标签（null = 不显示），apply() 时刷新 */
 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;
+  lastErrorText = text;
+  if (ctx.mode === "tui") ctx.ui.notify(text, "warning");
+  else console.error(text);
+}
+
 /** 深合并：文件配置覆盖内置默认（全局 + provider + model 三级），部分配置文件也能生效 */
 function mergeConfig(base: DynamicConfig, override: DynamicConfig): DynamicConfig {
   const merged: DynamicConfig = { ...base, ...override };
@@ -443,23 +663,98 @@ function dimSkip(text: string, marker: string, theme: Theme): string {
   );
 }
 
+/** 本插件视角下的模型对象子集（pi 的 Model 结构兼容，cost 只看四段扁平价） */
+interface ModelLike {
+  provider: string;
+  id: string;
+  cost?: TierRates;
+}
+
 /** 读取当前模型的生效 provider 配置；未配置 / 未生效 → null。 */
 function getActiveModelPricing(
   cfg: DynamicConfig | null,
-  ctx: ExtensionContext | null,
+  model: ModelLike | undefined,
+  date: Date = new Date(),
 ): ProviderPricing | null {
-  const model = ctx?.model;
-  const provider = model && cfg?.providers?.[model.provider];
-  if (!model || !provider || !provider.models[model.id] || !isEffective(provider)) return null;
+  const provider = model ? cfg?.providers?.[model.provider] : undefined;
+  if (!model || !provider || !provider.models[model.id] || !isEffective(provider, date)) return null;
   return provider;
 }
 
-/** 计算档位标签；当前模型无动态计价配置 / 配置缺失 / 未生效 / 档位未配置标签 → null */
-function computeFooterLabel(cfg: DynamicConfig | null, ctx: ExtensionContext | null): FooterLabel | null {
-  const provider = getActiveModelPricing(cfg, ctx);
-  if (!provider) return null;
-  const tier = currentTier(provider);
-  return provider.labels?.[tier] ?? DEFAULT_LABELS[tier] ?? null;
+/**
+ * 费率比较：浮点相对容差 1e-9，避免 JSON round-trip 造成误判漂移。
+ * ponytail: 只比四段扁平价。pi 的 ModelCost 还有请求级 tiers（本插件不产出该字段），
+ * 若将来支持分档价，这里要按 tier 逐段比较。
+ */
+export function sameRates(a: TierRates, b: TierRates | undefined): boolean {
+  if (!b) return false;
+  return (["input", "output", "cacheRead", "cacheWrite"] as const).every((k) => {
+    const want = a[k];
+    const have = b[k] as number | undefined;
+    if (typeof have !== "number") return false;
+    return Math.abs(want - have) <= 1e-9 * Math.max(Math.abs(want), Math.abs(have), 1);
+  });
+}
+
+/** 计费与档位不符：期望 = 配置 × 当前档位，实际 = 会话模型对象的 cost（真正参与计费的那个） */
+interface CostDrift {
+  providerId: string;
+  tier: Tier;
+  want: TierRates;
+  have: TierRates;
+}
+
+/** 当前模型的档位状态（一次 currentTier 判定，标签 / 漂移 / 诊断共用） */
+interface PricingState {
+  /** 生效的 provider 配置；该模型不归本插件管 → null */
+  provider: ProviderPricing | null;
+  /** 期望档位；同上 → null */
+  tier: Tier | null;
+  /** 期望费率；该模型该档位未配价 → null（保持原价，不算漂移） */
+  rates: TierRates | null;
+  /** 实际计费 cost 与期望费率不符 → 详情 */
+  drift: CostDrift | null;
+}
+
+function pricingState(
+  cfg: DynamicConfig | null,
+  model: ModelLike | undefined,
+  date: Date = new Date(),
+): PricingState {
+  const provider = getActiveModelPricing(cfg, model, date);
+  if (!provider || !model) return { provider: null, tier: null, rates: null, drift: null };
+  const tier = currentTier(provider, date);
+  const want = provider.models[model.id]?.[tier];
+  const have = model.cost;
+  const drift = want && have && !sameRates(want, have)
+    ? { providerId: model.provider, tier, want, have }
+    : null;
+  return { provider, tier, rates: want ?? null, drift };
+}
+
+/** 当前模型应有的费率（provider 未配置 / 未生效 / 该模型或该档位缺价 → null） */
+export function expectedRatesForModel(
+  cfg: DynamicConfig | null,
+  model: ModelLike | undefined,
+  date: Date = new Date(),
+): { tier: Tier; rates: TierRates } | null {
+  const st = pricingState(cfg, model, date);
+  return st.tier && st.rates ? { tier: st.tier, rates: st.rates } : null;
+}
+
+/** 漂移判定：有期望费率且与实际 cost 不等 → 详情；一致或不归本插件管 → null */
+export function detectCostDrift(
+  cfg: DynamicConfig | null,
+  model: ModelLike | undefined,
+  date: Date = new Date(),
+): CostDrift | null {
+  return pricingState(cfg, model, date).drift;
+}
+
+/** 档位标签；当前模型无动态计价配置 / 该档位未配置标签 → null */
+function computeFooterLabel(st: PricingState): FooterLabel | null {
+  if (!st.provider || !st.tier) return null;
+  return st.provider.labels?.[st.tier] ?? DEFAULT_LABELS[st.tier] ?? null;
 }
 
 function installCustomFooter(ctx: ExtensionContext): void {
@@ -522,15 +817,27 @@ function installCustomFooter(ctx: ExtensionContext): void {
         const precision = currentCfg?.cacheHitRatePrecision ?? 1;
         statsParts.push(`CH${latestCacheHitRate.toFixed(precision)}%`);
       }
+      // tok/s：⚡ 常显；流式中为当前相位实时值（r 思考 / o 正文），空闲/工具执行时为定稿三档
+      const speedPart = formatSpeedPart();
+      if (speedPart) statsParts.push(speedPart);
       // 订阅制 provider 无法从扩展读取 modelRuntime，退化为内置的特例
       const usingSubscription = c?.model?.provider === "kimi-coding";
       // 未配置模型只改 CH；金额符号和档位标签保持内置默认
-      const customPricing = getActiveModelPricing(currentCfg, c);
+      const customPricing = getActiveModelPricing(currentCfg, c?.model);
       const labelInfo = customPricing ? footerLabel : null;
-      const labelStr = labelInfo ? colorize(theme, labelInfo.color, labelInfo.text) : "";
+      // 漂移时标签转 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 = `${symbol}${totals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
+        const costStr = `${drift ? "≈" : ""}${symbol}${totals.cost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
         statsParts.push(costStr + labelStr);
       }
       statsParts.push(contextPercentStr);
@@ -596,29 +903,61 @@ function apply(pi: ExtensionAPI, ctx: ExtensionContext): void {
   activeCtx = ctx;
   const cfg = loadDynamicConfig();
   currentCfg = cfg;
-  footerLabel = computeFooterLabel(cfg, ctx);
-  if (!cfg) return;
+  if (!cfg) {
+    footerLabel = null;
+    footerDrift = false;
+    return;
+  }
+  // 核心：以“实际计费 cost”为准，而不是以“档位字符串有没有变”为准
+  // 注：不能就地把费率写回 ctx.model.cost —— pi 的 model 对象被 Object.freeze（实测
+  // "Cannot assign to read only property"），且事件 ctx 无 setModel（只读 model）。
+  // 写进“参与计费的那个对象”的唯一通道就是 registerProvider → _refreshCurrentModelFromRegistry()。
+  const state = pricingState(cfg, ctx.model);
+  footerLabel = computeFooterLabel(state);
+  footerDrift = state.drift !== null;
+  const drift = state.drift;
   const providerTiers = Object.entries(cfg.providers || {}).map(([providerId, provider]) => {
     const tier = isEffective(provider) ? currentTier(provider) : null;
     return [providerId, tier] as const;
   });
   const key = `${JSON.stringify(cfg)}|${JSON.stringify(providerTiers)}`;
-  if (key === lastAppliedKey) return;
-  // 动态计价对所有配置了 providers 的模型生效（不限定 deepseek）
+  const keyChanged = key !== appliedKey;
+  // 预算复位：配置/档位变了（新状态）或已一致（收敛）
+  if (keyChanged || !drift) driftRetries = 0;
+  if (!keyChanged) {
+    if (!drift) return; // 正常路径：档位未变且计费一致 → 零开销
+    // 同一漂移状态重试用尽 → 不再每轮抖，转由 footer 告警
+    if (driftRetries >= DRIFT_RETRY_LIMIT) return;
+  }
+  // 只统计“漂移驱动”的重试：key 变化那轮本就要全量重注册，不该占预算
+  if (!keyChanged && drift) driftRetries++;
+
+  let allOk = true;
+  const touched: string[] = [];
   for (const [providerId, tier] of providerTiers) {
     if (!tier) continue;
+    // key 变了：全部重注册（与旧版一致）；只有漂移：只重注册当前模型的 provider
+    if (!keyChanged && providerId !== drift?.providerId) continue;
     try {
       const config = patchProviderConfig(cfg, providerId, tier);
+      // provider 不在 models.json 是永久配置态，不是瞬时失败，不阻塞守卫
       if (!config) continue;
       pi.registerProvider(providerId, config);
+      touched.push(`${providerId} → ${tier}`);
       console.log(`[pi-better-cost-display-footer] ${providerId} → ${tier}`);
     } catch (err) {
-      console.error(
-        `[pi-better-cost-display-footer] ${providerId} 注册失败: ${err instanceof Error ? err.message : String(err)}`,
-      );
+      allOk = false;
+      const msg = `${providerId} 注册失败: ${err instanceof Error ? err.message : String(err)}`;
+      lastRegisterResult = msg;
+      notifyOnce(ctx, `[pi-better-cost-display-footer] ${msg}`);
     }
   }
-  lastAppliedKey = key;
+  if (touched.length) lastRegisterResult = `${touched.join(", ")} @ 成功`;
+  // 失败不写守卫 → 下一轮自动重试（修 A）；恢复后允许同类故障再次告警
+  if (allOk) {
+    appliedKey = key;
+    lastErrorText = null; // 恢复后允许同类故障再次告警
+  }
 }
 
 export default function (pi: ExtensionAPI): void {
@@ -662,10 +1001,61 @@ export default function (pi: ExtensionAPI): void {
       );
     },
   });
+  // 只读诊断。本次排障最大成本是“扩展 stderr 无落盘 + 状态不可观测”，命令把它们摊开
+  pi.registerCommand("cost-tier", {
+    description: "打印当前模型的计价档位诊断：期望费率 vs 实际计费费率、是否漂移、最近注册结果",
+    handler: async (_args, ctx) => {
+      const cfg = currentCfg ?? loadDynamicConfig();
+      const m = ctx.model;
+      const st = pricingState(cfg, m);
+      const fmt = (r: TierRates | null | undefined) =>
+        r ? `${r.input}/${r.output}/${r.cacheRead}/${r.cacheWrite}` : "—";
+      const fnSrc = m ? cfg?.providers?.[m.provider]?.tierFn : undefined;
+      const fnStatus = !fnSrc
+        ? "未配置（走 peakWindows / defaultTier）"
+        : tierFnCache.get(fnSrc) === null
+          ? "编译失败 → 回退 defaultTier"
+          : "OK";
+      const lines = [
+        `模型: ${m ? `${m.provider}/${m.id}` : "无"}`,
+        `配置: ${existsSync(CONFIG_FILE) ? CONFIG_FILE : `${CONFIG_FILE}（不存在，用内置默认）`}`,
+        `档位: ${st.tier ?? "不归本插件管（未配置 / 未生效 / 该模型无价）"}`,
+        `期望费率 in/out/cR/cW: ${fmt(st.rates)}`,
+        `实际 cost  in/out/cR/cW: ${fmt(m?.cost)}`,
+        `漂移: ${st.drift ? "是（计费与档位不符）" : m?.cost ? "否" : "—"}`,
+        `tierFn: ${fnStatus}`,
+        `守卫: ${appliedKey ? "已置位（配置与档位未变则不重注册）" : "未置位（下一轮重注册）"}`,
+        `漂移重试: ${driftRetries}/${DRIFT_RETRY_LIMIT}`,
+        `速率折算: 思考 ${speedRatios().r.toFixed(2)} / 正文 ${speedRatios().o.toFixed(2)} 字符/token（真实 token 校准，初始 4）`,
+        `最近注册: ${lastRegisterResult}`,
+      ];
+      const text = `[pi-better-cost-display-footer]\n${lines.join("\n")}`;
+      if (ctx.mode === "tui") ctx.ui.notify(text, "info");
+      else console.log(text);
+    },
+  });
   pi.on("session_start", (_e, ctx) => {
+    resetSpeedSession();
     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;
@@ -673,7 +1063,7 @@ export default function (pi: ExtensionAPI): void {
   pi.on("input", (_e, ctx) => apply(pi, ctx));
   // 切换模型时刷新档位标签（深色/深绿 ⇄ 其他模型）
   pi.on("model_select", (_e, ctx) => apply(pi, ctx));
-  // 每个 LLM 调用（含工具循环内的每次调用）开始前按调用时刻重算档位，对齐按调用点计费；
-  // lastAppliedKey 守卫保证档位未变时零开销。
+  // 每个 LLM 调用（含工具循环内的每次调用）开始前重算档位，对齐按调用点计费；
+  // 守卫 = 配置/档位 key 未变 且 实际 cost 与期望一致 → O(1) 返回，保证正常路径零开销。
   pi.on("turn_start", (_e, ctx) => apply(pi, ctx));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yalieny/pi-better-cost-display-footer",
-  "version": "2.1.1",
+  "version": "2.2.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"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",