switchroom 0.16.22 → 0.16.24

package/telegram-plugin/tests/answer-stream.test.ts

@@ -4,15 +4,16 @@ import {
   MIN_INITIAL_CHARS,
 } from '../answer-stream.js'
 import { resolveAnswerLaneConfig, ANSWER_LANE_NEVER_OPENS } from '../answer-stream-flag.js'
-import { markdownToHtml } from '../format.js'
-import { sanitizeTelegramHtml } from '../html-sanitize.js'
 
-/**
- * The exact renderer the gateway injects into createAnswerStream — markdown →
- * Telegram HTML, then HTML sanitize. Mirrors gateway.ts so the test pins the
- * real conversion, not a hand-rolled one.
- */
-const renderText = (text: string): string => sanitizeTelegramHtml(markdownToHtml(text))
+// #2669: the answer lane no longer converts markdown → HTML. It ships the RAW
+// assistant transcript markdown through its sendMessage/editMessageText
+// closures, which the gateway wires to the rich-message path
+// (`sendRichMessage` / `editMessageText({ markdown })`). There is no
+// renderText / parse_mode anymore — the body IS the raw GFM markdown.
+
+// The rich-message wire cap the answer lane guards against (matches
+// answer-stream.ts's TELEGRAM_MAX_CHARS).
+const TELEGRAM_MAX_CHARS = 32768
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -137,27 +138,27 @@ describe('answer-stream — minInitialChars threshold', () => {
     expect(sendMessage).toHaveBeenCalledWith(
       'chat1',
       'y'.repeat(500),
-      expect.objectContaining({ parse_mode: 'HTML' }),
+      // #2669: no parse_mode — the body ships as raw markdown via the rich path.
+      expect.not.objectContaining({ parse_mode: 'HTML' }),
     )
     expect(editMessageText).not.toHaveBeenCalled()
   })
 })
 
-describe('answer-stream — markdown → HTML conversion (renderText)', () => {
-  // Regression for the answer-stream-raw-markdown bug: this lane historically
-  // shipped the RAW assistant transcript under parse_mode:'HTML', so `**bold**`
-  // arrived as literal asterisks while every other lane converted. The fix
-  // injects the same renderText the other lanes use; these tests assert the
-  // wire payload is converted, not raw.
+describe('answer-stream — raw GFM markdown passthrough (#2669)', () => {
+  // The answer lane historically shipped the RAW assistant transcript under
+  // parse_mode:'HTML', so `**bold**` arrived as literal asterisks. Post-#2669
+  // there is ONE rich-markdown path: the lane ships the raw markdown VERBATIM
+  // (the gateway wraps it in `sendRichMessage` / `editMessageText({ markdown })`),
+  // so `**bold**` reaches Telegram intact and renders as bold there.
 
-  it('converts **bold** to <b>bold</b> on the opening sendMessage', async () => {
+  it('ships raw markdown verbatim on the opening sendMessage (no HTML conversion)', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()
     const stream = createAnswerStream({
       chatId: 'chat1',
       minInitialChars: 10,
       throttleMs: 250,
-      renderText,
       sendMessage,
       editMessageText,
     })
@@ -167,33 +168,27 @@ describe('answer-stream — markdown → HTML conversion (renderText)', () => {
 
     expect(sendMessage).toHaveBeenCalledTimes(1)
     const sentText = sendMessage.mock.calls[0][1] as string
-    expect(sentText).toContain('<b>bold</b>')
-    expect(sentText).not.toContain('**bold**')
-    expect(sendMessage).toHaveBeenCalledWith(
-      'chat1',
-      expect.stringContaining('<b>bold</b>'),
-      expect.objectContaining({ parse_mode: 'HTML' }),
-    )
+    // Raw markdown passes through unchanged — no <b> conversion.
+    expect(sentText).toContain('**bold**')
+    expect(sentText).not.toContain('<b>bold</b>')
+    expect(sendMessage.mock.calls[0][2]).not.toHaveProperty('parse_mode')
   })
 
-  it('converts **bold** to <b>bold</b> on a follow-up editMessageText', async () => {
+  it('ships raw markdown verbatim on a follow-up editMessageText', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()
     const stream = createAnswerStream({
       chatId: 'chat1',
       minInitialChars: 10,
       throttleMs: 250,
-      renderText,
       sendMessage,
       editMessageText,
     })
 
-    // First update opens the message.
     stream.update('first chunk of the answer arriving')
     await flushMicrotasks()
     expect(sendMessage).toHaveBeenCalledTimes(1)
 
-    // Second update (past the throttle window) edits in place with markdown.
     vi.advanceTimersByTime(300)
     stream.update('first chunk of the answer arriving with **bold** added')
     vi.advanceTimersByTime(300)
@@ -201,54 +196,31 @@ describe('answer-stream — markdown → HTML conversion (renderText)', () => {
 
     expect(editMessageText).toHaveBeenCalled()
     const editText = editMessageText.mock.calls.at(-1)![2] as string
-    expect(editText).toContain('<b>bold</b>')
-    expect(editText).not.toContain('**bold**')
+    expect(editText).toContain('**bold**')
+    expect(editText).not.toContain('<b>bold</b>')
   })
 
-  it('converts **bold** to <b>bold</b> on materialize', async () => {
+  it('ships raw markdown verbatim on materialize', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()
     const stream = createAnswerStream({
       chatId: 'chat1',
       minInitialChars: 10,
       throttleMs: 250,
-      renderText,
       sendMessage,
       editMessageText,
     })
 
     stream.update('The final answer is **definitely** forty-two.')
     await flushMicrotasks()
-    // Opening send already converted; capture how many sends precede materialize.
     const sendsBeforeMaterialize = sendMessage.mock.calls.length
 
     const id = await stream.materialize()
     expect(typeof id).toBe('number')
-    // materialize always sends a fresh message for the push notification.
     expect(sendMessage.mock.calls.length).toBe(sendsBeforeMaterialize + 1)
     const sentText = sendMessage.mock.calls.at(-1)![1] as string
-    expect(sentText).toContain('<b>definitely</b>')
-    expect(sentText).not.toContain('**definitely**')
-  })
-
-  it('sends raw text verbatim when no renderText is injected (back-compat)', async () => {
-    const sendMessage = makeSendMessage()
-    const editMessageText = makeEditMessageText()
-    const stream = createAnswerStream({
-      chatId: 'chat1',
-      minInitialChars: 10,
-      throttleMs: 250,
-      sendMessage,
-      editMessageText,
-    })
-
-    stream.update('Here is some **bold** narration text for the user.')
-    await flushMicrotasks()
-
-    expect(sendMessage).toHaveBeenCalledTimes(1)
-    const sentText = sendMessage.mock.calls[0][1] as string
-    // No renderer → unchanged (preserves prior behaviour for unwired callers).
-    expect(sentText).toContain('**bold**')
+    expect(sentText).toContain('**definitely**')
+    expect(sentText).not.toContain('<b>definitely</b>')
   })
 })
 
@@ -467,7 +439,7 @@ describe('answer-stream — empty / whitespace-only text is a no-op', () => {
 })
 
 describe('answer-stream — maxChars guard', () => {
-  it('does not send when text exceeds 4096 chars', async () => {
+  it('does not send when text exceeds the rich-message cap (#2669)', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()
     const stream = createAnswerStream({
@@ -478,14 +450,32 @@ describe('answer-stream — maxChars guard', () => {
       editMessageText,
     })
 
-    // 4097 chars exceeds Telegram's 4096 limit
-    stream.update('z'.repeat(4097))
+    // One char over the 32768 rich-message limit.
+    stream.update('z'.repeat(TELEGRAM_MAX_CHARS + 1))
     vi.advanceTimersByTime(1000)
     await flushMicrotasks()
 
     expect(sendMessage).not.toHaveBeenCalled()
     expect(editMessageText).not.toHaveBeenCalled()
   })
+
+  it('DOES send a body that fits under the 32768 cap (was rejected under the old 4096)', async () => {
+    const sendMessage = makeSendMessage()
+    const editMessageText = makeEditMessageText()
+    const stream = createAnswerStream({
+      chatId: 'chat1',
+      minInitialChars: 0,
+      throttleMs: 250,
+      sendMessage,
+      editMessageText,
+    })
+
+    // 8000 chars — over the legacy 4096 cap but well under the rich cap.
+    stream.update('z'.repeat(8000))
+    await flushMicrotasks()
+
+    expect(sendMessage).toHaveBeenCalledTimes(1)
+  })
 })
 
 describe('answer-stream — onSuperseded callback', () => {
@@ -532,7 +522,7 @@ describe('answer-stream — onSuperseded callback', () => {
 })
 
 describe('answer-stream — materialize() max-chars guard', () => {
-  it('does not send when buffered text exceeds 4096 chars', async () => {
+  it('does not send when buffered text exceeds the rich-message cap (#2669)', async () => {
     const sendMessage = makeSendMessage()
     const editMessageText = makeEditMessageText()
     const warn = vi.fn()
@@ -550,13 +540,14 @@ describe('answer-stream — materialize() max-chars guard', () => {
     await flushMicrotasks()
     const sendsAfterStreaming = sendMessage.mock.calls.length
 
-    stream.update('b'.repeat(4097))
+    // One char over the 32768 rich cap.
+    stream.update('b'.repeat(TELEGRAM_MAX_CHARS + 1))
     const result = await stream.materialize()
 
     expect(result).toBeUndefined()
     expect(sendMessage.mock.calls.length).toBe(sendsAfterStreaming)
     expect(warn).toHaveBeenCalled()
-    expect(warn.mock.calls.some((c) => /4096|exceeds/i.test(String(c[0])))).toBe(true)
+    expect(warn.mock.calls.some((c) => /32768|exceeds/i.test(String(c[0])))).toBe(true)
   })
 })
 
@@ -800,7 +791,7 @@ describe('answer-stream — onMetric callback (#203)', () => {
       onMetric,
     })
 
-    stream.update('x'.repeat(4097))
+    stream.update('x'.repeat(TELEGRAM_MAX_CHARS + 1))
     onMetric.mockClear()
     const id = await stream.materialize()
 

package/telegram-plugin/tests/auth-command-format2.test.ts

@@ -77,7 +77,7 @@ function mockClient(over: Partial<AuthBrokerClient> = {}): AuthBrokerClient {
 describe('renderShowText — Format 2 vs legacy', () => {
   it('falls back to legacy ASCII table when no liveQuotas given', () => {
     const out = renderShowText(FIXTURE_STATE, NOW_MS);
-    expect(out).toContain('<b>Auth — fleet snapshot</b>');
+    expect(out).toContain('**Auth — fleet snapshot**');
     expect(out).toContain('ACCOUNT');
     expect(out).toContain('STATUS');
     expect(out).toContain('EXPIRES');
@@ -91,10 +91,10 @@ describe('renderShowText — Format 2 vs legacy', () => {
       tz: 'UTC',
       liveProbedAtMs: NOW_MS,
     });
-    expect(out).toContain('🔋 <b>Auth — fleet status</b>');
+    expect(out).toContain('🔋 **Auth — fleet status**');
     expect(out).toContain('Recommendation:');
-    expect(out).toContain('🔴 <b>BLOCKED</b>');
-    expect(out).toContain('🟢 <b>HEALTHY</b>');
+    expect(out).toContain('🔴 **BLOCKED**');
+    expect(out).toContain('🟢 **HEALTHY**');
     // Legacy ASCII column headers should be absent
     expect(out).not.toContain('ACCOUNT     STATUS');
   });

package/telegram-plugin/tests/auth-command-vernacular.test.ts

@@ -511,10 +511,11 @@ describe('handleAuthCommand — help text lists every verb', () => {
       { agentName: 'x', isAdmin: true, client },
     )
     const text = reply.text
-    // Verbs (all variants). The help is HTML; <code> wraps each verb.
+    // Verbs (all variants). The help is GFM markdown (#2669); each verb is
+    // wrapped in a `code span`, so `<agent>` renders literally — no HTML escape.
     for (const fragment of [
       '/auth show',
-      '/auth show &lt;agent&gt;',
+      '/auth show <agent>',
       '/auth list',
       '/auth use',
       '/auth rotate',

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

@@ -194,16 +194,16 @@ describe('renderAuthSnapshotFormat2', () => {
   it('renders three health-grouped sections (BLOCKED first, then HEALTHY)', () => {
     const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
     // Headers present
-    expect(out).toContain('🔋 <b>Auth — fleet status</b>');
-    expect(out).toContain('🔴 <b>BLOCKED</b> (1)');
-    expect(out).toContain('🟢 <b>HEALTHY</b> (2)');
+    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('🟢'));
   });
 
   it('marks the active account with ●', () => {
     const out = renderAuthSnapshotFormat2(fixtureSnaps, { now: NOW, tz: 'UTC' });
-    expect(out).toMatch(/●\s*<code>you@example\.com<\/code>/);
+    expect(out).toMatch(/●\s*`you@example\.com`/);
   });
 
   it('shows "back …" for blocked accounts with binding-window word', () => {
@@ -253,7 +253,7 @@ describe('renderAuthSnapshotFormat2', () => {
     const out = renderAuthSnapshotFormat2(errSnaps, { now: NOW });
     expect(out).toContain('quota probe failed');
     expect(out).toContain('HTTP 401');
-    expect(out).toContain('⚪ <b>UNKNOWN</b>');
+    expect(out).toContain('⚪ **UNKNOWN**');
   });
 
   it('renders refresh stamp when liveProbedAtMs given', () => {
@@ -261,7 +261,7 @@ describe('renderAuthSnapshotFormat2', () => {
       now: NOW,
       liveProbedAtMs: NOW.getTime() - 12_000,
     });
-    expect(out).toMatch(/<i>Live · refreshed \d+s ago<\/i>/);
+    expect(out).toMatch(/_Live · refreshed \d+s ago_/);
   });
 
   it('#2495 Change 2 — renders "⚠ cached Nm ago" (NOT a live stamp) on staleCachedAtMs', () => {
@@ -269,7 +269,7 @@ describe('renderAuthSnapshotFormat2', () => {
       now: NOW,
       staleCachedAtMs: NOW.getTime() - 3 * 60_000, // 3 min old cache
     });
-    expect(out).toMatch(/<i>⚠ cached 3m ago<\/i>/);
+    expect(out).toMatch(/_⚠ cached 3m ago_/);
     // Crucially: no false live stamp.
     expect(out).not.toContain('Live · refreshed');
   });
@@ -302,7 +302,7 @@ describe('renderAuthSnapshotFormat2', () => {
       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(/<code>[^@<]+@example\.com<\/code>/);
+      expect(out).toMatch(/`[^@<]+@example\.com`/);
     });
 
     it('WITH demo, the recommendation footer masks the active label', () => {
@@ -381,7 +381,7 @@ describe('renderFallbackAnnouncement', () => {
       now: NOW,
       tz: 'UTC',
     });
-    expect(out).toContain('Triggered by: agent <b>carrie</b>');
+    expect(out).toContain('Triggered by: agent **carrie**');
     expect(out).toMatch(/ken@x.*recovers.*in 4h 57m/);
   });
 
@@ -419,7 +419,7 @@ describe('renderFallbackAnnouncement', () => {
       now: NOW,
       tz: 'UTC',
     });
-    expect(out).toContain('🔴 <b>All accounts blocked');
+    expect(out).toContain('🔴 **All accounts blocked');
     expect(out).toMatch(/ken@x recovers.*in 4h 57m/);
     expect(out).toContain('/auth add');
   });
@@ -461,7 +461,7 @@ describe('renderFallbackAnnouncement', () => {
       now: NOW,
       tz: 'UTC',
     });
-    expect(out).toContain('🔴 <b>All accounts blocked');
+    expect(out).toContain('🔴 **All accounts blocked');
     // Every account is listed (not just the trigger).
     expect(out).toContain('ken@x');
     expect(out).toContain('you@x');
@@ -474,7 +474,7 @@ describe('renderFallbackAnnouncement', () => {
     expect(out).toMatch(/quota exhausted/);
     // The earliest recovery across the fleet (carol, 5h reset at 03:00Z = ~2h)
     // is called out explicitly.
-    expect(out).toMatch(/Earliest recovery:\s*<code>carol@x<\/code>/);
+    expect(out).toMatch(/Earliest recovery:\s*`carol@x`/);
     expect(out).toContain('/auth add');
   });
 
@@ -488,7 +488,7 @@ describe('renderFallbackAnnouncement', () => {
       now: NOW,
       tz: 'UTC',
     });
-    expect(out).toContain('🔴 <b>All accounts blocked');
+    expect(out).toContain('🔴 **All accounts blocked');
     expect(out).toMatch(/ken@x recovers.*in 4h 57m/);
     expect(out).not.toContain('Earliest recovery:');
   });
@@ -866,10 +866,11 @@ describe('#2494 — renderAuthSnapshotFormat2 row rendering (out_of_credits demo
       { now: NOW },
     );
     // Must be in HEALTHY group, not BLOCKED
-    expect(out).toContain('🟢 <b>HEALTHY</b>');
-    expect(out).not.toContain('🔴 <b>BLOCKED</b>');
-    // Must have informational annotation
-    expect(out).toContain('overage off (out_of_credits) — serving from quota');
+    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).not.toContain('billing disabled');
     expect(out).not.toContain("won't recover until billing is fixed");
@@ -913,7 +914,7 @@ 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('🟡 <b>THROTTLING</b>');
+    expect(out).toContain('🟡 **THROTTLING**');
     expect(out).not.toContain('overage off');
   });
 

package/telegram-plugin/tests/auto-fallback-fleet.test.ts

@@ -78,7 +78,7 @@ describe('runFleetAutoFallback', () => {
       expect(out.oldLabel).toBe('ken@x');
       expect(out.newLabel).toBe('you@x');
       expect(out.announcement).toContain('5-hour limit on ken@x');
-      expect(out.announcement).toContain('Triggered by: agent <b>carrie</b>');
+      expect(out.announcement).toContain('Triggered by: agent **carrie**');
       expect(out.announcement).toContain('plenty of headroom');
     }
   });
@@ -248,20 +248,22 @@ import { renderFallbackFailureNotice } from "../auto-fallback-fleet.js";
 
 describe("renderFallbackFailureNotice", () => {
   it("names the trigger agent, the reason, and the manual recovery verbs", () => {
-    const html = renderFallbackFailureNotice("marko", "auth-broker unreachable (no client).");
-    expect(html).toContain("Auto-failover could not run");
-    expect(html).toContain("<b>marko</b>");
-    expect(html).toContain("auth-broker unreachable");
-    expect(html).toContain("/auth use");
-    expect(html).toContain("/auth</code>");
+    const out = renderFallbackFailureNotice("marko", "auth-broker unreachable (no client).");
+    expect(out).toContain("Auto-failover could not run");
+    expect(out).toContain("**marko**");
+    expect(out).toContain("auth-broker unreachable");
+    expect(out).toContain("/auth use");
+    expect(out).toContain("`/auth`");
   });
 
-  it("escapes HTML in the error reason (broker errors can contain angle brackets)", () => {
-    const html = renderFallbackFailureNotice("a<b", 'request <probe-quota> failed & "timed out"');
-    expect(html).toContain("a&lt;b");
-    expect(html).toContain("&lt;probe-quota&gt;");
-    expect(html).toContain("&amp;");
-    expect(html).not.toMatch(/<probe-quota>/);
+  it("passes < > & literally in the error reason (markdown, #2669)", () => {
+    // Broker errors can contain angle brackets — they are literal in rich
+    // markdown and cannot inject formatting; emphasis specials are escaped.
+    const out = renderFallbackFailureNotice("a<b", 'request <probe-quota> failed & a_b');
+    expect(out).toContain("a<b");
+    expect(out).toContain("<probe-quota>");
+    expect(out).toContain("&");
+    expect(out).toContain("a\\_b");
   });
 });
 

package/telegram-plugin/tests/boot-card-reason-to-render.test.ts

@@ -32,6 +32,16 @@ const NOW = 1_700_000_000_000
 const VERSION = 'v0.8.0+106'
 const AGENT = 'test-harness'
 
+// The crash row's tail-logs command is runtime-aware: in-container agents
+// (SWITCHROOM_RUNTIME=docker) get `docker logs …`, everything else gets
+// `journalctl …`. The bun-native test set inherits the live container env,
+// while vitest scrubs it — so assert against whichever branch the renderer
+// actually selected rather than pinning one shape (#2669).
+const TAIL_CMD = (slug: string): string =>
+  process.env.SWITCHROOM_RUNTIME === 'docker'
+    ? `\`docker logs --tail 100 switchroom-${slug}\``
+    : `\`journalctl --user -u switchroom-${slug} -n 100\``
+
 function rec(offsetMs: number) {
   return { ts: NOW - offsetMs }
 }
@@ -57,7 +67,7 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       version: VERSION,
       restartReason: reason,
     })
-    expect(card).toMatchInlineSnapshot(`"✅ <b>test-harness</b> back up · v0.8.0+106"`)
+    expect(card).toMatchInlineSnapshot(`"✅ **test-harness** back up · v0.8.0+106"`)
     // Negative assertions on the failure surface CC-8 worries about:
     expect(card).not.toContain('crash recovery')
     expect(card).not.toContain('journalctl')
@@ -83,10 +93,10 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       restartReason: reason,
       restartAgeMs: 3_400,
     })
-    expect(card).toContain('⚠️ <b>test-harness</b> back up')
-    expect(card).toContain('⚠️ <b>Restart</b>  crash recovery · 3.4s ago')
+    expect(card).toContain('⚠️ **test-harness** back up')
+    expect(card).toContain('⚠️ **Restart**  crash recovery · 3.4s ago')
     expect(card).toContain('Tail logs:')
-    expect(card).toContain('<code>journalctl --user -u switchroom-test-harness -n 100</code>')
+    expect(card).toContain(TAIL_CMD('test-harness'))
   })
 
   // ─── canonical crash: no marker at all ─────────────────────────
@@ -104,7 +114,7 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       restartReason: reason,
       restartAgeMs: 12_000,
     })
-    expect(card).toContain('⚠️ <b>test-harness</b> back up')
+    expect(card).toContain('⚠️ **test-harness** back up')
     expect(card).toContain('crash recovery · 12.0s ago')
     expect(card).toContain('Tail logs:')
   })
@@ -143,7 +153,7 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       version: VERSION,
       restartReason: reason,
     })
-    expect(card).toMatchInlineSnapshot(`"✅ <b>test-harness</b> back up · v0.8.0+106"`)
+    expect(card).toMatchInlineSnapshot(`"✅ **test-harness** back up · v0.8.0+106"`)
     expect(card).not.toContain('crash recovery')
   })
 
@@ -161,15 +171,17 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       version: VERSION,
       restartReason: reason,
     })
-    expect(card).toMatchInlineSnapshot(`"🆕 <b>test-harness</b> back up · v0.8.0+106"`)
+    expect(card).toMatchInlineSnapshot(`"🆕 **test-harness** back up · v0.8.0+106"`)
     expect(card).not.toContain('crash recovery')
   })
 
-  // ─── slug override path: agentSlug used in journalctl, not agentName ───
-  it('crash card uses agentSlug (not agentName) in the journalctl command', () => {
-    // The journalctl row is the user's actionable next step — if the
+  // ─── slug override path: agentSlug used in tail-logs cmd, not agentName ───
+  it('crash card uses agentSlug (not agentName) in the tail-logs command', () => {
+    // The tail-logs row is the user's actionable next step — if the
     // slug ever drifts (capitalization, special chars), the copy-paste
-    // command stops working. Pin the slug pathway explicitly.
+    // command stops working. Pin the slug pathway explicitly. The command
+    // shape (docker vs journalctl) is runtime-determined; the slug must be
+    // the lowercase systemd slug regardless.
     const card = renderBootCard({
       agentName: 'Test Harness Display',
       agentSlug: 'test-harness',
@@ -177,6 +189,9 @@ describe('boot-card: reason → user-visible render (CC-8)', () => {
       restartReason: 'crash',
       restartAgeMs: 800,
     })
-    expect(card).toContain('<code>journalctl --user -u switchroom-test-harness -n 100</code>')
+    expect(card).toContain(TAIL_CMD('test-harness'))
+    // And never the display name in the unit target.
+    expect(card).not.toContain('Test Harness Display -n')
+    expect(card).not.toContain('switchroom-Test Harness Display')
   })
 })