switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/auth-snapshot-format.test.ts

@@ -11,6 +11,7 @@ import {
   bindingWindow,
   formatRelative,
   formatAbsolute,
+  formatStatusTime,
   fmtPct,
   recommendation,
   renderAuthSnapshotFormat2,
@@ -133,6 +134,14 @@ describe('fmtPct', () => {
     expect(fmtPct(8.6)).toBe('9%');
     expect(fmtPct(99.6)).toBe('100%');
   });
+  it('CLAMPS the displayed value to 100% — never shows over 100 (trust)', () => {
+    // Anthropic returns a decimal that can exceed 1.0; quota-check multiplies by
+    // 100 → e.g. 1.01 → 101. The displayed number must clamp to 100%.
+    expect(fmtPct(101)).toBe('100%');
+    expect(fmtPct(100.4)).toBe('100%');
+    expect(fmtPct(250)).toBe('100%');
+    expect(fmtPct(1.01 * 100)).toBe('100%');
+  });
 });
 
 // ── formatAbsolute ───────────────────────────────────────────────────
@@ -149,6 +158,52 @@ describe('formatAbsolute', () => {
   });
 });
 
+// ── formatStatusTime (date shown only when NOT today, in user tz) ─────
+describe('formatStatusTime', () => {
+  // Fixed injected now + fixed tz → fully deterministic (no wall-clock).
+  // 2026-05-15T05:00:00Z = Fri 15 May 3:00 PM in Australia/Melbourne (AEST,
+  // UTC+10). May is winter there → AEST, not AEDT — the tz database handles it.
+  const MEL = 'Australia/Melbourne';
+  const NOW_MEL = new Date('2026-05-15T05:00:00Z'); // Fri 3:00 PM Melbourne
+
+  it('shows TIME ONLY when the target is the same calendar day (user tz)', () => {
+    // 2026-05-15T13:00:00Z = Fri 11:00 PM Melbourne — same Melbourne day as now.
+    const out = formatStatusTime(new Date('2026-05-15T13:00:00Z'), NOW_MEL, MEL);
+    expect(out).toBe('11:00 PM');
+    // No weekday/date leaks on a same-day target.
+    expect(out).not.toMatch(/Mon|Tue|Wed|Thu|Fri|Sat|Sun/);
+  });
+
+  it('includes the WEEKDAY when the target is a different day (within the week)', () => {
+    // 2026-05-15T15:00:00Z = Sat 16 May 1:00 AM Melbourne — next Melbourne day.
+    const out = formatStatusTime(new Date('2026-05-15T15:00:00Z'), NOW_MEL, MEL);
+    expect(out).toBe('Sat 1:00 AM');
+    expect(out).toMatch(/^Sat\b/);
+  });
+
+  it('includes day-of-month + month when the target is beyond the current week', () => {
+    // ~9 days out: 2026-05-24T01:00:00Z = Sun 24 May 11:00 AM Melbourne.
+    const out = formatStatusTime(new Date('2026-05-24T01:00:00Z'), NOW_MEL, MEL);
+    // Intl en-US renders the weekday+day+month as "Sun, May 24".
+    expect(out).toBe('Sun, May 24 11:00 AM');
+    expect(out).toMatch(/^Sun\b/);
+    expect(out).toContain('May 24');
+  });
+
+  it('is tz-correct — same instant renders differently in UTC vs Melbourne', () => {
+    const instant = new Date('2026-05-15T15:00:00Z');
+    // In UTC that instant is still Fri 15 May 3:00 PM → same day as NOW_MEL's UTC
+    // wall date — but NOW in UTC terms is also 2026-05-15, so time-only.
+    expect(formatStatusTime(instant, NOW_MEL, 'UTC')).toBe('3:00 PM');
+    // In Melbourne it has crossed midnight into Saturday.
+    expect(formatStatusTime(instant, NOW_MEL, MEL)).toBe('Sat 1:00 AM');
+  });
+
+  it('returns "—" for a null target', () => {
+    expect(formatStatusTime(null, NOW_MEL, MEL)).toBe('—');
+  });
+});
+
 // ── renderAuthSnapshotFormat2 ────────────────────────────────────────
 
 describe('renderAuthSnapshotFormat2', () => {
@@ -191,42 +246,120 @@ describe('renderAuthSnapshotFormat2', () => {
     }),
   ];
 
-  it('renders three health-grouped sections (BLOCKED first, then HEALTHY)', () => {
+  // Helper: parse the GFM table rows (the lines between the header separator
+  // and the trailing blank line) into their cell arrays.
+  function tableRows(out: string): string[][] {
+    const lines = out.split('\n');
+    const sep = lines.findIndex((l) => /^\|\s*---/.test(l));
+    if (sep < 0) return [];
+    const rows: string[][] = [];
+    for (let i = sep + 1; i < lines.length; i++) {
+      const l = lines[i];
+      if (!l.startsWith('|')) break;
+      rows.push(l.split('|').slice(1, -1).map((c) => c.trim()));
+    }
+    return rows;
+  }
+
+  it('renders a GFM table with the State/Account/5h/7d/Status header', () => {
     const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
-    // Headers present
     expect(out).toContain('🔋 **Auth — fleet status**');
-    expect(out).toContain('🔴 **BLOCKED** (1)');
-    expect(out).toContain('🟢 **HEALTHY** (2)');
-    // Order: BLOCKED before HEALTHY
-    expect(out.indexOf('🔴')).toBeLessThan(out.indexOf('🟢'));
+    expect(out).toContain('| State | Account | 5h | 7d | Status |');
+    expect(out).toContain('| --- | --- | --- | --- | --- |');
+    // No legacy group headers / health-section titles remain.
+    expect(out).not.toContain('**BLOCKED**');
+    expect(out).not.toContain('**HEALTHY**');
   });
 
-  it('marks the active account with ●', () => {
-    const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
-    expect(out).toMatch(/●\s*`you@example\.com`/);
+  it('sorts the ACTIVE account to the top row regardless of health group', () => {
+    const rows = tableRows(renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' }));
+    expect(rows.length).toBe(3);
+    // you@example.com is active + healthy; bob is blocked. Active still wins
+    // the top row over the blocked account.
+    expect(rows[0][1]).toContain('you@example.com');
   });
 
-  it('shows "back …" for blocked accounts with binding-window word', () => {
+  it('labels the active account with " (active)" and NO black-dot marker', () => {
     const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
-    // bob@example is blocked on 7d, recovers Sun
-    expect(out).toMatch(/bob@example\.com[\s\S]*back .* 7-day cap/);
+    expect(out).toContain('you@example.com (active)');
+    // The ⚫/● active marker is removed entirely.
+    expect(out).not.toContain('⚫');
+    expect(out).not.toContain('●');
   });
 
-  it('puts the imminent window first on healthy/throttling rows', () => {
-    const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
-    // you: 5h reset is in 7m, 7d reset is in 2d. 5h should come first.
-    // The two reset segments now render on SEPARATE lines (so the 7d
-    // segment doesn't wrap mid-line on a narrow phone) — the imminent 5h
-    // line must precede the 7d line, each on its own line.
-    const lines = out.split('\n');
-    const fiveLine = lines.findIndex((l) => l.includes('5h refills'));
-    const sevenLine = lines.findIndex((l) => l.includes('7d resets'));
-    expect(fiveLine).toBeGreaterThanOrEqual(0);
-    expect(sevenLine).toBeGreaterThanOrEqual(0);
-    // Distinct lines, 5h before 7d.
-    expect(fiveLine).toBeLessThan(sevenLine);
-    expect(lines[fiveLine]).not.toContain('7d resets');
-    expect(lines[sevenLine]).not.toContain('5h refills');
+  it('shows the FULL email address, never truncated', () => {
+    const longSnaps = [
+      snap({ label: 'a-very-long-account-name@really-long-domain.example.com', isActive: true, quota: quota({ fiveHourUtilizationPct: 5 }) }),
+    ];
+    const rows = tableRows(renderAuthSnapshotFormat2(longSnaps, { now: NOW, tz: 'UTC' }));
+    expect(rows[0][1]).toContain('a-very-long-account-name@really-long-domain.example.com');
+    expect(rows[0][1]).not.toContain('…');
+    expect(rows[0][1]).not.toContain('...');
+  });
+
+  it('orders non-active rows blocked-before-healthy', () => {
+    const rows = tableRows(renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' }));
+    // After the active row (you), the blocked bob must precede the healthy alice.
+    const bob = rows.findIndex((r) => r[1].includes('bob@example.com'));
+    const alice = rows.findIndex((r) => r[1].includes('alice@example.com'));
+    expect(bob).toBeGreaterThan(0);
+    expect(bob).toBeLessThan(alice);
+  });
+
+  it('Status column shows "back <when>" for a blocked account', () => {
+    const rows = tableRows(renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' }));
+    const bob = rows.find((r) => r[1].includes('bob@example.com'))!;
+    expect(bob[4]).toMatch(/^back .* \(in .+\)$/);
+  });
+
+  it('Status column shows "refills <when>" for a healthy account', () => {
+    const rows = tableRows(renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' }));
+    const you = rows.find((r) => r[1].includes('you@example.com'))!;
+    expect(you[4]).toMatch(/^refills .* \(in .+\)$/);
+  });
+
+  it('NEVER displays a percentage over 100% even on an over-cap account', () => {
+    // Feed 1.01 (decimal) * 100 = 101 → must clamp to 100% in the cell.
+    const overSnaps = [
+      snap({
+        label: 'over@example.com',
+        isActive: true,
+        quota: quota({ fiveHourUtilizationPct: 101, sevenDayUtilizationPct: 250 }),
+      }),
+    ];
+    const rows = tableRows(renderAuthSnapshotFormat2(overSnaps, { now: NOW, tz: 'UTC' }));
+    expect(rows[0][2]).toBe('100%'); // 5h
+    expect(rows[0][3]).toBe('100%'); // 7d
+    // And the blocked state still surfaces via the emoji (🔴) + Status.
+    expect(rows[0][0]).toBe('🔴');
+    expect(rows[0][4]).toMatch(/^back/);
+  });
+
+  it('renders dates in the Status column only when NOT today (user tz)', () => {
+    // now = Fri 3:00 PM Melbourne. A reset later the SAME Melbourne day shows
+    // time-only; a reset on the next day shows the weekday.
+    const MEL = 'Australia/Melbourne';
+    const NOW_MEL = new Date('2026-05-15T05:00:00Z'); // Fri 3:00 PM Mel
+    const sameDay = [
+      snap({ label: 'today@example.com', isActive: true, quota: quota({
+        fiveHourUtilizationPct: 5,
+        fiveHourResetAt: new Date('2026-05-15T11:00:00Z'), // Fri 9:00 PM Mel (today)
+        sevenDayResetAt: new Date('2026-05-22T11:00:00Z'),
+      }) }),
+    ];
+    const todayRows = tableRows(renderAuthSnapshotFormat2(sameDay, { now: NOW_MEL, tz: MEL }));
+    expect(todayRows[0][4]).toContain('9:00 PM');
+    expect(todayRows[0][4]).not.toMatch(/Mon|Tue|Wed|Thu|Fri|Sat|Sun/);
+
+    const nextDay = [
+      snap({ label: 'tomorrow@example.com', isActive: true, quota: quota({
+        fiveHourUtilizationPct: 5,
+        fiveHourResetAt: new Date('2026-05-15T15:00:00Z'), // Sat 1:00 AM Mel (tomorrow)
+        sevenDayResetAt: new Date('2026-05-22T11:00:00Z'),
+      }) }),
+    ];
+    const tomorrowRows = tableRows(renderAuthSnapshotFormat2(nextDay, { now: NOW_MEL, tz: MEL }));
+    expect(tomorrowRows[0][4]).toContain('Sat 1:00 AM');
   });
 
   it('emits a recommendation footer that names a healthy alternative when active is throttling', () => {
@@ -251,9 +384,10 @@ describe('renderAuthSnapshotFormat2', () => {
       snap({ label: 'broken@x', isActive: true, quota: null, quotaError: 'HTTP 401' }),
     ];
     const out = renderAuthSnapshotFormat2(errSnaps, { now: NOW });
-    expect(out).toContain('quota probe failed');
+    // Probe-failed row: ⚪ State emoji + a "probe failed (...)" Status cell.
+    expect(out).toContain('probe failed');
     expect(out).toContain('HTTP 401');
-    expect(out).toContain('⚪ **UNKNOWN**');
+    expect(out).toContain('⚪');
   });
 
   it('renders refresh stamp when liveProbedAtMs given', () => {
@@ -300,9 +434,8 @@ describe('renderAuthSnapshotFormat2', () => {
       expect(out).not.toContain('alice@example.com');
       expect(out).not.toContain('bob@example.com');
       expect(out).not.toContain('you@example.com');
-      // Masked fakes present (pool order from a clean cache: blocked-first
-      // render order means bob is masked first, then alice/you in healthy).
-      expect(out).toMatch(/`[^@<]+@example\.com`/);
+      // Masked fakes present — plain table cells (no backtick wrap now).
+      expect(out).toMatch(/[^@\s<]+@example\.com/);
     });
 
     it('WITH demo, the recommendation footer masks the active label', () => {
@@ -371,6 +504,33 @@ describe('renderFallbackAnnouncement', () => {
     expect(out7).toContain('7-day limit on me@x');
   });
 
+  // Context-correct escaping (#2695 fix): the swap announcement renders each
+  // label in TWO contexts, and each demands a different treatment —
+  //  • **bold** header / trigger-agent → escapeMarkdown (backslash-escaped, so
+  //    an underscore can't open an emphasis run), and
+  //  • `code span` (the old→new line, recovery line) → codeSpanSafe (LITERAL,
+  //    because backslash escaping is inert inside a code span and would show a
+  //    visible `old\_a\*x`).
+  it('escapes labels in the bold header but renders them literally in code spans (#2695)', () => {
+    const out = renderFallbackAnnouncement({
+      oldLabel: 'old_a*x',
+      oldQuota: KEN_5H_BLOWN,
+      newLabel: 'new_b*y',
+      newQuota: YOU_HEALTHY,
+      triggerAgent: 'agent_z*q',
+      now: NOW,
+      tz: 'UTC',
+    });
+    // Emphasis contexts: backslash-escaped.
+    expect(out).toContain('old\\_a\\*x'); // bold header "· … on old_a*x"
+    expect(out).toContain('agent\\_z\\*q'); // "Triggered by: agent **…**"
+    // Code-span contexts: literal, no stray backslash.
+    expect(out).toContain('`old_a*x`');
+    expect(out).toContain('`new_b*y`');
+    expect(out).not.toContain('`old\\_a\\*x`');
+    expect(out).not.toContain('`new\\_b\\*y`');
+  });
+
   it('names the triggering agent + recovery countdown for the old account', () => {
     const out = renderFallbackAnnouncement({
       oldLabel: 'ken@x',
@@ -858,23 +1018,20 @@ describe('#2494 Bug C — blockedReason + thin probe (out_of_credits now informa
 // ── #2494 — row rendering: out_of_credits as informational annotation ─────────
 
 describe('#2494 — renderAuthSnapshotFormat2 row rendering (out_of_credits demoted)', () => {
-  it('out_of_credits at 0% util → healthy row with informational overage annotation, NOT blocked', () => {
-    // THE KEY CHANGE: carol scenario — 0% util, out_of_credits → healthy group
-    // with an informational sub-line "overage off (out_of_credits) — serving from quota"
+  it('out_of_credits at 0% util → healthy (🟢) row, NOT blocked', () => {
+    // THE KEY CHANGE: carol scenario — 0% util, out_of_credits → healthy. In the
+    // table this surfaces as a 🟢 State emoji, not 🔴 — the row is not blocked.
     const out = renderAuthSnapshotFormat2(
       [snap({ label: 'dead@x', isActive: true, quota: quota({ fiveHourUtilizationPct: 0, overageDisabledReason: 'out_of_credits' }) })],
       { now: NOW },
     );
-    // Must be in HEALTHY group, not BLOCKED
-    expect(out).toContain('🟢 **HEALTHY**');
-    expect(out).not.toContain('🔴 **BLOCKED**');
-    // Must have informational annotation. #2669: the reason is markdown-
-    // escaped, so the underscores in "out_of_credits" render as "out\_of\_credits".
-    expect(out).toContain('overage off (out\\_of\\_credits) — serving from quota');
-    // Must NOT have old blocked framing
+    expect(out).toContain('| 🟢 |');
+    expect(out).not.toContain('| 🔴 |');
+    // Must NOT have old blocked framing.
     expect(out).not.toContain('billing disabled');
     expect(out).not.toContain("won't recover until billing is fixed");
     expect(out).not.toContain('quota exhausted');
+    expect(out).not.toContain('back ');
   });
 
   it('out_of_credits account is a valid failover target (appears in buildSnapshotKeyboard switch buttons)', () => {
@@ -888,13 +1045,14 @@ describe('#2494 — renderAuthSnapshotFormat2 row rendering (out_of_credits demo
     expect(allText).toContain('Switch fleet → carol@example.com');
   });
 
-  it('quota-exhausted row shows a recovery countdown, not "billing disabled" or overage annotation', () => {
+  it('quota-exhausted row shows a 🔴 + "back <when>" Status, not "billing disabled"', () => {
     const futureReset = new Date(NOW.getTime() + 45 * 60_000);
     const out = renderAuthSnapshotFormat2(
       [snap({ label: 'ex@x', isActive: true, quota: quota({ fiveHourUtilizationPct: 100, fiveHourResetAt: futureReset }) })],
       { now: NOW },
     );
-    expect(out).toContain('quota exhausted');
+    expect(out).toContain('| 🔴 |');
+    expect(out).toMatch(/back .* \(in 45m\)/);
     expect(out).not.toContain('billing disabled');
     expect(out).not.toContain('overage off');
   });
@@ -914,7 +1072,8 @@ describe('#2494 — renderAuthSnapshotFormat2 row rendering (out_of_credits demo
       [snap({ label: 'org@x', isActive: false, quota: quota({ fiveHourUtilizationPct: 85, overageDisabledReason: 'org_level_disabled' }) })],
       { now: NOW },
     );
-    expect(out).toContain('🟡 **THROTTLING**');
+    // 85% util → throttling, surfaced as the 🟡 State emoji in the table.
+    expect(out).toContain('| 🟡 |');
     expect(out).not.toContain('overage off');
   });
 

package/telegram-plugin/tests/card-format.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest'
 import {
   cleanWorkerResultParagraph,
   formatDuration,
+  stackCardLines,
   stripMarkdown,
   truncate,
 } from '../card-format.js'
@@ -55,6 +56,21 @@ describe('stripMarkdown', () => {
   it('does not touch HTML-significant characters (escaping stays separate)', () => {
     expect(stripMarkdown('a < b & c > d')).toBe('a < b & c > d')
   })
+
+  it('F1: normalizes an em-dash on this card/narration prose surface', () => {
+    // The reply path scrubs em-dashes but cards/narration/PTY previews did not,
+    // so em-dashes leaked there. stripMarkdown now runs the same dash logic.
+    // A clause-joining dash becomes a full stop (never a comma — that produces
+    // a comma splice), with the following word recapitalized into a sentence.
+    expect(stripMarkdown('build done — shipping now')).toBe('build done. Shipping now')
+    expect(stripMarkdown('build done — Shipping now')).toBe('build done. Shipping now')
+  })
+
+  it('F1: preserves an em-dash inside an inline code span', () => {
+    // The dash normalizer masks code spans, and it runs BEFORE the backticks
+    // are stripped, so a dash inside `` `…` `` survives verbatim.
+    expect(stripMarkdown('see `a — b` token')).toBe('see a — b token')
+  })
 })
 
 describe('cleanWorkerResultParagraph', () => {
@@ -75,6 +91,19 @@ describe('cleanWorkerResultParagraph', () => {
   it('returns empty for whitespace/markup-only input', () => {
     expect(cleanWorkerResultParagraph('   \n---\n')).toBe('')
   })
+
+  it('F1: normalizes em-dashes in worker narration prose', () => {
+    const input = '## Result\n\nTests pass — ready to merge'
+    expect(cleanWorkerResultParagraph(input)).toBe('Result Tests pass. Ready to merge')
+  })
+
+  it('F1: an em-dash inside a fenced block is preserved (the block is dropped, never normalized)', () => {
+    // Fenced blocks are excised whole, so a dash inside one is preserved by
+    // removal — it never reaches (nor is mutated by) the dash normalizer, and
+    // the surrounding prose dash IS normalized.
+    const input = 'before — after\n```\nlet a = b — c\n```\ntail'
+    expect(cleanWorkerResultParagraph(input)).toBe('before. After tail')
+  })
 })
 
 describe('formatDuration', () => {
@@ -96,3 +125,53 @@ describe('escapeMarkdown / truncate', () => {
     expect(truncate('abc', 4)).toBe('abc')
   })
 })
+
+describe('stackCardLines — card bodies stack like the reply path', () => {
+  // The bug this fixes: the rich-message renderer (#2669) treats a LONE `\n`
+  // between two non-blank lines as a SOFT break and collapses them onto one
+  // visual line. A card built as a list of styled prose lines and joined with
+  // `\n` therefore renders as a run-on blob. stackCardLines promotes every
+  // inter-line break to a GFM hard break (`  \n`) so the lines stack — the
+  // same end-state the reply path reaches via normalizeParagraphBreaks.
+
+  it('promotes every inter-line break to a GFM hard break so bullets stack', () => {
+    const out = stackCardLines(['_✓ Reading a.ts_', '_✓ Searching memory_', '**→ List workspace**'])
+    expect(out).toBe('_✓ Reading a.ts_  \n_✓ Searching memory_  \n**→ List workspace**')
+    // No LONE `\n` survives between non-blank lines — every break is a hard break.
+    expect(out.replace(/ {2}\n/g, '')).not.toContain('\n')
+  })
+
+  it('single line is returned verbatim (no trailing hard break)', () => {
+    expect(stackCardLines(['**→ Reading a.ts**'])).toBe('**→ Reading a.ts**')
+  })
+
+  it('preserves an intentional blank-line paragraph gap', () => {
+    // A blank entry is a genuine `\n\n` gap (e.g. boot card header → rows);
+    // it must NOT become a hard-break run — the blank reconstructs the gap.
+    const out = stackCardLines(['🔔 **Header**', '', '_✓ row one_', '_✓ row two_'])
+    expect(out).toBe('🔔 **Header**\n\n_✓ row one_  \n_✓ row two_')
+  })
+
+  it('does not accumulate trailing spaces on a re-run (idempotent breaks)', () => {
+    const once = stackCardLines(['a.', 'b.', 'c.'])
+    // Feeding the stacked output back in (split on hard break) yields the same.
+    const twice = stackCardLines(once.split('  \n'))
+    expect(twice).toBe(once)
+  })
+
+  it('keeps bold, code-spans and the worker-result rule intact (only breaks change)', () => {
+    const out = stackCardLines([
+      '🛠 **Worker** · _build_',
+      '_✓ Running `git push`_',
+      '─────',
+      '✅ _Fixed the **bug** in `foo.ts`_',
+    ])
+    // Inline markup is untouched — bold, code spans, the rule line all survive.
+    expect(out).toContain('**Worker**')
+    expect(out).toContain('`git push`')
+    expect(out).toContain('Fixed the **bug** in `foo.ts`')
+    expect(out).toContain('─────')
+    // And the four lines stack (three hard breaks, no soft breaks).
+    expect(out.match(/ {2}\n/g)?.length).toBe(3)
+  })
+})

package/telegram-plugin/tests/chat-id-fallback.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+
+import { resolveChatIdFallback, type ChatIdAllowlist } from '../gateway/chat-id-fallback.js'
+
+/**
+ * Regression tests for the sr-* chat_id routing hotfixes that shipped
+ * test-free, plus the stream_reply fallback parity fix.
+ *
+ * The reply / stream_reply final-answer paths call resolveChatIdFallback with a
+ * String()-coerced chat_id. This suite pins the pure decision:
+ *   - Bug A — numeric coercion (String() at the callsite makes 42 match "42")
+ *   - Bug B — executeReply falls back to the active turn's sessionChatId
+ *   - Bug D — lastActiveTurnChatId survives the silence poke (currentTurn null)
+ *   - stream_reply — the SAME fallback (mirrors the executeReply Bug-D test)
+ */
+describe('resolveChatIdFallback', () => {
+  const access = (allowFrom: string[], groups: Record<string, unknown> = {}): ChatIdAllowlist => ({
+    allowFrom,
+    groups,
+  })
+
+  it('allowlisted raw chat_id passes through unchanged (tier=raw)', () => {
+    const r = resolveChatIdFallback('123', access(['123']), '999', '999', true)
+    expect(r).toEqual({ chatId: '123', tier: 'raw' })
+  })
+
+  it('a chat_id present in groups (not allowFrom) passes through (tier=raw)', () => {
+    const r = resolveChatIdFallback('-100777', access([], { '-100777': {} }), '999', '999', true)
+    expect(r).toEqual({ chatId: '-100777', tier: 'raw' })
+  })
+
+  // Bug A — numeric coercion. The model passes a JSON number; the caller
+  // String()-coerces before calling. A stringified numeric id matches the
+  // string allowlist, so it must pass through as tier=raw (no spurious
+  // fallback).
+  it('Bug A: numerically-coerced chat_id ("42") matches the string allowlist', () => {
+    const coerced = String(42 as unknown as number)
+    const r = resolveChatIdFallback(coerced, access(['42']), '999', '999', true)
+    expect(r).toEqual({ chatId: '42', tier: 'raw' })
+  })
+
+  // Bug B — executeReply fallback. Raw chat_id not allowlisted, a live turn is
+  // present → route to the active turn's validated sessionChatId.
+  it('Bug B: non-allowlisted raw + live turn → active turn sessionChatId', () => {
+    const r = resolveChatIdFallback('wrong-id', access(['123']), '123', '123', true)
+    expect(r).toEqual({ chatId: '123', tier: 'active' })
+  })
+
+  // Bug D — lastActiveTurnChatId survives the silence poke. currentTurn is null
+  // (turnSessionChatId undefined, hasLiveTurn false) because clearTurnStarted
+  // fired after ≥5 min silence, but the model finally replied after the poke.
+  // The last-known chat still routes the answer.
+  it('Bug D: no live turn (silence poke) → last-known turn chat', () => {
+    const r = resolveChatIdFallback('wrong-id', access(['123']), undefined, '123', false)
+    expect(r).toEqual({ chatId: '123', tier: 'last-known' })
+  })
+
+  // stream_reply Bug-D mirror: stream_reply is the primary final-answer path
+  // and now applies the SAME fallback. Identical inputs → identical decision.
+  it('stream_reply parity: same fallback after a silence poke (mirrors Bug D)', () => {
+    const r = resolveChatIdFallback('wrong-id', access(['555']), undefined, '555', false)
+    expect(r).toEqual({ chatId: '555', tier: 'last-known' })
+  })
+
+  it('no valid fallback → returns raw so assertAllowedChat throws the human error', () => {
+    const r = resolveChatIdFallback('wrong-id', access(['123']), 'also-wrong', 'still-wrong', true)
+    expect(r).toEqual({ chatId: 'wrong-id', tier: 'raw' })
+  })
+
+  it('active tier wins over last-known when both are set (turn present)', () => {
+    const r = resolveChatIdFallback('wrong-id', access(['active-chat', 'old-chat']), 'active-chat', 'old-chat', true)
+    expect(r).toEqual({ chatId: 'active-chat', tier: 'active' })
+  })
+})