switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/boot-card-issue-dedup.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Unit tests for the boot-issue dedup module (`boot-issue-cache.ts`).
+ *
+ * Covers the four canonical lifecycles a probe can move through across
+ * consecutive boots:
+ *
+ *   1. novel    — first boot a fingerprint is seen → not snoozed, not resolved
+ *   2. repeated — fingerprint matches prior boot → counter increments
+ *   3. snoozed  — same fingerprint past snoozeBoots / snoozeMs → hidden
+ *   4. resolved — was degraded/fail last boot, ok this boot → resolved=true
+ *
+ * Plus persistence guardrails (corrupt cache, schema mismatch, GC).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, readFileSync, writeFileSync, existsSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+
+import {
+  fingerprintProbe,
+  diffProbes,
+  loadCache,
+  applyAndSave,
+  DEFAULT_SNOOZE_BOOTS,
+  type BootIssueCacheFile,
+} from '../gateway/boot-issue-cache.js'
+import type { ProbeMap } from '../gateway/boot-card.js'
+
+let tmp: string
+beforeEach(() => { tmp = mkdtempSync(join(tmpdir(), 'boot-issue-')) })
+afterEach(() => { rmSync(tmp, { recursive: true, force: true }) })
+
+describe('fingerprintProbe — per-probe fold policy', () => {
+  it('skills folds across dangling count and named entries', () => {
+    const a = fingerprintProbe('skills', {
+      status: 'degraded', label: 'Skills',
+      detail: '3/12 dangling: alpha, beta, gamma',
+    })
+    const b = fingerprintProbe('skills', {
+      status: 'degraded', label: 'Skills',
+      detail: '5/12 dangling: alpha, beta, gamma, delta, epsilon',
+    })
+    expect(a).toBe(b)
+  })
+
+  it('account folds by status_kind (signed-out vs token-expiring vs token-expired)', () => {
+    const signedOut1 = fingerprintProbe('account', { status: 'degraded', label: 'Account', detail: 'not signed in' })
+    const signedOut2 = fingerprintProbe('account', { status: 'degraded', label: 'Account', detail: 'Not Signed In' })
+    expect(signedOut1).toBe(signedOut2)
+
+    const exp1 = fingerprintProbe('account', { status: 'degraded', label: 'Account', detail: 'a@b · Pro · token 4d' })
+    const exp2 = fingerprintProbe('account', { status: 'degraded', label: 'Account', detail: 'a@b · Pro · token 6d' })
+    expect(exp1).toBe(exp2)
+    expect(exp1).not.toBe(signedOut1)
+  })
+
+  it('agent folds by raw systemd state string', () => {
+    const a = fingerprintProbe('agent', { status: 'fail', label: 'Agent', detail: 'service failed' })
+    const b = fingerprintProbe('agent', { status: 'fail', label: 'Agent', detail: 'service failed' })
+    expect(a).toBe(b)
+    const c = fingerprintProbe('agent', { status: 'degraded', label: 'Agent', detail: 'service activating' })
+    expect(a).not.toBe(c)
+  })
+
+  it('broker / kernel / hindsight use literal detail (normalized)', () => {
+    const broker1 = fingerprintProbe('broker', { status: 'fail', label: 'Broker', detail: 'socket missing' })
+    const broker2 = fingerprintProbe('broker', { status: 'fail', label: 'Broker', detail: 'socket missing' })
+    expect(broker1).toBe(broker2)
+    const broker3 = fingerprintProbe('broker', { status: 'fail', label: 'Broker', detail: 'connection refused' })
+    expect(broker1).not.toBe(broker3)
+  })
+
+  it('ok results all share a single per-probe fingerprint', () => {
+    const a = fingerprintProbe('skills', { status: 'ok', label: 'Skills', detail: '12 resolved' })
+    const b = fingerprintProbe('skills', { status: 'ok', label: 'Skills', detail: '8 resolved' })
+    expect(a).toBe(b)
+    expect(a).toBe('skills:ok')
+  })
+})
+
+describe('diffProbes — lifecycle: novel → repeated → snoozed → resolved', () => {
+  it('novel: first sighting → not snoozed, not resolved, counter=1', () => {
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'socket missing' } }
+    const diff = diffProbes(probes, { schema: 1, probes: {} }, { now: () => 1000 })
+    expect(diff.broker?.snoozed).toBe(false)
+    expect(diff.broker?.resolved).toBe(false)
+    expect(diff.broker?.firstSighting).toBe(true)
+    expect(diff.broker?.nextEntry?.consecutiveBoots).toBe(1)
+  })
+
+  it('repeated: same fingerprint → counter increments, still surfaced (not snoozed) below threshold', () => {
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'socket missing' } }
+    const cache: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: {
+          fingerprint: 'broker:fail:socket missing',
+          consecutiveBoots: 3,
+          firstSeenMs: 1000,
+          lastSeenMs: 2000,
+        },
+      },
+    }
+    const diff = diffProbes(probes, cache, { now: () => 3000, snoozeBoots: 10, snoozeMs: 1_000_000 })
+    expect(diff.broker?.snoozed).toBe(false)
+    expect(diff.broker?.nextEntry?.consecutiveBoots).toBe(4)
+  })
+
+  it('snoozed: same fingerprint past snoozeBoots → snoozed=true', () => {
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'socket missing' } }
+    const cache: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: {
+          fingerprint: 'broker:fail:socket missing',
+          consecutiveBoots: DEFAULT_SNOOZE_BOOTS, // next boot triggers snooze
+          firstSeenMs: 1000,
+          lastSeenMs: 2000,
+        },
+      },
+    }
+    const diff = diffProbes(probes, cache, { now: () => 3000, snoozeMs: 1_000_000_000 })
+    expect(diff.broker?.snoozed).toBe(true)
+    expect(diff.broker?.nextEntry?.consecutiveBoots).toBe(DEFAULT_SNOOZE_BOOTS + 1)
+  })
+
+  it('snoozed: same fingerprint past snoozeMs → snoozed=true even if below boot count', () => {
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'socket missing' } }
+    const cache: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: {
+          fingerprint: 'broker:fail:socket missing',
+          consecutiveBoots: 2,
+          firstSeenMs: 1000,
+          lastSeenMs: 1500,
+        },
+      },
+    }
+    const diff = diffProbes(probes, cache, {
+      now: () => 1000 + 4 * 24 * 60 * 60 * 1000, // 4 days later
+      snoozeMs: 3 * 24 * 60 * 60 * 1000, // 3-day window
+      snoozeBoots: 100,
+    })
+    expect(diff.broker?.snoozed).toBe(true)
+  })
+
+  it('resolved: was degraded last boot, now ok → resolved=true, nextEntry=null', () => {
+    const probes: ProbeMap = { broker: { status: 'ok', label: 'Broker', detail: 'reachable' } }
+    const cache: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: {
+          fingerprint: 'broker:fail:socket missing',
+          consecutiveBoots: 2,
+          firstSeenMs: 1000,
+          lastSeenMs: 2000,
+        },
+      },
+    }
+    const diff = diffProbes(probes, cache, { now: () => 3000 })
+    expect(diff.broker?.resolved).toBe(true)
+    expect(diff.broker?.snoozed).toBe(false)
+    expect(diff.broker?.nextEntry).toBeNull()
+  })
+
+  it('fingerprint change resets counter — new failure mode shows even if old one was snoozed', () => {
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'connection refused' } }
+    const cache: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: {
+          fingerprint: 'broker:fail:socket missing',
+          consecutiveBoots: 50,
+          firstSeenMs: 1000,
+          lastSeenMs: 2000,
+        },
+      },
+    }
+    const diff = diffProbes(probes, cache, { now: () => 3000 })
+    expect(diff.broker?.snoozed).toBe(false)
+    expect(diff.broker?.nextEntry?.consecutiveBoots).toBe(1)
+    expect(diff.broker?.firstSighting).toBe(true)
+  })
+})
+
+describe('loadCache / applyAndSave — persistence', () => {
+  it('round-trips a diff: save then load yields the same probe entries', () => {
+    const path = join(tmp, 'cache.json')
+    const probes: ProbeMap = { broker: { status: 'fail', label: 'Broker', detail: 'socket missing' } }
+    const empty: BootIssueCacheFile = { schema: 1, probes: {} }
+    const diff = diffProbes(probes, empty, { now: () => 1000 })
+    applyAndSave(path, empty, diff)
+    expect(existsSync(path)).toBe(true)
+    const loaded = loadCache(path, () => 1000) // same clock as the diff
+    expect(loaded.probes.broker?.fingerprint).toBe(diff.broker?.fingerprint)
+  })
+
+  it('resolved probe removes its entry from the cache (nextEntry=null)', () => {
+    const path = join(tmp, 'cache.json')
+    const seed: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: { fingerprint: 'broker:fail:x', consecutiveBoots: 2, firstSeenMs: 1, lastSeenMs: 2 },
+      },
+    }
+    writeFileSync(path, JSON.stringify(seed))
+    const loaded = loadCache(path, () => 1000)
+    expect(loaded.probes.broker).toBeDefined()
+    const probes: ProbeMap = { broker: { status: 'ok', label: 'Broker', detail: 'reachable' } }
+    const diff = diffProbes(probes, loaded, { now: () => 1000 })
+    applyAndSave(path, loaded, diff)
+    const reloaded = loadCache(path, () => 1000)
+    expect(reloaded.probes.broker).toBeUndefined()
+  })
+
+  it('corrupt cache file is renamed aside and an empty cache is returned', () => {
+    const path = join(tmp, 'cache.json')
+    writeFileSync(path, 'not-json-{{{')
+    const loaded = loadCache(path, () => 12345)
+    expect(loaded.probes).toEqual({})
+    // The corrupt file is preserved for forensics.
+    expect(existsSync(`${path}.corrupt-12345`)).toBe(true)
+  })
+
+  it('schema mismatch is treated like empty', () => {
+    const path = join(tmp, 'cache.json')
+    writeFileSync(path, JSON.stringify({ schema: 99, probes: {} }))
+    const loaded = loadCache(path)
+    expect(loaded.probes).toEqual({})
+  })
+
+  it('GC drops entries older than 30 days on load', () => {
+    const path = join(tmp, 'cache.json')
+    const seed: BootIssueCacheFile = {
+      schema: 1,
+      probes: {
+        broker: { fingerprint: 'x', consecutiveBoots: 1, firstSeenMs: 0, lastSeenMs: 0 },
+      },
+    }
+    writeFileSync(path, JSON.stringify(seed))
+    // Now = far enough that 0-mtime entry exceeds 30d.
+    const loaded = loadCache(path, () => 60 * 24 * 60 * 60 * 1000)
+    expect(loaded.probes.broker).toBeUndefined()
+  })
+})

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

@@ -0,0 +1,182 @@
+/**
+ * Integration unit test — couples `determineRestartReason` to
+ * `renderBootCard` so the user-visible output is pinned across the
+ * decision boundary.
+ *
+ * Cause class CC-8 from `docs/status-ask-cause-classes.md`:
+ *
+ *   Boot card silenced on operator update vs. silent on a real crash.
+ *
+ *   Clean-shutdown marker (#1139/#1141/#1142) silences the boot card
+ *   on operator-driven restarts. If the marker is stamped erroneously
+ *   (or the 5-min freshness window is too generous on a slow boot),
+ *   the card stays silent after a real crash → user sees the agent
+ *   come back with no acknowledgement → asks "did you crash?".
+ *
+ * `boot-card-reason.test.ts` covers the decision in isolation. This
+ * file pins the next link: given the decision, what string lands in
+ * the user's chat? Specifically, on `'crash'` the card MUST surface
+ * the ⚠️ row + journalctl `nextStep` hint; on `'graceful'` /
+ * `'planned'` it MUST NOT (no crash row, just the ack).
+ *
+ * Together: a refactor that subtly drops the crash row, swaps the
+ * emoji on `'crash'`, or accidentally renders the crash row on
+ * `'graceful'`, fails one of these snapshots at test time.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import { determineRestartReason } from '../gateway/boot-reason.js'
+import { renderBootCard } from '../gateway/boot-card.js'
+
+const NOW = 1_700_000_000_000
+const VERSION = 'v0.8.0+106'
+const AGENT = 'test-harness'
+
+function rec(offsetMs: number) {
+  return { ts: NOW - offsetMs }
+}
+
+function clean(offsetMs: number, reason?: string) {
+  return { ts: NOW - offsetMs, signal: 'SIGTERM', reason }
+}
+
+const session = { pid: 1234 }
+
+describe('boot-card: reason → user-visible render (CC-8)', () => {
+  // ─── happy path: clean operator restart, recently stamped ──────
+  it('clean operator restart within 5min window renders ack only (no crash row)', () => {
+    const reason = determineRestartReason({
+      marker: null,
+      cleanMarker: clean(97_000, 'operator: switchroom update'),
+      sessionMarker: session,
+      now: NOW,
+    })
+    expect(reason).toBe('graceful')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      restartReason: reason,
+    })
+    expect(card).toMatchInlineSnapshot(`"✅ <b>test-harness</b> 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')
+    expect(card).not.toContain('⚠️')
+  })
+
+  // ─── the worry case: marker erroneously stamped, real crash later ──
+  it('operator marker stale beyond 5min + session marker → crash card with hint', () => {
+    // 6 min after stamping — operator-extended window has expired,
+    // so even a planned-looking marker reads as a crash. This is
+    // EXACTLY CC-8's failure shape: if we'd left this case silent,
+    // the user would never see the crash recovery row.
+    const reason = determineRestartReason({
+      marker: null,
+      cleanMarker: clean(6 * 60_000, 'operator: switchroom update'),
+      sessionMarker: session,
+      now: NOW,
+    })
+    expect(reason).toBe('crash')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      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('Tail logs:')
+    expect(card).toContain('<code>journalctl --user -u switchroom-test-harness -n 100</code>')
+  })
+
+  // ─── canonical crash: no marker at all ─────────────────────────
+  it('no markers + session marker → crash card with hint', () => {
+    const reason = determineRestartReason({
+      marker: null,
+      cleanMarker: null,
+      sessionMarker: session,
+      now: NOW,
+    })
+    expect(reason).toBe('crash')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      restartReason: reason,
+      restartAgeMs: 12_000,
+    })
+    expect(card).toContain('⚠️ <b>test-harness</b> back up')
+    expect(card).toContain('crash recovery · 12.0s ago')
+    expect(card).toContain('Tail logs:')
+  })
+
+  // ─── user /restart (non-operator): tight 60s window applies ────
+  it('user: /restart marker stale beyond 60s → crash card (tight window not extended)', () => {
+    // A /restart from chat that takes >60s before its gateway boots
+    // is a real crash; the catalog's CC-8 worry includes this path.
+    const reason = determineRestartReason({
+      marker: null,
+      cleanMarker: clean(90_000, 'user: /restart from chat'),
+      sessionMarker: session,
+      now: NOW,
+    })
+    expect(reason).toBe('crash')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      restartReason: reason,
+      restartAgeMs: 1_500,
+    })
+    expect(card).toContain('crash recovery · 1.5s ago')
+  })
+
+  // ─── planned restart via switchroom: ack only ──────────────────
+  it('planned restart (marker present, fresh) → ack only', () => {
+    const reason = determineRestartReason({
+      marker: rec(10_000),
+      cleanMarker: null,
+      sessionMarker: session,
+      now: NOW,
+    })
+    expect(reason).toBe('planned')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      restartReason: reason,
+    })
+    expect(card).toMatchInlineSnapshot(`"✅ <b>test-harness</b> back up · v0.8.0+106"`)
+    expect(card).not.toContain('crash recovery')
+  })
+
+  // ─── fresh first start: distinct emoji, ack only ───────────────
+  it('fresh first start (no markers, no session) → 🆕 ack', () => {
+    const reason = determineRestartReason({
+      marker: null,
+      cleanMarker: null,
+      sessionMarker: null,
+      now: NOW,
+    })
+    expect(reason).toBe('fresh')
+    const card = renderBootCard({
+      agentName: AGENT,
+      version: VERSION,
+      restartReason: reason,
+    })
+    expect(card).toMatchInlineSnapshot(`"🆕 <b>test-harness</b> 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 ever drifts (capitalization, special chars), the copy-paste
+    // command stops working. Pin the slug pathway explicitly.
+    const card = renderBootCard({
+      agentName: 'Test Harness Display',
+      agentSlug: 'test-harness',
+      version: VERSION,
+      restartReason: 'crash',
+      restartAgeMs: 800,
+    })
+    expect(card).toContain('<code>journalctl --user -u switchroom-test-harness -n 100</code>')
+  })
+})

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

@@ -16,8 +16,10 @@ function recentMarker(offsetMs = 0) {
   return { ts: NOW - offsetMs }
 }
 
-function recentCleanMarker(offsetMs = 0) {
-  return { ts: NOW - offsetMs }
+function recentCleanMarker(offsetMs = 0, reason?: string) {
+  // `signal` is part of the CleanShutdownMarker shape; required at the
+  // type level but not exercised by determineRestartReason itself.
+  return { ts: NOW - offsetMs, signal: 'SIGTERM', reason }
 }
 
 function sessionMarker() {
@@ -89,6 +91,67 @@ describe('determineRestartReason', () => {
     expect(result).toBe('planned')
   })
 
+  it('returns "graceful" when clean-shutdown marker has operator: reason and is within the extended 5-min window (#1141 follow-up: 9-agent fleet recreate can exceed 60s)', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(97_000, 'operator: switchroom update'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+    })
+    expect(result).toBe('graceful')
+  })
+
+  it('still treats operator: marker as stale beyond 5 min (longer window not "silent forever")', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(6 * 60_000, 'operator: switchroom update'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+    })
+    expect(result).toBe('crash')
+  })
+
+  it('non-operator reasons (user:, cli:) keep the tight 60s window — a /restart that takes >60s before its gateway boots is still a crash', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(90_000, 'user: /restart from chat'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+    })
+    expect(result).toBe('crash')
+  })
+
+  it('cli: reasons also keep the tight 60s window', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(90_000, 'cli: switchroom restart'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+    })
+    expect(result).toBe('crash')
+  })
+
+  it('operator: marker just barely inside the 5-min window still graceful', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(4 * 60_000 + 59_000, 'operator: switchroom update'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+    })
+    expect(result).toBe('graceful')
+  })
+
+  it('respects operatorMaxAgeMs override (tests can tighten the window)', () => {
+    const result = determineRestartReason({
+      marker: null,
+      cleanMarker: recentCleanMarker(120_000, 'operator: switchroom update'),
+      sessionMarker: sessionMarker(),
+      now: NOW,
+      operatorMaxAgeMs: 60_000, // override tightens to 60s
+    })
+    expect(result).toBe('crash')
+  })
+
   it('respects custom markerMaxAgeMs — stale marker does not count as planned', () => {
     const result = determineRestartReason({
       marker: recentMarker(10 * 60_000),  // 10 min ago

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

@@ -135,6 +135,95 @@ describe('renderBootCard — degraded conditions', () => {
     expect(out).toContain('🟡 <b>Account</b>  expiring')
   })
 
+  it('renders nextStep as an indented continuation line beneath a degraded row', () => {
+    // Principle 1 ("If they need the docs, we've failed"): every degraded
+    // probe should surface its remediation inline. Plain backticks in the
+    // nextStep get translated to <code> spans so the command stays tap-to-
+    // copy on mobile.
+    const out = renderBootCard({
+      agentName: 'lawgpt',
+      version: 'v0.7.16',
+      probes: {
+        skills: {
+          status: 'degraded',
+          label: 'Skills',
+          detail: '10/10 dangling: a, b, c +7 more',
+          nextStep: 'Run `switchroom agent reconcile lawgpt` to rebuild symlinks',
+        },
+      },
+    })
+    expect(out).toContain('🟡 <b>Skills</b>  10/10 dangling')
+    expect(out).toContain('    ↳ Run <code>switchroom agent reconcile lawgpt</code> to rebuild symlinks')
+  })
+
+  it('crash row carries a tail-logs next-step', () => {
+    const out = renderBootCard({
+      agentName: 'lawgpt',
+      version: 'v0.7.16',
+      restartReason: 'crash',
+      restartAgeMs: 6_100,
+    })
+    expect(out).toContain('⚠️ <b>Restart</b>  crash recovery · 6.1s ago')
+    expect(out).toContain('↳ Tail logs: <code>journalctl --user -u switchroom-lawgpt -n 100</code>')
+  })
+
+  it('crash row uses agentSlug for the systemd unit when provided', () => {
+    const out = renderBootCard({
+      agentName: 'LawGPT',
+      agentSlug: 'lawgpt',
+      version: 'v1',
+      restartReason: 'crash',
+    })
+    expect(out).toContain('switchroom-lawgpt')
+    expect(out).not.toContain('switchroom-LawGPT')
+  })
+
+  it('renderNextStep escapes HTML inside backtick-quoted commands', () => {
+    const out = renderBootCard({
+      agentName: 'a',
+      version: 'v',
+      probes: {
+        account: {
+          status: 'fail',
+          label: 'Account',
+          detail: 'expired',
+          nextStep: 'Run `foo <bar> & baz` to fix',
+        },
+      },
+    })
+    expect(out).toContain('<code>foo &lt;bar&gt; &amp; baz</code>')
+    expect(out).not.toContain('<bar>')
+  })
+
+  it('unpaired backticks in nextStep fall back to plain escaped text', () => {
+    const out = renderBootCard({
+      agentName: 'a',
+      version: 'v',
+      probes: {
+        account: {
+          status: 'fail',
+          label: 'Account',
+          detail: 'expired',
+          nextStep: 'Run `switchroom foo to fix',
+        },
+      },
+    })
+    expect(out).toContain('↳ Run `switchroom foo to fix')
+    expect(out).not.toContain('<code>')
+  })
+
+  it('degraded rows without nextStep render unchanged (backwards compat)', () => {
+    const out = renderBootCard({
+      agentName: 'a',
+      version: 'v',
+      probes: {
+        quota: { status: 'fail', label: 'Quota', detail: 'rate limited' },
+      },
+    })
+    expect(out).toContain('🔴 <b>Quota</b>  rate limited')
+    expect(out).not.toContain('↳')
+  })
+
   it('null probe entries are skipped (defensive against partial probe maps)', () => {
     const out = renderBootCard({
       agentName: 'a',
@@ -218,3 +307,60 @@ describe('resolvePersonaName — persona name over slug (#169)', () => {
     expect(out).not.toContain('<b>finn</b>')
   })
 })
+
+// ── Issue dedup rendering ──────────────────────────────────────────────────
+// Resolved rows render at the top of the degraded section; snoozed rows
+// suppress the matching probe row entirely.
+
+describe('renderBootCard — resolved / snooze rendering', () => {
+  it('renders a ✅ "resolved" row for each entry in resolvedRows above the degraded section', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      probes: {
+        broker: { status: 'fail', label: 'Broker', detail: 'socket missing' },
+      },
+      resolvedRows: ['hindsight'],
+    })
+    expect(out).toContain('✅ <b>Hindsight</b>  resolved')
+    expect(out).toContain('🔴 <b>Broker</b>  socket missing')
+    // Resolved appears BEFORE Broker.
+    expect(out.indexOf('Hindsight')).toBeLessThan(out.indexOf('Broker'))
+  })
+
+  it('skips a degraded row when its probe key is in snoozeRows', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      probes: {
+        broker: { status: 'fail', label: 'Broker', detail: 'socket missing' },
+        kernel: { status: 'fail', label: 'Kernel', detail: 'socket missing' },
+      },
+      snoozeRows: ['broker'],
+    })
+    expect(out).not.toContain('Broker')
+    expect(out).toContain('Kernel')
+  })
+
+  it('snoozed everything → output is the bare ack line (silent-when-snoozed)', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v0.1',
+      probes: {
+        broker: { status: 'fail', label: 'Broker', detail: 'socket missing' },
+      },
+      snoozeRows: ['broker'],
+    })
+    expect(out).toBe('✅ <b>k</b> back up · v0.1')
+  })
+
+  it('resolvedRows alone (no probes degraded) renders the resolved row beneath the ack', () => {
+    const out = renderBootCard({
+      agentName: 'k',
+      version: 'v',
+      resolvedRows: ['skills', 'broker'],
+    })
+    expect(out).toContain('✅ <b>Skills</b>  resolved')
+    expect(out).toContain('✅ <b>Broker</b>  resolved')
+  })
+})