switchroom 0.16.28 → 0.16.38

package/telegram-plugin/tests/credits-watch.test.ts

@@ -188,6 +188,24 @@ describe("evaluateCreditState — transition decisions (machinery, explicit fata
     // The underscore is escaped so it can't open an italic run inside **…**.
     expect(d.message).toContain("ev\\_il");
   });
+
+  // Boundary-escaping after the #2695 escaper de-dup: the entry message escapes
+  // BOTH the agent name and the raw reason via the consolidated `escapeMarkdown`
+  // import. A metacharacter-laden value through each site proves the import swap
+  // preserved escaping at this call-site.
+  it("escapes metacharacters in both the agent name and the cached reason (#2695)", () => {
+    const d = evaluateCreditState({
+      agentName: "a_b*c",
+      currentReason: "weird_reason*x",
+      prev: HEALTHY,
+      now: NOW,
+      fatalReasons: new Set(["weird_reason*x"]),
+    });
+    expect(d.kind).toBe("notify");
+    if (d.kind !== "notify") return;
+    expect(d.message).toContain("a\\_b\\*c");
+    expect(d.message).toContain("weird\\_reason\\*x");
+  });
 });
 
 describe("evaluateCreditState — subscription-only default (the fix)", () => {

package/telegram-plugin/tests/history.test.ts

@@ -28,19 +28,55 @@ afterEach(() => {
 })
 
 describe('initHistory', () => {
-  it('creates history.db with chmod 0600', () => {
+  it('creates history.db with chmod 0644', () => {
     initHistory(stateDir, 30)
     const dbPath = join(stateDir, 'history.db')
     expect(existsSync(dbPath)).toBe(true)
     const st = statSync(dbPath)
     // Mask off the file-type bits — only the perm bits matter.
-    expect(st.mode & 0o777).toBe(0o600)
+    // 0644: the web container (uid 1000) opens history.db read-only to
+    // stream replies back to Hermes Desktop. Content is redacted on write,
+    // so world-readable is safe (owner-approved behaviour change).
+    expect(st.mode & 0o777).toBe(0o644)
   })
 
   it('is idempotent — second call is a no-op', () => {
     initHistory(stateDir, 30)
     expect(() => initHistory(stateDir, 30)).not.toThrow()
   })
+
+  // Regression for HERMES #2689 review defect #1: the web process (a different
+  // uid than the agent) opens history.db READ-ONLY to stream Telegram replies
+  // back to Hermes Desktop. If the db/WAL sidecars were left 0600, that open
+  // fails and the real-time sync poller silently no-ops. Assert both the perm
+  // bits AND that a readonly open + the poller's exact SELECT succeed.
+  it('history.db is world-readable and the Hermes poller can open it read-only', async () => {
+    initHistory(stateDir, 30)
+    recordInbound({ chat_id: '1', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'hi' })
+    recordOutbound({ chat_id: '1', thread_id: null, message_ids: [2], texts: ['hello'], ts: 200 })
+
+    const dbPath = join(stateDir, 'history.db')
+    // Force a WAL sidecar to exist so we exercise the -wal/-shm perm path too.
+    for (const suffix of ['', '-shm', '-wal']) {
+      const f = dbPath + suffix
+      if (existsSync(f)) expect(statSync(f).mode & 0o777).toBe(0o644)
+    }
+
+    // Reproduce the poller's open (src/web/hermes-adapter.ts startHistoryPoll):
+    // readonly connection + MAX(rowid) + assistant-row SELECT.
+    const { Database } = await import('bun:sqlite')
+    const rdb = new Database(dbPath, { readonly: true })
+    try {
+      const max = rdb.prepare('SELECT MAX(rowid) AS r FROM messages').get() as { r: number | null }
+      expect(max.r).toBeGreaterThan(0)
+      const rows = rdb
+        .prepare("SELECT rowid, role, text FROM messages WHERE rowid > ? AND role = 'assistant' ORDER BY rowid ASC")
+        .all(0) as Array<{ role: string; text: string }>
+      expect(rows.some((r) => r.text === 'hello')).toBe(true)
+    } finally {
+      rdb.close()
+    }
+  })
 })
 
 describe('recordInbound + query', () => {

package/telegram-plugin/tests/idle-footer.test.ts

@@ -20,39 +20,83 @@ describe("formatIdleFooter", () => {
 
   it("single old turn ended 1h ago → idle 1h ago", () => {
     const r = row({ startedAt: NOW - 70 * 60_000, endedAt: NOW - 60 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 1h ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **1h ago**");
   });
 
   it("single turn ended 3m ago → idle 3m ago", () => {
     const r = row({ startedAt: NOW - 5 * 60_000, endedAt: NOW - 3 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 3m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **3m ago**");
   });
 
   it("single turn ended 10s ago → idle <1m ago", () => {
     const r = row({ startedAt: NOW - 30_000, endedAt: NOW - 10_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply <1m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **<1m ago**");
   });
 
-  it("currently running turn started 2m ago → working since 2m ago", () => {
+  it("currently running turn started 2m ago → working since **2m ago**", () => {
     const r = row({ startedAt: NOW - 2 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("⚙️ working since 2m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("⚙️ working since **2m ago**");
   });
 
   it("multiple turns, most recent is running → working since recent", () => {
     const old = row({ turnKey: "t1", startedAt: NOW - 10 * 60_000, endedAt: NOW - 8 * 60_000 });
     const running = row({ turnKey: "t2", startedAt: NOW - 90_000 }); // 1m 30s ago
-    expect(formatIdleFooter([old, running], NOW)).toBe("⚙️ working since 1m ago");
+    expect(formatIdleFooter([old, running], NOW)).toBe("⚙️ working since **1m ago**");
   });
 
   it("multiple turns, most recent is ended → idle last reply", () => {
     const old = row({ turnKey: "t1", startedAt: NOW - 30 * 60_000, endedAt: NOW - 28 * 60_000 });
     const recent = row({ turnKey: "t2", startedAt: NOW - 6 * 60_000, endedAt: NOW - 4 * 60_000 });
-    expect(formatIdleFooter([old, recent], NOW)).toBe("🟢 idle · last reply 4m ago");
+    expect(formatIdleFooter([old, recent], NOW)).toBe("🟢 idle · last reply **4m ago**");
   });
 
   it("day-old turn → 1d ago", () => {
     const r = row({ startedAt: NOW - 26 * 3_600_000, endedAt: NOW - 25 * 3_600_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 1d ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **1d ago**");
+  });
+
+  it("no-data (quiet) state carries NO ** markup", () => {
+    const out = formatIdleFooter([], NOW);
+    expect(out).toBe("🟡 quiet · no turns yet");
+    expect(out).not.toContain("**");
+  });
+
+  it("working state bolds ONLY the elapsed value, not the whole line", () => {
+    const r = row({ startedAt: NOW - 4 * 60_000 });
+    const out = formatIdleFooter([r], NOW);
+    // The bold span wraps the time and only the time.
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold).not.toBeNull();
+    expect(bold![1]).toBe("4m ago");
+    // The label "⚙️ working since " is outside the bold span.
+    expect(out).toBe("⚙️ working since **4m ago**");
+    // Exactly one bold span (two `**` delimiters).
+    expect((out.match(/\*\*/g) ?? []).length).toBe(2);
+  });
+
+  it("idle state bolds ONLY the last-reply value, not the whole line", () => {
+    const r = row({ startedAt: NOW - 6 * 60_000, endedAt: NOW - 3 * 60_000 });
+    const out = formatIdleFooter([r], NOW);
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold).not.toBeNull();
+    expect(bold![1]).toBe("3m ago");
+    expect(out).toBe("🟢 idle · last reply **3m ago**");
+    expect((out.match(/\*\*/g) ?? []).length).toBe(2);
+  });
+
+  // Table-driven across elapsed magnitudes: a future change to formatAgo that
+  // drops the bold (or widens it past the time value) is caught here.
+  it.each([
+    { label: "seconds", deltaMs: 10_000, ago: "<1m ago" },
+    { label: "minutes", deltaMs: 7 * 60_000, ago: "7m ago" },
+    { label: "hours", deltaMs: 5 * 3_600_000, ago: "5h ago" },
+    { label: "days", deltaMs: 3 * 86_400_000, ago: "3d ago" },
+  ])("idle footer bolds the $label-magnitude elapsed value", ({ deltaMs, ago }) => {
+    const r = row({ startedAt: NOW - deltaMs - 1000, endedAt: NOW - deltaMs });
+    const out = formatIdleFooter([r], NOW);
+    expect(out).toBe(`🟢 idle · last reply **${ago}**`);
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold![1]).toBe(ago);
   });
 
   it("unsorted rows — picks max startedAt", () => {
@@ -61,6 +105,6 @@ describe("formatIdleFooter", () => {
     const r2 = row({ turnKey: "t2", startedAt: NOW - 5 * 60_000, endedAt: NOW - 2 * 60_000 });
     const r3 = row({ turnKey: "t3", startedAt: NOW - 40 * 60_000, endedAt: NOW - 38 * 60_000 });
     // r2 has the largest startedAt, endedAt is 2m ago
-    expect(formatIdleFooter([r1, r2, r3], NOW)).toBe("🟢 idle · last reply 2m ago");
+    expect(formatIdleFooter([r1, r2, r3], NOW)).toBe("🟢 idle · last reply **2m ago**");
   });
 });

package/telegram-plugin/tests/ipc-server-validate-rollout-status.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Validation contract for the #2726 rollout status IPC verbs — hostd asks the
+ * caller agent's gateway to POST (terminal ping / first narration message) or
+ * EDIT (later phases) an ORDINARY operator-DM message. A rogue process on the
+ * same UDS must not inject a malformed payload: requestId + agentName required
+ * and shaped, text required non-empty and bounded, messageId (edit) an integer.
+ *
+ * No Bun-native API → vitest per the mixed-runner gotcha.
+ */
+import { describe, it, expect } from "vitest";
+import { validateClientMessage } from "../gateway/ipc-server.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
+
+const post = {
+  type: "rollout_status_post",
+  requestId: "ro-1",
+  agentName: "overlord",
+  text: "⏳ Rollout → v1.2.3 — applying",
+};
+const edit = {
+  type: "rollout_status_edit",
+  requestId: "ro-1",
+  agentName: "overlord",
+  messageId: 42,
+  text: "✅ Rollout → v1.2.3 — done",
+};
+
+describe("validateClientMessage — rollout_status_post", () => {
+  it("accepts a well-formed message", () => {
+    expect(validateClientMessage(post)).toBe(true);
+  });
+
+  it("rejects a missing / empty / over-long requestId", () => {
+    expect(validateClientMessage({ ...post, requestId: undefined })).toBe(false);
+    expect(validateClientMessage({ ...post, requestId: "" })).toBe(false);
+    expect(validateClientMessage({ ...post, requestId: "x".repeat(65) })).toBe(false);
+  });
+
+  it("rejects a missing / malformed agentName", () => {
+    expect(validateClientMessage({ ...post, agentName: undefined })).toBe(false);
+    expect(validateClientMessage({ ...post, agentName: "Bad Name" })).toBe(false);
+  });
+
+  it("rejects empty or over-long text", () => {
+    expect(validateClientMessage({ ...post, text: "" })).toBe(false);
+    expect(
+      validateClientMessage({ ...post, text: "x".repeat(RICH_MESSAGE_MAX_CHARS + 1) }),
+    ).toBe(false);
+  });
+});
+
+describe("validateClientMessage — rollout_status_edit", () => {
+  it("accepts a well-formed message", () => {
+    expect(validateClientMessage(edit)).toBe(true);
+  });
+
+  it("rejects a non-integer messageId", () => {
+    expect(validateClientMessage({ ...edit, messageId: 1.5 })).toBe(false);
+    expect(validateClientMessage({ ...edit, messageId: "42" })).toBe(false);
+    expect(validateClientMessage({ ...edit, messageId: undefined })).toBe(false);
+  });
+
+  it("rejects empty text", () => {
+    expect(validateClientMessage({ ...edit, text: "" })).toBe(false);
+  });
+});

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

@@ -175,6 +175,30 @@ describe("renderIssuesCard", () => {
     expect(out).toContain("`<x>::<y>`");
     expect(out).toContain("<dangerous & stuff>");
   });
+
+  it("stacks issue rows with GFM hard breaks so they don't collapse onto one line (#2669)", () => {
+    // Card-body regression: the rich-message renderer collapses lone-`\n`
+    // separated rows into a run-on blob. The issues card now routes its rows
+    // through stackCardLines, so each issue row is separated by a hard break.
+    const events = [
+      makeEvent({ fingerprint: "a::1", code: "1", severity: "critical", summary: "alpha down", detail: "Fix: restart alpha" }),
+      makeEvent({ fingerprint: "a::2", code: "2", severity: "error", summary: "beta slow" }),
+    ];
+    const out = renderIssuesCard({ agentName: "klanker", events, now: 1_700_000_000_000 })!;
+    // Header → rows is a genuine paragraph gap (blank line preserved).
+    expect(out).toContain("\n\n");
+    // Each adjacent issue row (and its remediation line) is hard-broken, not
+    // soft — so no two non-blank body lines are glued by a LONE `\n`.
+    const softBreaks = out.split("\n\n").flatMap((block) => {
+      // Within a block, every internal `\n` must be a hard break (` \n`).
+      return [...block.matchAll(/(?<! {2})\n/g)];
+    });
+    expect(softBreaks.length).toBe(0);
+    // Both rows + the remediation line all rendered, stacked.
+    expect(out).toContain("alpha down");
+    expect(out).toContain("→ _restart alpha_");
+    expect(out).toContain("beta slow");
+  });
 });
 
 // ─── createIssuesCardHandle (lifecycle) ──────────────────────────────────────

package/telegram-plugin/tests/obligation-turn-end.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest'
+
+import { decideObligationTurnEnd } from '../gateway/obligation-turn-end.js'
+import { ObligationLedger } from '../gateway/obligation-ledger.js'
+
+/**
+ * #2624 — obligation close on replyCalled shipped test-free. Pin BOTH branches:
+ *
+ *   - Normal reply → close at turn_end (finalAnswerDelivered OR replyCalled).
+ *   - Ack-then-ghost / no-reply → NOT closed at turn_end; stays open so the
+ *     idle sweep ends it via silence_fallback.
+ */
+describe('decideObligationTurnEnd (#2624)', () => {
+  it('final answer delivered → close', () => {
+    expect(decideObligationTurnEnd(true, false)).toBe('close')
+  })
+
+  it('replyCalled (short sr-* reply demoted to non-final) → close', () => {
+    // The LiteLLM sr-* cascade: reply("OK", {disable_notification:true}) is
+    // below the 200-char backstop + notification-suppressed, so
+    // finalAnswerDelivered is false — but the model explicitly replied.
+    expect(decideObligationTurnEnd(false, true)).toBe('close')
+  })
+
+  it('final answer AND replyCalled → close', () => {
+    expect(decideObligationTurnEnd(true, true)).toBe('close')
+  })
+
+  it('no reply at all (ack-then-ghost / no-reply) → note-ended, NOT close', () => {
+    expect(decideObligationTurnEnd(false, false)).toBe('note-ended')
+  })
+})
+
+describe('#2624 obligation lifecycle — end-to-end over the ledger', () => {
+  const openObligation = (ledger: ObligationLedger, turnId: string) =>
+    ledger.openIfAbsent({
+      originTurnId: turnId,
+      chatId: '123',
+      messageId: 1,
+      text: 'do the thing',
+      openedAt: 1_000,
+    })
+
+  it('normal reply closes the obligation at turn_end', () => {
+    const ledger = new ObligationLedger()
+    openObligation(ledger, 'turn-A')
+    expect(ledger.isOpen('turn-A')).toBe(true)
+
+    // Simulate the gateway turn_end branch for a turn that called reply.
+    if (decideObligationTurnEnd(true, false) === 'close') {
+      ledger.close('turn-A')
+    } else {
+      ledger.noteTurnEnded('turn-A', 2_000)
+    }
+    expect(ledger.isOpen('turn-A')).toBe(false)
+  })
+
+  it('ack-then-ghost turn_end does NOT close — obligation survives for silence_fallback', () => {
+    const ledger = new ObligationLedger()
+    openObligation(ledger, 'turn-B')
+
+    // turn_end with no reply: the ack-then-ghost path.
+    if (decideObligationTurnEnd(false, false) === 'close') {
+      ledger.close('turn-B')
+    } else {
+      ledger.noteTurnEnded('turn-B', 2_000)
+    }
+    // Still open at turn_end — the whole point: it is ended later via
+    // silence_fallback, NOT turn_end.
+    expect(ledger.isOpen('turn-B')).toBe(true)
+
+    // The silence-fallback sweep is what finally closes it.
+    expect(ledger.close('turn-B')).toBe(true)
+    expect(ledger.isOpen('turn-B')).toBe(false)
+  })
+})

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

@@ -9,7 +9,12 @@
  * (un-promoted break) are preferred over false positives (double-spaced list).
  */
 import { describe, test, expect } from 'vitest'
-import { normalizeParagraphBreaks } from '../format.js'
+import {
+  normalizeParagraphBreaks,
+  splitCollapsedInlineBullets,
+  addParagraphSpacers,
+  PARAGRAPH_SPACER,
+} from '../format.js'
 
 describe('normalizeParagraphBreaks', () => {
   test('promotes a lone prose paragraph break (prev ends with `.`, next is prose)', () => {
@@ -271,3 +276,197 @@ describe('normalizeParagraphBreaks', () => {
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 })
+
+// ---------------------------------------------------------------------------
+// splitCollapsedInlineBullets — stack an inline-collapsed bullet list
+// ---------------------------------------------------------------------------
+
+describe('splitCollapsedInlineBullets', () => {
+  test('splits the bath-bulb run-on (4 inline bullets → 4 lines)', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• Master Bath 1, clean\n• Master Bath 2, 33% packet loss\n• Master Bath 3, clean\n• Cabinet, clean',
+    )
+  })
+
+  test('a bold segment inside one bullet survives the split', () => {
+    const input = '• A, clean • **Master Bath 2** (192.168.5.252), **33% loss** • C, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• A, clean\n• **Master Bath 2** (192.168.5.252), **33% loss**\n• C, clean',
+    )
+  })
+
+  test('a <b> segment inside one bullet survives the split', () => {
+    const input = '• A, clean • <b>Master Bath 2</b>, <b>33% packet loss</b> • C, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• A, clean\n• <b>Master Bath 2</b>, <b>33% packet loss</b>\n• C, clean',
+    )
+  })
+
+  test('splits on the middle-dot `·` separator too, and a `·`-led line', () => {
+    const input = '· one · two · three'
+    expect(splitCollapsedInlineBullets(input)).toBe('· one\n· two\n· three')
+  })
+
+  test('accepts a `-` or `*` leading marker (but only splits unicode interior bullets)', () => {
+    expect(splitCollapsedInlineBullets('- lead marker • two • three')).toBe(
+      '- lead marker\n• two\n• three',
+    )
+    expect(splitCollapsedInlineBullets('* lead marker • two')).toBe('* lead marker\n• two')
+  })
+
+  test('prose containing a mid-sentence `•` (line does not start with a bullet) is untouched', () => {
+    const input = 'The plan uses A • B notation throughout the design doc.'
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+
+  test('does NOT split on interior `-`/`*` (hyphens, ranges, multiplication)', () => {
+    const input = '• range 1-3 and a * b product stay on one bullet'
+    // No interior unicode bullet → line is returned unchanged.
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+
+  test('is idempotent on the bath-bulb input', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    const once = splitCollapsedInlineBullets(input)
+    const twice = splitCollapsedInlineBullets(once)
+    expect(twice).toBe(once)
+  })
+
+  test('an already-correct multi-line bullet list passes through unchanged', () => {
+    const input = '• Master Bath 1, clean\n• Master Bath 2, 33% loss\n• Cabinet, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// addParagraphSpacers — restore a VISIBLE blank line between prose paragraphs.
+//
+// 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.
+// ---------------------------------------------------------------------------
+
+describe('addParagraphSpacers', () => {
+  const gap = `\n\n${PARAGRAPH_SPACER}\n\n`
+
+  test('the spacer is a single non-breaking space (U+00A0), not an ASCII space', () => {
+    expect(PARAGRAPH_SPACER).toBe(' ')
+  })
+
+  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('does NOT space a gap adjacent to a list (tight list rhythm preserved)', () => {
+    const input = 'Here are the steps.\n\n- first\n- second'
+    expect(addParagraphSpacers(input)).toBe(input)
+    const input2 = '- first\n- second\n\nClosing prose after the list.'
+    expect(addParagraphSpacers(input2)).toBe(input2)
+  })
+
+  test('does NOT space a gap adjacent to a table', () => {
+    const input = 'Intro.\n\n| a | b |\n| --- | --- |\n| 1 | 2 |'
+    expect(addParagraphSpacers(input)).toBe(input)
+  })
+
+  test('does NOT space a gap adjacent to a fenced code block', () => {
+    const input = 'Look here.\n\n```js\nconst a = 1;\n```\n\nDone.'
+    // Neither the prose→fence nor the fence→prose gap gets a spacer.
+    expect(addParagraphSpacers(input)).toBe(input)
+  })
+
+  test('does NOT space a gap adjacent to a heading or blockquote', () => {
+    expect(addParagraphSpacers('Intro prose.\n\n## Section\n\nBody prose.')).toBe(
+      'Intro prose.\n\n## Section\n\nBody prose.',
+    )
+    expect(addParagraphSpacers('Said.\n\n> a quote\n\nAfter.')).toBe(
+      'Said.\n\n> a quote\n\nAfter.',
+    )
+  })
+
+  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```')
+    // And no spacer paragraph was injected anywhere (both gaps touch the fence).
+    expect(out).not.toContain(PARAGRAPH_SPACER)
+  })
+
+  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', () => {
+    const input = [
+      'Summary of the change.',
+      '',
+      'It does two things.',
+      '',
+      '- 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 list stays tight (no spacer wedged before it).
+    expect(out).toContain('- adds a normalizer\n- lifts the cap')
+    expect(out).not.toContain(`${PARAGRAPH_SPACER}\n\n- adds`)
+  })
+})
+
+describe('normalizeParagraphBreaks — inline bullet split integration', () => {
+  test('splits the bath-bulb run-on as part of the full outbound pass', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      '• Master Bath 1, clean\n• Master Bath 2, 33% packet loss\n• Master Bath 3, clean\n• Cabinet, clean',
+    )
+  })
+
+  test('a `•` inside an inline code span is NOT split (code masked)', () => {
+    const input = '`• a • b • c` is a code span'
+    // The line does not start with a bullet marker (it starts with the masked
+    // code placeholder), and the bullets live inside masked code regardless.
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('a `•` inside a fenced code block is NOT split', () => {
+    const input = '```\n• a • b • c\n```'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('idempotent through the full pass on the bath-bulb input', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Cabinet, clean'
+    const once = normalizeParagraphBreaks(input)
+    const twice = normalizeParagraphBreaks(once)
+    expect(twice).toBe(once)
+  })
+})

package/telegram-plugin/tests/permission-card-single-edit.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Structural pin for card-ux fix 3 — the "Allow once" tap updates the SAME
+ * card instead of spawning a separate "▶️ … got it, continuing" message.
+ *
+ * What broke before: tapping Allow edited the card to "✅ Allowed once" AND
+ * posted a separate resume message (to EVERY resolvePermissionCardTargets()
+ * surface). Ken wants no split — the continuation folds into the tapped card.
+ *
+ * The turn-resume trigger (dispatchPermissionVerdict) and the glyph flip
+ * (resumeReactionAfterVerdict) MUST still fire; only the user-visible second
+ * message collapses. mtcute UAT can observe the card edit and a separate
+ * sendMessage, but wiring a full Grammy ctx here is heavy, so this is a
+ * source-structure pin over the exact callback block (mirrors
+ * permission-verdict-resume-guard.test.ts).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_SRC = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  'utf8',
+)
+
+// Isolate the single "Allow once / Deny" verdict-tap block: from the
+// `labelWithResume` construction to the end of its finalizeCallback call.
+function allowOnceBlock(): string {
+  const start = GATEWAY_SRC.indexOf('const resumeLine = process.env.SWITCHROOM_RESUME_MSG')
+  expect(start).toBeGreaterThan(-1)
+  // Cut a generous slice covering resumeLine + finalizeCallback + synthInbound.
+  return GATEWAY_SRC.slice(start, start + 2000)
+}
+
+describe('permission "Allow once" tap → single in-place card edit (card-ux fix 3)', () => {
+  it('folds the resume line into the card edit via formatPermissionResumeMessage', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('formatPermissionResumeMessage(')
+    // The card newText carries BOTH the verdict label and the resume line.
+    expect(block).toContain('const labelWithResume = resumeLine')
+    expect(block).toMatch(/newText:\s*baseText\s*\?\s*`\$\{baseText\}\\n\\n\$\{labelWithResume\}`/)
+  })
+
+  it('does NOT post a separate resume message on this path', () => {
+    const block = allowOnceBlock()
+    expect(block).not.toContain('postPermissionResumeMessage(')
+  })
+
+  it('still fires the turn-resume trigger and glyph flip', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('dispatchPermissionVerdict(')
+    expect(block).toContain('resumeReactionAfterVerdict()')
+  })
+
+  it('honours the SWITCHROOM_RESUME_MSG=0 kill-switch for the folded line', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain("process.env.SWITCHROOM_RESUME_MSG === '0'")
+  })
+
+  it('carries the card-folded-resume sentinel the resume guard keys off', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('card-folded-resume')
+  })
+})