switchroom 0.19.1 → 0.19.2

package/telegram-plugin/hooks/subagent-tracker-pretool.mjs

@@ -360,6 +360,22 @@ function main() {
   }
 
   const input = event.tool_input ?? {}
+  // F3 (progress-card fork model): a FORK dispatch (`subagent_type === 'fork'`)
+  // inherits the PARENT session's model and IGNORES any `tool_input.model`
+  // override. Seeding the row's first-paint model from that ignored override
+  // makes the worker card show a WRONG model (e.g. "sonnet" while the fork
+  // actually runs Opus) until the watcher overwrites it from the fork's own
+  // transcript. Suppress the dispatch-time seed for forks — leave model NULL so
+  // the card omits the model rather than showing a value the fork won't honor;
+  // the transcript-sourced model then paints as soon as the first assistant
+  // line lands (transcript wins, exactly as for non-fork workers). Fixing it at
+  // the seed source (not downstream in worker-feed-dispatch) keeps the
+  // transcript-confirmed model flowing to the terminal card unchanged.
+  const isFork = input.subagent_type === 'fork'
+  const dispatchModel =
+    !isFork && typeof input.model === 'string' && input.model.length > 0
+      ? input.model
+      : null
   // Resolve parent_turn_key from the live turn-active marker (the turn whose
   // tool call is dispatching this sub-agent). Claude Code's PreToolUse payload
   // carries only its own session id, never the gateway-minted Telegram turn_key
@@ -384,8 +400,9 @@ function main() {
       // BEFORE the sub-agent writes its first assistant line. Persisted so the
       // card can render the model from dispatch; the watcher later overwrites it
       // from the worker's own transcript (transcript wins). Only a non-empty
-      // string is stored — never guess from config.
-      model: typeof input.model === 'string' && input.model.length > 0 ? input.model : null,
+      // string is stored — never guess from config. NULL for a fork dispatch,
+      // which ignores the model override (see dispatchModel above, F3).
+      model: dispatchModel,
       now: Date.now(),
     },
     (err) => {

package/telegram-plugin/quota-bar-format.ts

@@ -42,6 +42,7 @@ import type { AccountState, ListStateData } from '../src/auth/broker/client.js';
 import { reviveLastQuota, recommendation, type AccountSnapshot } from './auth-snapshot-format.js';
 import { escapeMarkdown } from './card-format.js';
 import { maskEmail } from './demo-mask.js';
+import { formatExternalSpendBlock } from './external-spend.js';
 
 // ── dot thresholds ───────────────────────────────────────────────────
 
@@ -257,6 +258,17 @@ export interface UsageCardRenderOpts extends QuotaBarRenderOpts {
    * because in that case there IS real data, just stale.
    */
   probeFailed?: boolean;
+  /**
+   * Optional External (OpenRouter / non-Claude cash) spend block — layout B
+   * (operator-locked 2026-07-19). When null/undefined the block is omitted
+   * entirely (no error rows). When present (including $0.00), bullets land
+   * after the recommendation and before the freshness footer.
+   */
+  externalSpend?: {
+    day24hUsd: number;
+    day7dUsd: number;
+    top: Array<{ label: string; usd: number }>;
+  } | null;
 }
 
 /**
@@ -342,6 +354,12 @@ export function renderUsageCard(
   const lines = [bar];
   // Actionable cross-account verdict — restored from renderAuthSnapshotFormat2.
   lines.push(`_${recommendation(snapshots, now, demo)}_`);
+  // External cash spend (OpenRouter / non-Claude) — layout B. Omitted when
+  // the caller could not fetch a summary (null/undefined: no admin key,
+  // timeout, error). Present summary including $0.00 still renders.
+  if (opts.externalSpend != null) {
+    lines.push(...formatExternalSpendBlock(opts.externalSpend));
+  }
   // Freshness signal: stale-cache warning takes precedence over a live stamp,
   // which takes precedence over an explicit probe-failed marker (no live data
   // AND no cache — the card is showing "⚠️ no data" rows, so "Live" would be

package/telegram-plugin/quota-check.ts

@@ -252,11 +252,26 @@ export function formatQuotaBlock(q: QuotaUtilization, now: Date = new Date()): s
   const lines: string[] = [];
   lines.push("**Claude plan quota**");
   lines.push("");
+  // #2494 Bug C / adversarial-review F3 — a window whose utilization header
+  // was absent (a thin probe) has a numeric field that coalesced to 0, so a
+  // naive `${pct}%` renders a confident `0%` indistinguishable from a genuine
+  // fresh-account 0%. The modern bar card (quota-bar-format.ts ~200) already
+  // renders these as "no data"; backport that honesty here. The presence
+  // markers are optional — `undefined` means a legacy/real probe (render the
+  // percent); only an explicit `false` suppresses the number.
+  const fiveHour =
+    q.fiveHourUtilPresent === false
+      ? "no data"
+      : `\`${Math.round(q.fiveHourUtilizationPct)}%\``;
+  const sevenDay =
+    q.sevenDayUtilPresent === false
+      ? "no data"
+      : `\`${Math.round(q.sevenDayUtilizationPct)}%\``;
   lines.push(
-    `**5h window**  \`${Math.round(q.fiveHourUtilizationPct)}%\` · \`${formatResetRelative(q.fiveHourResetAt, now)}\``,
+    `**5h window**  ${fiveHour} · \`${formatResetRelative(q.fiveHourResetAt, now)}\``,
   );
   lines.push(
-    `**7d window**  \`${Math.round(q.sevenDayUtilizationPct)}%\` · \`${formatResetRelative(q.sevenDayResetAt, now)}\``,
+    `**7d window**  ${sevenDay} · \`${formatResetRelative(q.sevenDayResetAt, now)}\``,
   );
   if (q.representativeClaim) {
     lines.push("");

package/telegram-plugin/tests/activity-card-wiring.test.ts

@@ -58,6 +58,53 @@ describe('activity-card durability wiring', () => {
     expect(recordCode).not.toMatch(/pinned: true/)
   })
 
+  // F6 (persist-intent-first ordering): the durable record must be written in
+  // the SAME synchronous block as the send, BEFORE the status-pin reconcile and
+  // with NO `await` between the send resolving and the persist — otherwise the
+  // crash window in which a sent card has no reapable record reopens. Structural
+  // lock (the gateway IIFE can't be instantiated in-process); complements the
+  // behavioural store/reaper tests in activity-card-store.test.ts.
+  it('(F6) persists the record BEFORE the status-pin reconcile, with no await between send and persist', () => {
+    const openBranch = between(
+      laneSrc,
+      'if (turn.activityMessageId == null) {',
+      'turn.activityLastSentRender = target',
+    )
+    const persistIdx = openBranch.indexOf('writeActivityCardRecord(')
+    const pinIdx = openBranch.indexOf('void reconcileStatusPin(')
+    expect(persistIdx).toBeGreaterThanOrEqual(0)
+    expect(pinIdx).toBeGreaterThanOrEqual(0)
+    // Persist-intent-first: the record write precedes the pin reconcile.
+    expect(persistIdx).toBeLessThan(pinIdx)
+    // No `await` sits between the send returning and the persist — the whole
+    // window from `const sent =` to writeActivityCardRecord( is synchronous.
+    const sendToPersist = between(openBranch, 'const sent = await robustApiCall', 'writeActivityCardRecord(')
+    const codeOnly = sendToPersist
+      .split('\n')
+      .filter((l) => !l.trim().startsWith('//') && !l.trim().startsWith('*'))
+      .join('\n')
+    expect(codeOnly).not.toMatch(/\bawait\b/)
+  })
+
+  // F5 (persist-intent honesty): the persisted `pinned` mirrors the ACTUAL pin
+  // decision (PIN_STATUS_WHILE_WORKING), never a bare `pinned: true`. This is
+  // also asserted in the OPEN test above; kept as a named F5 lock so a rename or
+  // refactor that reintroduces an unconditional `pinned: true` is caught here too.
+  it('(F5) the persisted record mirrors the real pin decision, not an unconditional pinned:true', () => {
+    const openBranch = between(
+      laneSrc,
+      'if (turn.activityMessageId == null) {',
+      'turn.activityLastSentRender = target',
+    )
+    const recordBlock = between(openBranch, 'writeActivityCardRecord(', 'void reconcileStatusPin(')
+    const recordCode = recordBlock
+      .split('\n')
+      .filter((l) => !l.trim().startsWith('//'))
+      .join('\n')
+    expect(recordCode).toMatch(/pinned: PIN_STATUS_WHILE_WORKING/)
+    expect(recordCode).not.toMatch(/pinned: true/)
+  })
+
   it('the normal-CLOSE path clears the durable handle, id-scoped (reap-race guard)', () => {
     const closeBody = between(
       laneSrc,

package/telegram-plugin/tests/external-spend.test.ts

@@ -0,0 +1,168 @@
+/**
+ * Unit tests for External OpenRouter/$ spend (layout B on /usage).
+ * Pure filter/format coverage lives primarily in
+ * `src/litellm/external-spend.test.ts`. This file covers the card
+ * block formatter + broker-backed fetch ExternalSpendSummary path.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  formatExternalSpendBlock,
+  fetchExternalSpendSummary,
+  clearExternalSpendCache,
+  formatUsd,
+  isExternalModel,
+  shortModelLabel,
+  summarizeExternalSpend,
+} from '../external-spend.js';
+import { renderUsageCard } from '../quota-bar-format.js';
+import type { AccountSnapshot } from '../auth-snapshot-format.js';
+import type { QuotaUtilization } from '../quota-check.js';
+
+const NOW = new Date('2026-07-19T15:30:00.000Z');
+
+beforeEach(() => {
+  clearExternalSpendCache();
+});
+
+describe('re-exported pure helpers', () => {
+  it('filter / labels / money still work from the telegram module', () => {
+    expect(isExternalModel('openrouter/openai/gpt-oss-20b')).toBe(true);
+    expect(isExternalModel('claude-sonnet-5')).toBe(false);
+    expect(shortModelLabel('openrouter/x-ai/grok-4.5')).toBe('grok-4.5');
+    expect(formatUsd(8.07)).toBe('$8.07');
+    const s = summarizeExternalSpend(
+      [
+        {
+          startTime: '2026-07-19',
+          models: { 'openrouter/openai/gpt-oss-20b': 1.5, 'claude-sonnet-5': 9 },
+        },
+      ],
+      NOW,
+    );
+    expect(s.day24hUsd).toBeCloseTo(1.5, 5);
+  });
+});
+
+describe('formatExternalSpendBlock', () => {
+  it('renders locked layout B', () => {
+    expect(
+      formatExternalSpendBlock({
+        day24hUsd: 8.07,
+        day7dUsd: 119.89,
+        top: [
+          { label: 'gpt-oss-20b', usd: 6.1 },
+          { label: 'grok-4.5', usd: 1.18 },
+          { label: 'gemini-3.1-flash-lite', usd: 0.79 },
+        ],
+      }),
+    ).toEqual([
+      '- 💸 External',
+      '- 24h `$8.07` · 7d `$119.89`',
+      '- top `gpt-oss-20b $6.10` · `grok-4.5 $1.18` · `gemini-3.1-flash-lite $0.79`',
+    ]);
+  });
+
+  it('omits top and returns [] for null', () => {
+    expect(formatExternalSpendBlock({ day24hUsd: 0, day7dUsd: 0, top: [] })).toEqual([
+      '- 💸 External',
+      '- 24h `$0.00` · 7d `$0.00`',
+    ]);
+    expect(formatExternalSpendBlock(null)).toEqual([]);
+  });
+});
+
+describe('fetchExternalSpendSummary (broker path)', () => {
+  it('returns null when broker says unavailable', async () => {
+    const s = await fetchExternalSpendSummary({
+      getExternalSpend: async () => ({ available: false, reason: 'master_key_unavailable' }),
+      bypassCache: true,
+    });
+    expect(s).toBeNull();
+  });
+
+  it('maps available broker payload + caches', async () => {
+    let calls = 0;
+    const getExternalSpend = vi.fn(async () => {
+      calls += 1;
+      return {
+        available: true,
+        day24hUsd: 1.5,
+        day7dUsd: 10,
+        top: [{ label: 'gpt-oss-20b', usd: 1.5 }],
+        served: 'live' as const,
+        capturedAtMs: Date.now(),
+      };
+    });
+    const first = await fetchExternalSpendSummary({
+      getExternalSpend,
+      bypassCache: true,
+    });
+    expect(first).toEqual({
+      day24hUsd: 1.5,
+      day7dUsd: 10,
+      top: [{ label: 'gpt-oss-20b', usd: 1.5 }],
+    });
+    const second = await fetchExternalSpendSummary({ getExternalSpend });
+    expect(second?.day24hUsd).toBeCloseTo(1.5, 5);
+    expect(calls).toBe(1);
+  });
+
+  it('returns null on thrown broker error', async () => {
+    const s = await fetchExternalSpendSummary({
+      getExternalSpend: async () => {
+        throw new Error('unreachable');
+      },
+      bypassCache: true,
+    });
+    expect(s).toBeNull();
+  });
+});
+
+describe('renderUsageCard + externalSpend', () => {
+  function quota(part: Partial<QuotaUtilization>): QuotaUtilization {
+    return {
+      fiveHourUtilizationPct: 0,
+      sevenDayUtilizationPct: 0,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+      ...part,
+    };
+  }
+  const snapshots: AccountSnapshot[] = [
+    {
+      label: 'ken@example.com',
+      isActive: true,
+      quota: quota({
+        fiveHourUtilizationPct: 0,
+        sevenDayUtilizationPct: 47,
+        fiveHourResetAt: new Date(NOW.getTime() + 60 * 60_000),
+        sevenDayResetAt: new Date(NOW.getTime() + (3 * 24 + 1) * 60 * 60_000),
+      }),
+    },
+  ];
+  const exhausted = new Map<string, boolean>([['ken@example.com', false]]);
+
+  it('inserts External between recommendation and freshness', () => {
+    const out = renderUsageCard(snapshots, exhausted, {
+      now: NOW,
+      externalSpend: {
+        day24hUsd: 8.07,
+        day7dUsd: 119.89,
+        top: [{ label: 'gpt-oss-20b', usd: 6.1 }],
+      },
+    });
+    const lines = out.split('\n');
+    const recIdx = lines.findIndex((l) => l.includes('Recommendation'));
+    const extIdx = lines.findIndex((l) => l.includes('💸 External'));
+    expect(extIdx).toBe(recIdx + 1);
+    expect(lines[lines.length - 1]).toBe('_Live_');
+  });
+
+  it('omits External when null', () => {
+    const out = renderUsageCard(snapshots, exhausted, { now: NOW, externalSpend: null });
+    expect(out).not.toContain('💸 External');
+  });
+});

package/telegram-plugin/tests/gateway-session-model-relaunch.test.ts

@@ -16,8 +16,13 @@ import { describe, it, expect } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 import { dirname, resolve } from 'node:path'
+import { SESSION_MODEL_FILE } from '../gateway/session-model-file.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
+const MODEL_COMMAND_SRC = readFileSync(
+  resolve(__dirname, '../gateway/model-command.ts'),
+  'utf8',
+)
 const GATEWAY_SRC = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf8')
 
 describe('gateway: the .relaunch-model-intent subsystem is retired (rev 4)', () => {
@@ -148,44 +153,47 @@ describe('gateway boot: session-model re-hydration + confirmation + alert relay'
   })
 
   it('logs the applied model for diagnosability (F1)', () => {
-    expect(GATEWAY_SRC).toContain('gw /model relaunch applied agent=')
+    expect(GATEWAY_SRC).toContain('formatModelRelaunchDiagLog')
     expect(GATEWAY_SRC).toContain('gw /model relaunch scheduled agent=')
+    expect(MODEL_COMMAND_SRC).toContain('gw /model relaunch applied agent=')
+  })
+
+  it('logs outcome KIND explicitly on /model switch rehydration (NOT-APPLIED vs applied vs default)', () => {
+    // Formatters live in model-command.ts (gateway line-ratchet); gateway only calls them.
+    expect(GATEWAY_SRC).toContain('formatModelRelaunchDiagLog')
+    expect(GATEWAY_SRC).toContain('formatModelSwitchConfirmationBody')
+    expect(GATEWAY_SRC).toContain('formatModelRelaunchSuppressNotAppliedLog')
+    expect(MODEL_COMMAND_SRC).toContain('gw /model relaunch NOT-APPLIED agent=')
+    expect(MODEL_COMMAND_SRC).toContain('override=set outcome=applied')
+    expect(MODEL_COMMAND_SRC).toContain('override=cleared outcome=default')
+    expect(MODEL_COMMAND_SRC).toContain('gw /model relaunch NOT-APPLIED — suppressing not-applied confirmation')
   })
 
   it('sends ONE switch-confirmation from the ACTUAL launched model, keyed on the /model reason (F1/N4)', () => {
     const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
     expect(idx).toBeGreaterThan(0)
-    const win = GATEWAY_SRC.slice(idx, idx + 5200)
-    // Keyed on the deterministic /model switch reason, so it also fires on a
-    // launched===configured apply-boot (/model default) — N4. Never optimistic.
-    expect(win).toContain('if (modelSwitchReason != null && modelSwitchMarkerChat)')
-    expect(win).toContain('✅ Now running')
-    // N4: the launched===configured branch still confirms.
-    expect(win).toContain('(the configured default)')
+    const win = GATEWAY_SRC.slice(idx, idx + 2500)
+    expect(win).toContain('if (confirmation != null && modelSwitchMarkerChat)')
+    expect(win).toContain('formatModelSwitchConfirmationBody')
+    expect(MODEL_COMMAND_SRC).toContain('✅ Now running')
+    expect(MODEL_COMMAND_SRC).toContain('(the configured default)')
   })
 
   it('warns instead of a green ✅ when a non-default switch silently reverted to the default (silent-revert fix)', () => {
-    const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
-    const win = GATEWAY_SRC.slice(idx, idx + 5200)
-    // The confirmation card is derived from the pure classifier, not an inline
-    // isApplyBoot ternary — so a reverted non-default switch yields the ⚠️ card.
-    expect(win).toContain('classifyModelSwitchConfirmation({')
-    expect(win).toContain("confirmation.kind === 'applied'")
-    expect(win).toContain("confirmation.kind === 'not-applied'")
-    expect(win).toContain("⚠️ Your switch to")
-    expect(win).toContain("didn't apply")
-    // LOW-3: the re-issue hint interpolates the target inside backticks so a
-    // token containing Markdown metachars can't italicize / 400 the send.
-    expect(win).toContain('Re-issue \\`/model ${confirmation.target}\\`')
+    expect(GATEWAY_SRC).toContain('classifyModelSwitchConfirmation({')
+    expect(GATEWAY_SRC).toContain('formatModelSwitchConfirmationBody')
+    expect(MODEL_COMMAND_SRC).toContain('⚠️ Your switch to')
+    expect(MODEL_COMMAND_SRC).toContain("didn't apply")
+    // LOW-3: re-issue hint keeps target in backticks
+    expect(MODEL_COMMAND_SRC).toContain('Re-issue `/model ')
   })
 
   it('dedups the not-applied card against a tailored .session-model-alert (LOW-2)', () => {
     const idx = GATEWAY_SRC.indexOf('const isApplyBoot = launched.length > 0')
-    const win = GATEWAY_SRC.slice(idx, idx + 5200)
-    // When start.sh wrote a specific alert for this revert, the classifier's
-    // generic not-applied card is suppressed (the alert relay is the message).
+    const win = GATEWAY_SRC.slice(idx, idx + 2500)
     expect(win).toContain("existsSync(join(smAgentDir, '.session-model-alert'))")
     expect(win).toContain("confirmation.kind === 'not-applied' && hasSessionModelAlert")
+    expect(win).toContain('formatModelRelaunchSuppressNotAppliedLog')
   })
 
   it('N4/reason: the /model switch reason is captured from the clean-shutdown marker', () => {
@@ -213,6 +221,32 @@ describe('gateway boot: session-model re-hydration + confirmation + alert relay'
   })
 })
 
+
+describe('gateway SESSION_MODEL_FILE stays pinned to start.sh.hbs rev5 carrier', () => {
+  it('hbs applies the same basename gateway writes (no rev4/rev5 name drift)', async () => {
+    const { SESSION_MODEL_FILE } = await import('../gateway/session-model-file.js')
+    const { readFileSync } = await import('node:fs')
+    const { resolve, dirname } = await import('node:path')
+    const { fileURLToPath } = await import('node:url')
+    expect(SESSION_MODEL_FILE).toBe('.session-model')
+    // Vitest may run with import.meta or __dirname depending on config.
+    const here = typeof __dirname !== 'undefined'
+      ? __dirname
+      : dirname(fileURLToPath(import.meta.url))
+    const hbs = readFileSync(
+      resolve(here, '../../profiles/_base/start.sh.hbs'),
+      'utf8',
+    )
+    // Bare file test on the rev5 carrier (not only -override/-alert siblings).
+    expect(hbs).toMatch(/\[\s*-f\s+[^\]]*\/\.session-model["\s\]]/)
+    expect(hbs).toContain('configuredDefaultAtWrite')
+    // Legacy migration shim still converts leftover override → .session-model.
+    expect(hbs).toContain('.session-model-override')
+    expect(hbs).toMatch(/migrated legacy one-shot carrier/)
+  })
+})
+
+
 describe('gateway: the legacy one-shot carrier is no longer written', () => {
   it('no gateway code writes .session-model-override anymore (start.sh migration shim only reads it)', () => {
     expect(GATEWAY_SRC).not.toMatch(/writeFileSync\([^)]*\.session-model-override/)

package/telegram-plugin/tests/quota-bar-format.test.ts

@@ -441,4 +441,47 @@ describe('renderUsageCard', () => {
     const out = renderUsageCard(snapshots, exhausted, { now: NOW });
     expect(out).toContain('- **ken@example.com** (active)');
   });
+
+  it('inserts External layout-B block after recommendation and before freshness', () => {
+    const out = renderUsageCard(snapshots, exhausted, {
+      now: NOW,
+      externalSpend: {
+        day24hUsd: 8.07,
+        day7dUsd: 119.89,
+        top: [
+          { label: 'gpt-oss-20b', usd: 6.1 },
+          { label: 'grok-4.5', usd: 1.18 },
+          { label: 'gemini-3.1-flash-lite', usd: 0.79 },
+        ],
+      },
+    });
+    const lines = out.split('\n');
+    // recommendation then External header then totals then top then freshness
+    const recIdx = lines.findIndex((l) => l.includes('Recommendation:'));
+    expect(recIdx).toBeGreaterThan(0);
+    expect(lines[recIdx + 1]).toBe('- 💸 External');
+    expect(lines[recIdx + 2]).toBe('- 24h `$8.07` · 7d `$119.89`');
+    expect(lines[recIdx + 3]).toBe(
+      '- top `gpt-oss-20b $6.10` · `grok-4.5 $1.18` · `gemini-3.1-flash-lite $0.79`',
+    );
+    expect(lines[lines.length - 1]).toBe('_Live_');
+  });
+
+  it('omits External block when externalSpend is null/undefined', () => {
+    const bare = renderUsageCard(snapshots, exhausted, { now: NOW });
+    const withNull = renderUsageCard(snapshots, exhausted, { now: NOW, externalSpend: null });
+    expect(bare).not.toContain('💸 External');
+    expect(withNull).not.toContain('💸 External');
+    expect(bare).toBe(withNull);
+  });
+
+  it('still renders External block at $0.00 when summary is present', () => {
+    const out = renderUsageCard(snapshots, exhausted, {
+      now: NOW,
+      externalSpend: { day24hUsd: 0, day7dUsd: 0, top: [] },
+    });
+    expect(out).toContain('- 💸 External');
+    expect(out).toContain('- 24h `$0.00` · 7d `$0.00`');
+    expect(out).not.toContain('- top ');
+  });
 });

package/telegram-plugin/tests/quota-check.test.ts

@@ -118,6 +118,63 @@ describe('formatQuotaBlock', () => {
     })
     expect(block).toContain('Overage: disabled (spend_cap_reached)')
   })
+
+  it('renders "no data" (never a confident 0%) for an absent window header (F3)', () => {
+    // Adversarial-review F3 — a thin probe leaves the utilization field
+    // coalesced to 0 but flags the window absent. The legacy block renderer
+    // used to print a confident `0%`, indistinguishable from a genuine
+    // fresh-account 0%. Backport the modern card's handling: absent → no data.
+    const block = formatQuotaBlock({
+      fiveHourUtilizationPct: 0,
+      sevenDayUtilizationPct: 0,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+      fiveHourUtilPresent: false,
+      sevenDayUtilPresent: false,
+    })
+    const fiveLine = block.split('\n').find((l) => l.includes('5h window'))!
+    const sevenLine = block.split('\n').find((l) => l.includes('7d window'))!
+    expect(fiveLine).toContain('no data')
+    expect(sevenLine).toContain('no data')
+    // The confident-0% lie must be gone.
+    expect(fiveLine).not.toContain('`0%`')
+    expect(sevenLine).not.toContain('`0%`')
+  })
+
+  it('still renders the percent when a window is present but genuinely 0% (F3 guard)', () => {
+    const block = formatQuotaBlock({
+      fiveHourUtilizationPct: 0,
+      sevenDayUtilizationPct: 0,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+      fiveHourUtilPresent: true,
+      sevenDayUtilPresent: true,
+    })
+    expect(block).toContain('`0%`')
+    expect(block).not.toContain('no data')
+  })
+
+  it('renders the percent for legacy snapshots with no presence markers (F3 back-compat)', () => {
+    // Optional markers unset → real/legacy probe → render the number.
+    const block = formatQuotaBlock({
+      fiveHourUtilizationPct: 0,
+      sevenDayUtilizationPct: 5,
+      fiveHourResetAt: null,
+      sevenDayResetAt: null,
+      representativeClaim: null,
+      overageStatus: null,
+      overageDisabledReason: null,
+    })
+    expect(block).toContain('`0%`')
+    expect(block).toContain('`5%`')
+    expect(block).not.toContain('no data')
+  })
 })
 
 describe('fetchQuota', () => {