switchroom 0.18.17 → 0.18.19

package/telegram-plugin/tests/paragraph-normalizer.test.ts

@@ -12,8 +12,6 @@ import { describe, test, expect } from 'vitest'
 import {
   normalizeParagraphBreaks,
   splitCollapsedInlineBullets,
-  addParagraphSpacers,
-  PARAGRAPH_SPACER,
 } from '../format.js'
 
 describe('normalizeParagraphBreaks', () => {
@@ -433,96 +431,44 @@ describe('splitCollapsedInlineBullets', () => {
 })
 
 // ---------------------------------------------------------------------------
-// addParagraphSpacers — restore a VISIBLE blank line between prose paragraphs.
+// Paragraph gap spacing — plain \n\n, no NBSP spacer (#2669 follow-up).
 //
-// The rich GFM renderer (post-#2669) collapses a `\n\n` paragraph gap TIGHT, so
-// multi-paragraph replies render jammed together — the operator-confirmed
-// regression vs the old HTML path (`parse_mode:"HTML"`, `\n\n` → real blank
-// line). addParagraphSpacers wedges a U+00A0 spacer paragraph into each prose
-// `\n\n` gap so the rich renderer shows a visible empty line. Conservative:
-// only between two prose blocks, never adjacent to list/table/code/quote/heading.
+// The NBSP paragraph-spacer (addParagraphSpacers / PARAGRAPH_SPACER) was
+// REMOVED: its premise — that the Bot API 10.1 rich GFM renderer collapses a
+// `\n\n` gap TIGHT — is false for the live renderer, which shows a `\n\n` gap
+// as one normal blank line. The spacer therefore injected a spurious SECOND
+// blank line (`\n\n \n\n`) between every paragraph fleet-wide. Paragraph
+// spacing now relies on the plain `\n\n` that normalizeParagraphBreaks already
+// guarantees. These tests pin: multi-paragraph output has exactly one blank
+// line per gap, and no U+00A0 anywhere.
 // ---------------------------------------------------------------------------
 
-describe('addParagraphSpacers', () => {
-  const gap = `\n\n${PARAGRAPH_SPACER}\n\n`
+describe('paragraph gap spacing — single blank line, no NBSP', () => {
+  const NBSP = String.fromCharCode(0xa0)
 
-  test('the spacer is a single non-breaking space (U+00A0), not an ASCII space', () => {
-    expect(PARAGRAPH_SPACER).toBe(' ')
+  test('a two-paragraph prose body has exactly one blank-line gap and no NBSP', () => {
+    const out = normalizeParagraphBreaks('Paragraph one.\n\nParagraph two.')
+    expect(out).toBe('Paragraph one.\n\nParagraph two.')
+    expect(out).not.toContain(NBSP)
+    // Exactly one empty line between the two content lines.
+    expect(out.split('\n')).toEqual(['Paragraph one.', '', 'Paragraph two.'])
   })
 
-  test('inserts a visible spacer paragraph into a prose `\\n\\n` gap', () => {
-    expect(addParagraphSpacers('Paragraph one.\n\nParagraph two.')).toBe(
-      `Paragraph one.${gap}Paragraph two.`,
-    )
-  })
-
-  test('spaces every gap in a three-paragraph body', () => {
-    expect(addParagraphSpacers('One.\n\nTwo.\n\nThree.')).toBe(
-      `One.${gap}Two.${gap}Three.`,
-    )
-  })
-
-  test('is idempotent — a spaced gap is not doubled on a second pass', () => {
-    const once = addParagraphSpacers('Alpha.\n\nBravo.')
-    expect(addParagraphSpacers(once)).toBe(once)
-  })
-
-  test('leaves a single-`\\n` separation alone (only `\\n\\n` gaps are spaced)', () => {
-    // normalizeParagraphBreaks owns lone-break promotion; this pass only adds a
-    // visible spacer where a genuine blank-line gap already exists.
-    const input = 'Line one.\nLine two.'
-    expect(addParagraphSpacers(input)).toBe(input)
+  test('a three-paragraph body keeps single-blank-line gaps, no NBSP', () => {
+    const out = normalizeParagraphBreaks('One.\n\nTwo.\n\nThree.')
+    expect(out).toBe('One.\n\nTwo.\n\nThree.')
+    expect(out).not.toContain(NBSP)
+    // No gap is a DOUBLE blank line (`\n\n\n`), which the old spacer produced.
+    expect(out).not.toMatch(/\n\n\n/)
   })
 
-  test('spaces prose↔list transitions (uniform block spacing), list interior tight', () => {
-    expect(addParagraphSpacers('Here are the steps.\n\n- first\n- second')).toBe(
-      `Here are the steps.${gap}- first\n- second`,
-    )
-    expect(addParagraphSpacers('- first\n- second\n\nClosing prose after the list.')).toBe(
-      `- first\n- second${gap}Closing prose after the list.`,
-    )
+  test('prose->list transition is a single `\n\n` boundary, list interior tight', () => {
+    const out = normalizeParagraphBreaks('Here are the steps.\n\n- first\n- second')
+    expect(out).toBe('Here are the steps.\n\n- first\n- second')
+    expect(out).not.toContain(NBSP)
   })
 
-  test('spaces a prose→table boundary; table rows stay contiguous', () => {
-    const table = '| a | b |\n| --- | --- |\n| 1 | 2 |'
-    expect(addParagraphSpacers(`Intro.\n\n${table}`)).toBe(`Intro.${gap}${table}`)
-  })
-
-  test('spaces prose↔fence boundaries; fence interior untouched', () => {
-    const input = 'Look here.\n\n```js\nconst a = 1;\n```\n\nDone.'
-    expect(addParagraphSpacers(input)).toBe(
-      `Look here.${gap}\`\`\`js\nconst a = 1;\n\`\`\`${gap}Done.`,
-    )
-  })
-
-  test('spaces heading→anything and blockquote boundaries', () => {
-    expect(addParagraphSpacers('Intro prose.\n\n## Section\n\nBody prose.')).toBe(
-      `Intro prose.${gap}## Section${gap}Body prose.`,
-    )
-    expect(addParagraphSpacers('Said.\n\n> a quote\n\nAfter.')).toBe(
-      `Said.${gap}> a quote${gap}After.`,
-    )
-  })
-
-  test('does NOT space between items of the same loose list / same-kind blocks', () => {
-    const looseList = '- first\n\n- second\n\n- third'
-    expect(addParagraphSpacers(looseList)).toBe(looseList)
-    const quotes = '> one\n\n> two'
-    expect(addParagraphSpacers(quotes)).toBe(quotes)
-  })
-
-  test('never reaches inside a fenced block (interior blank line untouched)', () => {
-    const input = 'Before.\n\n```\nline 1\n\nline 2\n```\n\nAfter.'
-    const out = addParagraphSpacers(input)
-    // The fence interior — including its own blank line — is byte-for-byte intact.
-    expect(out).toContain('```\nline 1\n\nline 2\n```')
-  })
-
-  test('a body with no paragraph gap is returned unchanged', () => {
-    expect(addParagraphSpacers('just one paragraph, no gap')).toBe('just one paragraph, no gap')
-  })
-
-  test('composes after normalizeParagraphBreaks: prose gap spaced, list left tight', () => {
+  test('composed prose+list body: one blank line per gap, no NBSP, no double gap', () => {
     const input = [
       'Summary of the change.',
       '',
@@ -531,12 +477,11 @@ describe('addParagraphSpacers', () => {
       '- adds a normalizer',
       '- lifts the cap',
     ].join('\n')
-    const out = addParagraphSpacers(normalizeParagraphBreaks(input))
-    // The two prose paragraphs gain a visible spacer between them.
-    expect(out).toContain(`Summary of the change.${gap}It does two things.`)
-    // The prose→list transition gains a spacer too (uniform block spacing),
-    // but the list INTERIOR stays tight.
-    expect(out).toContain(`It does two things.${gap}- adds a normalizer\n- lifts the cap`)
+    const out = normalizeParagraphBreaks(input)
+    expect(out).toContain('Summary of the change.\n\nIt does two things.')
+    expect(out).toContain('It does two things.\n\n- adds a normalizer\n- lifts the cap')
+    expect(out).not.toContain(NBSP)
+    expect(out).not.toMatch(/\n\n\n/)
   })
 })
 
@@ -577,12 +522,12 @@ describe('normalizeParagraphBreaks — inline bullet split integration', () => {
  * ragged / oversized gap: CommonMark discards it so it buys no visible space,
  * but it reads as noise in the raw text. Step 1 of normalizeParagraphBreaks now
  * collapses any run of blank lines — including whitespace-only interior lines —
- * to exactly one clean `\n\n`, WITHOUT ever eating the deliberate U+00A0
- * paragraph spacer that addParagraphSpacers (#2692) adds later for a visible
- * gap on the rich-message path.
+ * to exactly one clean `\n\n`. The collapse is deliberately ASCII-only, so a
+ * genuine user-typed U+00A0 line survives (the conservative choice; there is no
+ * longer an NBSP paragraph spacer to protect — that pass was removed).
  */
 describe('normalizeParagraphBreaks — whitespace-only blank-line collapse (Bug 2)', () => {
-  const NBSP = ' '
+  const NBSP = String.fromCharCode(0xa0)
 
   test('a lone-space blank line between paragraphs collapses to a clean `\\n\\n` (real string)', () => {
     const input =
@@ -635,14 +580,11 @@ describe('normalizeParagraphBreaks — whitespace-only blank-line collapse (Bug
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
-  test('the deliberate U+00A0 spacer from addParagraphSpacers is preserved (no #2692 regression)', () => {
-    const normalized = normalizeParagraphBreaks('Alpha para.\n\nBravo para.')
-    const spaced = addParagraphSpacers(normalized)
-    // addParagraphSpacers wedges a U+00A0-only line to force a visible gap.
-    expect(spaced).toContain('\n\n' + PARAGRAPH_SPACER + '\n\n')
-    expect(spaced.split('\n')).toContain(NBSP)
-    // And re-running the normalizer must NOT eat that intentional spacer.
-    expect(normalizeParagraphBreaks(spaced)).toBe(spaced)
+  test('a genuine user-typed U+00A0-only line survives (ASCII-only collapse)', () => {
+    // The blank-line collapse is deliberately ASCII-only, so a non-breaking
+    // space a user actually typed on its own line is not silently eaten.
+    const input = 'Alpha para.\n' + NBSP + '\nBravo para.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
   test('idempotent: collapsing a stray gap twice is stable', () => {

package/telegram-plugin/tests/permission-title.test.ts

@@ -156,25 +156,188 @@ describe('formatPermissionCardBody', () => {
     expect(body).toContain('why: _listing temp files_')
   })
 
-  test('shows "not provided" when no caller reason is present (never the description)', () => {
+  // #3167: no caller reason → an honest synthesized `context:` line built
+  // from the tool's salient input, NEVER a bare "why: not provided" and never
+  // the static schema description. The distinct `context:` label keeps the
+  // agent's omission of a rationale visible.
+  test('synthesizes a context line when no caller reason is present (never "not provided" / the description)', () => {
     const body = formatPermissionCardBody({
       toolName: 'Bash',
       inputPreview: JSON.stringify({ command: 'ls /tmp' }),
       description: 'Run a shell command on the host.',
       agentName: 'gymbro',
     })
-    expect(body).toContain('why: _not provided_')
+    expect(body).not.toContain('not provided')
     expect(body).not.toContain('Run a shell command')
+    expect(body).toContain('context: _command: ls /tmp_')
   })
 
-  test('shows "not provided" when caller reason is whitespace only', () => {
+  test('synthesizes context when the caller reason is whitespace only', () => {
     const body = formatPermissionCardBody({
       toolName: 'Bash',
       inputPreview: JSON.stringify({ command: 'ls /tmp', reason: '   \n ' }),
       description: 'Run a shell command.',
       agentName: 'gymbro',
     })
-    expect(body).toContain('why: _not provided_')
+    expect(body).not.toContain('not provided')
+    expect(body).toContain('context: _command: ls /tmp_')
+  })
+
+  // #3167 root case: the `reply` tool (and react/edit_message/…) carries NO
+  // `reason` argument, so its cards used to render a contentless
+  // "🔐 Clerk wants to reply / why: not provided". Now the reply text is
+  // synthesized onto a `context:` line so the operator has something to judge.
+  test('reply (no reason arg) synthesizes the reply text as context, not "not provided"', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({
+        chat_id: '12345',
+        text: "On it — pulling yesterday's GitHub activity now.",
+        format: 'html',
+        disable_notification: true,
+      }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    const lines = body.split('\n')
+    expect(lines[0]).toBe('🔐 **Clerk** wants to reply')
+    expect(body).not.toContain('not provided')
+    // Salient field surfaced (truncated); id/routing/formatting noise stripped.
+    expect(body).toContain('context: _text: On it — pulling')
+    expect(body).toMatch(/context: _text: On it — pulling[^_]*…_/)
+    expect(body).not.toContain('chat_id')
+    expect(body).not.toContain('disable_notification')
+    expect(body).not.toContain('format')
+  })
+
+  test('a reason ON a reply card still renders as why:, not context: (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({
+        chat_id: '12345',
+        text: 'done',
+        reason: 'answering the operator’s status question',
+      }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('why: _answering the operator’s status question_')
+    expect(body).not.toContain('context:')
+  })
+
+  test('synthesized context redacts secrets in the salient input (#3167)', () => {
+    const fakeToken = 'sk-ant-' + 'api03-' + 'B'.repeat(48)
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: `here is the key: ${fakeToken}` }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('context:')
+    expect(body).not.toContain(fakeToken)
+  })
+
+  test('falls back to the natural action when the input exposes nothing salient (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'ExitPlanMode',
+      inputPreview: undefined,
+      description: 'Exit plan mode.',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('not provided')
+    expect(body).toContain('context: _exit plan mode_')
+  })
+
+  // #3167 review (HIGH/MEDIUM): the salient-value redactor must catch secrets
+  // the bare-value path missed. redact() excludes generic_high_entropy and the
+  // contextual kv detectors need a `key=value` shape — so a prefixless token
+  // under a credential-shaped key leaked verbatim. These FAIL pre-fix.
+  test('hard-masks a prefixless high-entropy value under a `token` key (#3167)', () => {
+    // No sk-/ghp-/JWT prefix — shape detection alone cannot catch it; only the
+    // key-name signal ("token") does.
+    const bare = 'Zx8Kq2Lm9Rn4Tv6Wb1Yc3Hd5Jf7Ug0Pe'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__do',
+      inputPreview: JSON.stringify({ token: bare, note: 'ping' }),
+      description: 'do a thing',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain(bare)
+    // `token` value is hard-masked; the benign `note` still surfaces.
+    expect(body).toContain('token:')
+    expect(body).toContain('REDACTED')
+    expect(body).toContain('note: ping')
+  })
+
+  test('hard-masks a 40-hex secret under a `secret`-shaped key (#3167)', () => {
+    const hex = 'a3f1'.repeat(10) // 40 hex chars, no prefix
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__do',
+      inputPreview: JSON.stringify({ webhook_secret: hex }),
+      description: 'do a thing',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain(hex)
+    expect(body).toContain('REDACTED')
+  })
+
+  test('masks a non-http DSN credential embedded in free text (redactUrls misses it) (#3167)', () => {
+    // Under a benign key (`text`) so the hard-mask key path does NOT fire —
+    // this exercises the NON_HTTP_DSN_RE scheme coverage specifically.
+    const dsn = 'postgres://user:S3cretPass99@db.host:5432/app'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: `connect via ${dsn} then run` }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('S3cretPass99')
+    expect(body).not.toContain(dsn)
+    expect(body).toContain('REDACTED')
+  })
+
+  test('hard-masks a DATABASE_URL under a url-shaped key (#3167)', () => {
+    const dsn = 'postgres://admin:hunter2pass@10.0.0.5/prod'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__migrate',
+      inputPreview: JSON.stringify({ database_url: dsn }),
+      description: 'run a migration',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('hunter2pass')
+    expect(body).not.toContain(dsn)
+    expect(body).toContain('REDACTED')
+  })
+
+  // #3167 review (LOW-2): acceptance asks for "tool + summarized input +
+  // originating turn" — surface a compact origin-turn reference when present.
+  test('appends a compact originating-turn reference when origin_turn_id is present (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: 'hi', origin_turn_id: 'turn-abcdef123456' }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('· turn …ef123456')
+    // The raw routing id is NOT dumped as its own kv pair.
+    expect(body).not.toContain('origin_turn_id:')
+  })
+
+  // #3167 review (LOW-3): raw commands/text now reach the context line, so a
+  // markdown metachar in the value must be escaped or it can spoof/break the
+  // card's own `_italic_` / `code` formatting.
+  test('escapes markdown metachars in the synthesized context value (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'Bash',
+      inputPreview: JSON.stringify({ command: 'echo _a_ *b* `c`' }),
+      description: 'run a shell command',
+      agentName: 'clerk',
+    })
+    // The metachars are backslash-escaped so they can't open emphasis/code.
+    expect(body).toContain('\\_a\\_')
+    expect(body).toContain('\\*b\\*')
+    expect(body).toContain('\\`c\\`')
+    expect(body).not.toContain('echo _a_ *b* `c`')
   })
 
   test('drops the agent prefix when agentName is null (early-boot edge)', () => {

package/telegram-plugin/tests/premium-recovery-wiring.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Integration test for the premium-recovery ping GLUE
+ * (`runPremiumRecoveryPing`, premium-recovery-wiring.ts) — the never-storm
+ * orchestration the pure `decidePremiumRecovery` / `renderPremiumRecoveryPing`
+ * tests do NOT cover. This is the P0 at-most-once guarantee (claim-gate → clear-
+ * marker-before-send → per-chat fan-out) that was inline in the gateway and so
+ * had ZERO coverage; the same untested-glue gap the tier-downgrade extraction
+ * closed for the downgrade path.
+ *
+ * It drives the real runner with injected seams and PINS:
+ *   - clear-BEFORE-send ordering (never-storm) + exactly one send per chat;
+ *   - claim !granted → marker cleared, NO send;
+ *   - decision.fire === false → no clear, no claim, no send;
+ *   - no marker / no agent dir → no-op;
+ *   - the button `callback_data` is EXACTLY `mdl:alias:<premium>` (a future edit
+ *     can't silently break the session-scoped switch-back path).
+ * These are outcome assertions that FAIL if the guard logic is reordered/dropped.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  runPremiumRecoveryPing,
+  type PremiumRecoveryPingDeps,
+  type PremiumRecoveryMarkerView,
+  type PremiumRecoveryKeyboard,
+} from '../gateway/premium-recovery-wiring.js'
+import type { PremiumRecoveryPing } from '../premium-recovery.js'
+
+interface Recorder {
+  /** Ordered event log — pins clear-before-send. */
+  events: string[]
+  clears: number
+  claims: string[]
+  sends: Array<{ chatId: string; ping: PremiumRecoveryPing; keyboard: PremiumRecoveryKeyboard }>
+  decides: number
+  logs: string[]
+}
+
+function makeDeps(
+  over: {
+    agentDir?: string | null
+    marker?: PremiumRecoveryMarkerView | null
+    fire?: boolean
+    granted?: boolean
+    fallbackChats?: string[]
+  } = {},
+): { deps: PremiumRecoveryPingDeps; rec: Recorder } {
+  const rec: Recorder = { events: [], clears: 0, claims: [], sends: [], decides: 0, logs: [] }
+  const deps: PremiumRecoveryPingDeps = {
+    getAgentDir: () => (over.agentDir === undefined ? '/tmp/agent' : over.agentDir),
+    readMarker: () =>
+      over.marker === undefined
+        ? { premiumModel: 'fable', chats: ['111', '222'] }
+        : over.marker,
+    clearMarker: () => {
+      rec.clears += 1
+      rec.events.push('clear')
+    },
+    getAgent: () => 'klanker',
+    decide: () => {
+      rec.decides += 1
+      return over.fire === undefined ? true : over.fire
+    },
+    claimNotification: async (key) => {
+      rec.claims.push(key)
+      return over.granted === undefined ? true : over.granted
+    },
+    fallbackChats: () => over.fallbackChats ?? ['999'],
+    sendToChat: (chatId, ping, keyboard) => {
+      rec.sends.push({ chatId, ping, keyboard })
+      rec.events.push(`send:${chatId}`)
+    },
+    log: (msg) => rec.logs.push(msg),
+  }
+  return { deps, rec }
+}
+
+describe('runPremiumRecoveryPing — never-storm at-most-once ordering', () => {
+  it('fire + granted: marker cleared BEFORE any send, exactly one send per chat', async () => {
+    const { deps, rec } = makeDeps({ marker: { premiumModel: 'fable', chats: ['111', '222'] } })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.clears).toBe(1)
+    // One send per recorded chat, in order, no duplicates.
+    expect(rec.sends.map((s) => s.chatId)).toEqual(['111', '222'])
+    // The clear MUST precede the first send (a double-send is unrecoverable).
+    const clearIdx = rec.events.indexOf('clear')
+    const firstSendIdx = rec.events.findIndex((e) => e.startsWith('send:'))
+    expect(clearIdx).toBeGreaterThanOrEqual(0)
+    expect(firstSendIdx).toBeGreaterThanOrEqual(0)
+    expect(clearIdx).toBeLessThan(firstSendIdx)
+    // The fleet claim was keyed on agent + the dropped premium token.
+    expect(rec.claims).toEqual(['premium-recovery:klanker:fable'])
+    expect(rec.logs).toHaveLength(1)
+  })
+
+  it('claim NOT granted: marker cleared (no lingering re-attempt), NO send', async () => {
+    const { deps, rec } = makeDeps({ granted: false })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.claims).toEqual(['premium-recovery:klanker:fable'])
+    expect(rec.clears).toBe(1)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('decision.fire === false: NO clear, NO claim, NO send (marker survives for a later tick)', async () => {
+    const { deps, rec } = makeDeps({ fire: false })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(1)
+    expect(rec.clears).toBe(0)
+    expect(rec.claims).toHaveLength(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('no marker present: no-op — no decide, no claim, no clear, no send', async () => {
+    const { deps, rec } = makeDeps({ marker: null })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(0)
+    expect(rec.clears).toBe(0)
+    expect(rec.claims).toHaveLength(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('no agent dir: immediate no-op (marker is never even read)', async () => {
+    const { deps, rec } = makeDeps({ agentDir: null })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(0)
+    expect(rec.clears).toBe(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('marker with no chats falls back to the access allowFrom chats', async () => {
+    const { deps, rec } = makeDeps({
+      marker: { premiumModel: 'fable', chats: [] },
+      fallbackChats: ['999'],
+    })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.sends.map((s) => s.chatId)).toEqual(['999'])
+  })
+})
+
+describe('runPremiumRecoveryPing — session-scoped switch-back button', () => {
+  it('the button callback_data is EXACTLY mdl:alias:<premium> (routes the model-menu apply path)', async () => {
+    const { deps, rec } = makeDeps({ marker: { premiumModel: 'fable', chats: ['111'] } })
+    await runPremiumRecoveryPing(deps)
+    const button = rec.sends[0].keyboard.inline_keyboard[0][0]
+    // Pin the exact wire format — a change to MODEL_CALLBACK_ALIAS or the button
+    // construction that broke the session-scoped `/model` apply path must fail here.
+    expect(button.callback_data).toBe('mdl:alias:fable')
+    expect(button.text).toBe('Switch to fable')
+  })
+})