switchroom 0.17.0 → 0.17.1

package/dist/cli/switchroom.js

@@ -25806,6 +25806,7 @@ function renderHindsightSettingsOverrides(raw, additionalBanks) {
     return null;
   }
   settings.retainEveryNTurns = 1;
+  settings.retainMode = "chunked";
   settings.recallMaxMemories = 8;
   settings.recallMinOverlap = 0.1;
   settings.recallTypes = ["world", "experience", "observation"];
@@ -63728,8 +63729,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.17.0";
-var COMMIT_SHA = "6bb8a20";
+var VERSION = "0.17.1";
+var COMMIT_SHA = "d7162c0";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/dist/host-control/main.js

@@ -22649,7 +22649,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.17.0";
+var VERSION = "0.17.1";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -6713,6 +6713,77 @@ function escapeMarkdown(text) {
 function codeSpanSafe(s) {
   return s.replace(/`/g, "`\u200b");
 }
+function maskCodeRegions(text, nonce) {
+  const FENCE_MASK_PH = `\x00RMF${nonce}_`;
+  const INLINE_MASK_PH = `\x00RMI${nonce}_`;
+  const codeMasks = [];
+  const masked = text.replace(/```[\s\S]*?```/g, (m) => {
+    const idx = codeMasks.length;
+    codeMasks.push(m);
+    return `${FENCE_MASK_PH}${idx}\x00`;
+  }).replace(/`[^`\n]+`/g, (m) => {
+    const idx = codeMasks.length;
+    codeMasks.push(m);
+    return `${INLINE_MASK_PH}${idx}\x00`;
+  });
+  const escNonce = nonce.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const anyMaskRe = new RegExp(`\x00RM[FI]${escNonce}_(\\d+)\x00`, "g");
+  const restore = (s) => s.replace(anyMaskRe, (_m, idx) => codeMasks[Number(idx)] ?? _m);
+  const stripPlaceholders = (s) => s.replace(anyMaskRe, "");
+  return { masked, restore, placeholder: FENCE_MASK_PH, stripPlaceholders };
+}
+function hardenCardBreaks(text) {
+  if (!text.includes(`
+`))
+    return text;
+  const nonce = Math.random().toString(36).slice(2);
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce);
+  const out = masked.replace(/\n{3,}/g, `
+
+`);
+  const isBlockConstructLine = (line) => isListItemLine(line) || isTableRowLine(line) || isTableDelimiterLine(line) || isBlockquoteLine(line) || isHeadingLine(line) || isFenceOpenLine(line, placeholder);
+  const lines = out.split(`
+`);
+  const pieces = [];
+  for (let i = 0;i < lines.length; i++) {
+    let line = lines[i];
+    const isLast = i === lines.length - 1;
+    const next = isLast ? "" : lines[i + 1];
+    const promote = !isLast && line.trim() !== "" && next.trim() !== "" && !isBlockConstructLine(line) && !isBlockConstructLine(next);
+    if (promote) {
+      line = line.replace(/[ \t\r]+$/, "");
+    }
+    pieces.push(line);
+    if (isLast)
+      break;
+    pieces.push(promote ? `  
+` : `
+`);
+  }
+  return restore(pieces.join(""));
+}
+function isListItemLine(line) {
+  const t = line.trimStart();
+  return /^[-*+]\s/.test(t) || /^\d+[.)]\s/.test(t);
+}
+function isTableRowLine(line) {
+  return /^\s*\|/.test(line);
+}
+function isTableDelimiterLine(line) {
+  return /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/.test(line);
+}
+function isFenceOpenLine(line, placeholder) {
+  const t = line.trimStart();
+  if (placeholder != null && placeholder.length > 0 && t.startsWith(placeholder))
+    return true;
+  return t.startsWith("```");
+}
+function isBlockquoteLine(line) {
+  return line.trimStart().startsWith(">");
+}
+function isHeadingLine(line) {
+  return /^#{1,6}\s/.test(line.trimStart());
+}
 var RICH_MESSAGE_MAX_CHARS = 32768;
 
 // text-voice-scrub.ts
@@ -32074,11 +32145,11 @@ function registerApprovalsCommands(bot, opts) {
         return `\`${d.id.slice(0, 8)}\` ` + `${escapeMarkdown(d.agent_unit)} \u2192 ` + `\`${codeSpanSafe(d.scope)}\` ` + `(${escapeMarkdown(d.action)}, ${ttl}) ` + `\u00b7 /approvals revoke ${escapeMarkdown(d.id)}`;
       }).join(`
 `);
-      await ctx.replyWithRichMessage(richMessage(`**Active approvals**
+      await ctx.replyWithRichMessage(richMessage(hardenCardBreaks(`**Active approvals**
 
 ${summary}
 
-${detail}`));
+${detail}`)));
       return;
     }
     if (sub === "revoke") {
@@ -35303,8 +35374,8 @@ function renderVaultRequestAccessCard(req) {
   }
   lines.push("");
   lines.push(`_Tap Approve to mint a scoped grant token (same flow as \`switchroom vault grant\`). Tap Deny to refuse \u2014 the agent will receive a denial result._`);
-  return lines.join(`
-`);
+  return hardenCardBreaks(lines.join(`
+`));
 }
 
 // gateway/permission-card-store.ts
@@ -45062,26 +45133,29 @@ function repairEscapedWhitespace(text) {
     return text;
   const nonce = Math.random().toString(36).slice(2);
   const BACKSLASH_PH = `\x00BK${nonce}_`;
-  const { masked, restore: restore2 } = maskCodeRegions(text, nonce);
+  const { masked, restore: restore2 } = maskCodeRegions2(text, nonce);
   const unescaped = masked.replace(/\\\\/g, BACKSLASH_PH).replace(/\\n/g, `
 `).replace(/\\r/g, "\r").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(new RegExp(BACKSLASH_PH.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), "\\");
   return restore2(unescaped);
 }
-function maskCodeRegions(text, nonce) {
-  const CODE_MASK_PH = `\x00RM${nonce}_`;
+function maskCodeRegions2(text, nonce) {
+  const FENCE_MASK_PH = `\x00RMF${nonce}_`;
+  const INLINE_MASK_PH = `\x00RMI${nonce}_`;
   const codeMasks = [];
   const masked = text.replace(/```[\s\S]*?```/g, (m) => {
     const idx = codeMasks.length;
     codeMasks.push(m);
-    return `${CODE_MASK_PH}${idx}\x00`;
+    return `${FENCE_MASK_PH}${idx}\x00`;
   }).replace(/`[^`\n]+`/g, (m) => {
     const idx = codeMasks.length;
     codeMasks.push(m);
-    return `${CODE_MASK_PH}${idx}\x00`;
+    return `${INLINE_MASK_PH}${idx}\x00`;
   });
-  const restoreRe = new RegExp(`${CODE_MASK_PH.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\d+)\x00`, "g");
-  const restore2 = (s) => s.replace(restoreRe, (_m, idx) => codeMasks[Number(idx)] ?? _m);
-  return { masked, restore: restore2, placeholder: CODE_MASK_PH };
+  const escNonce = nonce.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const anyMaskRe = new RegExp(`\x00RM[FI]${escNonce}_(\\d+)\x00`, "g");
+  const restore2 = (s) => s.replace(anyMaskRe, (_m, idx) => codeMasks[Number(idx)] ?? _m);
+  const stripPlaceholders = (s) => s.replace(anyMaskRe, "");
+  return { masked, restore: restore2, placeholder: FENCE_MASK_PH, stripPlaceholders };
 }
 function splitCollapsedInlineBullets(text) {
   if (!/[\u2022\u00b7]/.test(text))
@@ -45103,7 +45177,7 @@ function normalizeParagraphBreaks(text) {
 `) && !/[\u2022\u00b7]/.test(text))
     return text;
   const nonce = Math.random().toString(36).slice(2);
-  const { masked: maskedRaw, restore: restore2, placeholder } = maskCodeRegions(text, nonce);
+  const { masked: maskedRaw, restore: restore2, placeholder } = maskCodeRegions2(text, nonce);
   const masked = splitCollapsedInlineBullets(maskedRaw);
   let out = masked.replace(/\n[ \t\r]+\n(?:[ \t\r]*\n)*/g, `
 
@@ -45132,6 +45206,36 @@ function normalizeParagraphBreaks(text) {
   out = ensureBlockBoundaries(out, placeholder);
   return restore2(out);
 }
+function hardenCardBreaks2(text) {
+  if (!text.includes(`
+`))
+    return text;
+  const nonce = Math.random().toString(36).slice(2);
+  const { masked, restore: restore2, placeholder } = maskCodeRegions2(text, nonce);
+  const out = masked.replace(/\n{3,}/g, `
+
+`);
+  const isBlockConstructLine = (line) => isListItemLine2(line) || isTableRowLine2(line) || isTableDelimiterLine2(line) || isBlockquoteLine2(line) || isHeadingLine2(line) || isFenceOpenLine2(line, placeholder);
+  const lines = out.split(`
+`);
+  const pieces = [];
+  for (let i = 0;i < lines.length; i++) {
+    let line = lines[i];
+    const isLast = i === lines.length - 1;
+    const next = isLast ? "" : lines[i + 1];
+    const promote = !isLast && line.trim() !== "" && next.trim() !== "" && !isBlockConstructLine(line) && !isBlockConstructLine(next);
+    if (promote) {
+      line = line.replace(/[ \t\r]+$/, "");
+    }
+    pieces.push(line);
+    if (isLast)
+      break;
+    pieces.push(promote ? `  
+` : `
+`);
+  }
+  return restore2(pieces.join(""));
+}
 var PARAGRAPH_SPACER = "\u00a0";
 function addParagraphSpacers(text) {
   if (!text.includes(`
@@ -45139,7 +45243,7 @@ function addParagraphSpacers(text) {
 `))
     return text;
   const nonce = Math.random().toString(36).slice(2);
-  const { masked, restore: restore2, placeholder } = maskCodeRegions(text, nonce);
+  const { masked, restore: restore2, placeholder } = maskCodeRegions2(text, nonce);
   if (!masked.includes(`
 
 `))
@@ -45150,15 +45254,15 @@ function addParagraphSpacers(text) {
   const blockKind = (line) => {
     if (asciiTrim(line) === spacerLine)
       return "spacer";
-    if (isFenceOpenLine(line, placeholder))
+    if (isFenceOpenLine2(line, placeholder))
       return "fence";
-    if (isListItemLine(line))
+    if (isListItemLine2(line))
       return "list";
-    if (isTableRowLine(line) || isTableDelimiterLine(line))
+    if (isTableRowLine2(line) || isTableDelimiterLine2(line))
       return "table";
-    if (isBlockquoteLine(line))
+    if (isBlockquoteLine2(line))
       return "quote";
-    if (isHeadingLine(line))
+    if (isHeadingLine2(line))
       return "heading";
     if (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line.trimStart()))
       return "divider";
@@ -45224,7 +45328,7 @@ function normalizePunctuation(text) {
   if (!/[\u2014\u2013\u2022\u00b7]/.test(text))
     return text;
   const nonce = Math.random().toString(36).slice(2);
-  const { masked, restore: restore2 } = maskCodeRegions(text, nonce);
+  const { masked, restore: restore2 } = maskCodeRegions2(text, nonce);
   let out = masked.replace(/(\S)[ \t][\u2014\u2013][ \t](?=(\S))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2014(?=(\w))/g, (_m, a, b) => /\d/.test(a) && /\d/.test(b) ? `${a}-` : `${a}, `).replace(/(\w)\u2013(?=\w)/g, "$1-");
   out = out.split(`
 `).map((line) => line.replace(/^([ \t]*)[\u2022\u00b7][ \t]+/, "$1- ")).join(`
@@ -45244,9 +45348,8 @@ function stripExcessBold(text) {
   if (!text.includes("**"))
     return text;
   const nonce = Math.random().toString(36).slice(2);
-  const { masked, restore: restore2, placeholder } = maskCodeRegions(text, nonce);
-  const placeholderRe = new RegExp(`${placeholder.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\d+\x00`, "g");
-  const visible = masked.replace(placeholderRe, "");
+  const { masked, restore: restore2, placeholder, stripPlaceholders } = maskCodeRegions2(text, nonce);
+  const visible = stripPlaceholders(masked);
   if (visible.length < 100)
     return restore2(masked);
   let boldChars = 0;
@@ -45261,7 +45364,7 @@ function stripExcessBold(text) {
 `).filter((l) => l.trim() !== "");
     if (lines.length === 0 || !block.includes("**"))
       return block;
-    const listLines = lines.filter((l) => isListItemLine(l));
+    const listLines = lines.filter((l) => isListItemLine2(l));
     if (listLines.length >= 2 && listLines.length === lines.length) {
       if (lines.every((l) => isFullyBolded(listItemContent(l))))
         return unbold(block);
@@ -45284,26 +45387,26 @@ function stripExcessBold(text) {
 `) + rebuilt[i];
   return restore2(out);
 }
-function isListItemLine(line) {
+function isListItemLine2(line) {
   const t = line.trimStart();
   return /^[-*+]\s/.test(t) || /^\d+[.)]\s/.test(t);
 }
-function isTableRowLine(line) {
+function isTableRowLine2(line) {
   return /^\s*\|/.test(line);
 }
-function isTableDelimiterLine(line) {
+function isTableDelimiterLine2(line) {
   return /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/.test(line);
 }
-function isFenceOpenLine(line, placeholder) {
+function isFenceOpenLine2(line, placeholder) {
   const t = line.trimStart();
   if (placeholder != null && placeholder.length > 0 && t.startsWith(placeholder))
     return true;
   return t.startsWith("```");
 }
-function isBlockquoteLine(line) {
+function isBlockquoteLine2(line) {
   return line.trimStart().startsWith(">");
 }
-function isHeadingLine(line) {
+function isHeadingLine2(line) {
   return /^#{1,6}\s/.test(line.trimStart());
 }
 function ensureBlockBoundaries(text, placeholder) {
@@ -45320,24 +45423,24 @@ function ensureBlockBoundaries(text, placeholder) {
     const curBlank = line.trim() === "";
     if (prevNonBlank && !curBlank) {
       const next = i + 1 < lines.length ? lines[i + 1] : "";
-      const prevIsTable = isTableRowLine(prev);
-      const startsTableHere = !prevIsTable && (line.includes("|") && isTableDelimiterLine(next) || isTableRowLine(line) && isTableDelimiterLine(next));
-      const startsFence = isFenceOpenLine(line, placeholder) && !isFenceOpenLine(prev, placeholder);
-      const startsQuote = isBlockquoteLine(line) && !isBlockquoteLine(prev);
-      const startsHeading = isHeadingLine(line) && !isHeadingLine(prev);
-      const startsList = isListItemLine(line) && !isListItemLine(prev);
+      const prevIsTable = isTableRowLine2(prev);
+      const startsTableHere = !prevIsTable && (line.includes("|") && isTableDelimiterLine2(next) || isTableRowLine2(line) && isTableDelimiterLine2(next));
+      const startsFence = isFenceOpenLine2(line, placeholder) && !isFenceOpenLine2(prev, placeholder);
+      const startsQuote = isBlockquoteLine2(line) && !isBlockquoteLine2(prev);
+      const startsHeading = isHeadingLine2(line) && !isHeadingLine2(prev);
+      const startsList = isListItemLine2(line) && !isListItemLine2(prev);
       if (startsTableHere || startsFence || startsQuote || startsHeading || startsList) {
         result.push("");
       }
     }
-    if (prevNonBlank && !curBlank && isFenceOpenLine(prev, placeholder)) {
+    if (prevNonBlank && !curBlank && isFenceOpenLine2(prev, placeholder)) {
       const alreadySeparated = result.length > 0 && result[result.length - 1].trim() === "";
-      const curIsBlockStart = isFenceOpenLine(line, placeholder) || isBlockquoteLine(line) || isHeadingLine(line) || isTableRowLine(line) || isTableDelimiterLine(line);
+      const curIsBlockStart = isFenceOpenLine2(line, placeholder) || isBlockquoteLine2(line) || isHeadingLine2(line) || isTableRowLine2(line) || isTableDelimiterLine2(line);
       if (!alreadySeparated && !curIsBlockStart) {
         result.push("");
       }
     }
-    if (prevNonBlank && !curBlank && isListItemLine(prev) && !isListItemLine(line)) {
+    if (prevNonBlank && !curBlank && isListItemLine2(prev) && !isListItemLine2(line)) {
       const isIndentedContinuation = /^(\t| {4,})\S/.test(line);
       const alreadySeparated = result.length > 0 && result[result.length - 1].trim() === "";
       if (!isIndentedContinuation && !alreadySeparated) {
@@ -45355,7 +45458,7 @@ function isMarkerLine(line, placeholder) {
   const t = line.trimStart();
   if (placeholder != null && placeholder.length > 0 && t.startsWith(placeholder))
     return true;
-  return /^[-*+]\s/.test(t) || /^\d+[.)]\s/.test(t) || t.startsWith(">") || /^#{1,6}\s/.test(t) || isTableRowLine(line) || isTableDelimiterLine(line) || t.startsWith("```") || /^(-{3,}|\*{3,}|_{3,})\s*$/.test(t);
+  return /^[-*+]\s/.test(t) || /^\d+[.)]\s/.test(t) || t.startsWith(">") || /^#{1,6}\s/.test(t) || isTableRowLine2(line) || isTableDelimiterLine2(line) || t.startsWith("```") || /^(-{3,}|\*{3,}|_{3,})\s*$/.test(t);
 }
 function shouldPromoteBreak(prev, next, placeholder) {
   if (isMarkerLine(prev, placeholder) || isMarkerLine(next, placeholder))
@@ -45786,7 +45889,7 @@ function formatAgentLine(meta) {
 function startText(agentName3, dmDisabled) {
   if (dmDisabled)
     return "This bot isn't accepting new connections.";
-  return [
+  return stackCardLines([
     `**Switchroom** \u2014 Telegram on your Claude Pro or Max subscription.`,
     ``,
     `This bot is the **${escapeHtml(agentName3)}** agent. Pair first, then send messages here and they reach the agent; replies and reactions come back.`,
@@ -45796,11 +45899,10 @@ function startText(agentName3, dmDisabled) {
     `2. In Claude Code: \`/telegram:access pair <code>\``,
     ``,
     `After pairing, try \`/status\` or \`/commands\`.`
-  ].join(`
-`);
+  ]);
 }
 function helpText(agentName3) {
-  return [
+  return stackCardLines([
     `**Switchroom** \u2014 your Pro/Max subscription, wired to Telegram.`,
     ``,
     `This bot is the **${escapeHtml(agentName3)}** agent. Text and photos route through to it; replies, reactions and progress cards come back.`,
@@ -45811,8 +45913,7 @@ function helpText(agentName3) {
     `\`/status\` \u2014 agent, model, auth`,
     `\`/vault audit <agent>\` \u2014 admin: review agent's vault access + one-tap [\uD83D\uDD13 Allow] on recent denials`,
     `\`/commands\` \u2014 full command list`
-  ].join(`
-`);
+  ]);
 }
 var STATUS_DOT = {
   ok: "\uD83D\uDFE2",
@@ -45858,13 +45959,14 @@ function statusPairedText(params) {
     if (audit.memoryBank)
       lines.push(`**Memory** ${escapeHtml(audit.memoryBank)}`);
   }
-  return lines.join(`
-`);
+  return stackCardLines(lines);
 }
 function statusPendingText(code) {
-  return `Pending pairing \u2014 run in Claude Code:
-
-\`/telegram:access pair ${code}\``;
+  return stackCardLines([
+    `Pending pairing \u2014 run in Claude Code:`,
+    ``,
+    `\`/telegram:access pair ${code}\``
+  ]);
 }
 function statusUnpairedText() {
   return "Not paired. Send me a message to get a pairing code.";
@@ -45895,7 +45997,7 @@ var TELEGRAM_MENU_COMMANDS = [
 var TELEGRAM_BASE_COMMANDS = TELEGRAM_MENU_COMMANDS.slice(0, 3);
 var TELEGRAM_SWITCHROOM_COMMANDS = TELEGRAM_MENU_COMMANDS.slice(3);
 function switchroomHelpText(agentName3) {
-  return [
+  return stackCardLines([
     `**Switchroom bot** \u2014 commands for the **${escapeHtml(agentName3)}** agent.`,
     ``,
     `**Session & approvals**`,
@@ -45945,8 +46047,7 @@ function switchroomHelpText(agentName3) {
     `\`/commands\` \u2014 this help`,
     ``,
     `_Tip: \`/update\` shows the plan; \`/update apply\` executes it; \`/restart\` bounces a stuck agent; \`/version\` checks what's running._`
-  ].join(`
-`);
+  ]);
 }
 function restartAckText(agentName3) {
   return `\uD83D\uDD04 Restarting **${escapeHtml(agentName3)}**\u2026`;
@@ -51577,8 +51678,8 @@ function buildMs365CardText(p) {
   }
   lines.push("");
   lines.push("\u26a0\ufe0f Weak attestation (RFC \u00a78 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.");
-  return lines.join(`
-`);
+  return hardenCardBreaks(lines.join(`
+`));
 }
 function truncate3(s, n) {
   if (s.length <= n)
@@ -58663,10 +58764,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.17.0";
-var COMMIT_SHA = "6bb8a20";
-var COMMIT_DATE = "2026-07-05T13:24:36+10:00";
-var LATEST_PR = 2825;
+var VERSION = "0.17.1";
+var COMMIT_SHA = "d7162c0";
+var COMMIT_DATE = "2026-07-05T05:44:23Z";
+var LATEST_PR = 2831;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -64735,8 +64836,8 @@ function renderVaultRequestSaveCard(req, agentSlug) {
   }
   lines.push("");
   lines.push(`_Tap Save to write to the host vault, Rename to change the key name, or Discard to drop it. The value is held in this chat's gateway memory until you decide._`);
-  return lines.join(`
-`);
+  return hardenCardBreaks2(lines.join(`
+`));
 }
 async function executeVaultRequestSave(args) {
   const chat_id = String(args.chat_id ?? "");
@@ -67343,7 +67444,7 @@ async function switchroomReply(ctx, text2, options = {}) {
     ...options.reply_markup ? { reply_markup: options.reply_markup } : {}
   };
   if (options.html) {
-    await ctx.replyWithRichMessage(richMessage2(text2), replyOpts);
+    await ctx.replyWithRichMessage(richMessage2(hardenCardBreaks2(text2)), replyOpts);
   } else {
     await ctx.reply(text2, replyOpts);
   }

package/telegram-plugin/format.ts

@@ -132,8 +132,18 @@ export function repairEscapedWhitespace(text: string): string {
 interface MaskedCode {
   masked: string
   restore: (s: string) => string
-  /** The placeholder prefix injected for each masked region (fence or span). */
+  /**
+   * The placeholder prefix injected for FENCED-BLOCK masks only. A masked
+   * fenced block occupies a whole line, so `isFenceOpenLine` / `isMarkerLine`
+   * treat a line that STARTS with this prefix as a block construct. INLINE
+   * code spans get a DISTINCT prefix (see maskCodeRegions) that deliberately
+   * does NOT start with this one — so a line that merely opens with an inline
+   * span (e.g. `\`key\` = \`value\``) reads as ordinary prose and still gets
+   * its line break hardened.
+   */
   placeholder: string
+  /** Remove EVERY mask (fenced + inline) — used to measure visible length. */
+  stripPlaceholders: (s: string) => string
 }
 
 /**
@@ -144,31 +154,40 @@ interface MaskedCode {
  * Fenced blocks are extracted FIRST and only when CLOSED (matching ```), so an
  * unclosed fence is left intact rather than misparsed by the inline pass. Inline
  * spans use `[^\`\n]+` — the same definition the chunker treats as code.
+ *
+ * Fenced and inline masks carry DISTINCT prefixes (`\x00RMF…` vs `\x00RMI…`).
+ * This matters because the fenced prefix is what the block-structure predicates
+ * (`isFenceOpenLine`, `isMarkerLine`) use to recognise a standalone masked code
+ * block. Sharing one prefix (the pre-fix bug) made a line that merely STARTS
+ * with an inline code span look like a fenced block, so its lone `\n` was never
+ * hardened and the card collapsed into one run-on line (real victim:
+ * `/vault get` rendering `\`key\` = \`value\``).
  */
 function maskCodeRegions(text: string, nonce: string): MaskedCode {
-  const CODE_MASK_PH = `\x00RM${nonce}_`
+  const FENCE_MASK_PH = `\x00RMF${nonce}_`
+  const INLINE_MASK_PH = `\x00RMI${nonce}_`
   const codeMasks: string[] = []
 
   const masked = text
     .replace(/```[\s\S]*?```/g, (m) => {
       const idx = codeMasks.length
       codeMasks.push(m)
-      return `${CODE_MASK_PH}${idx}\x00`
+      return `${FENCE_MASK_PH}${idx}\x00`
     })
     .replace(/`[^`\n]+`/g, (m) => {
       const idx = codeMasks.length
       codeMasks.push(m)
-      return `${CODE_MASK_PH}${idx}\x00`
+      return `${INLINE_MASK_PH}${idx}\x00`
     })
 
-  const restoreRe = new RegExp(
-    `${CODE_MASK_PH.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(\\d+)\x00`,
-    'g',
-  )
+  // Restore / strip match EITHER prefix, keyed on the shared index space.
+  const escNonce = nonce.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const anyMaskRe = new RegExp(`\x00RM[FI]${escNonce}_(\\d+)\x00`, 'g')
   const restore = (s: string): string =>
-    s.replace(restoreRe, (_m, idx) => codeMasks[Number(idx)] ?? _m)
+    s.replace(anyMaskRe, (_m, idx) => codeMasks[Number(idx)] ?? _m)
+  const stripPlaceholders = (s: string): string => s.replace(anyMaskRe, '')
 
-  return { masked, restore, placeholder: CODE_MASK_PH }
+  return { masked, restore, placeholder: FENCE_MASK_PH, stripPlaceholders }
 }
 
 // ---------------------------------------------------------------------------
@@ -344,6 +363,92 @@ export function normalizeParagraphBreaks(text: string): string {
   return restore(out)
 }
 
+// ---------------------------------------------------------------------------
+// Card line-break hardener — for DETERMINISTIC command/card bodies
+// ---------------------------------------------------------------------------
+
+/**
+ * Harden the lone `\n` line breaks of a DETERMINISTIC card body into GFM hard
+ * breaks (`  \n`, two trailing spaces) so every field lands on its own line
+ * under Telegram's Bot API 10.1 rich-message (GFM) renderer.
+ *
+ * Why this exists (the run-on-blob bug): the rich path (#2669) renders a lone
+ * `\n` between two non-blank lines as a *soft* break — the two lines collapse
+ * onto the same visual line with a space between them. Agent PROSE is repaired
+ * on the reply path by `normalizeParagraphBreaks`, but the ~98 slash-command
+ * card replies dispatched through `switchroomReply(…, { html: true })` are sent
+ * as RAW markdown with no normalization. Their builders stack short labelled
+ * fields (`**5h window** …`, `**Model** …`, `Auth: ✓ Max …`) joined by a single
+ * `\n`, so the whole card renders as one run-on blob.
+ *
+ * A deterministic card is NOT free prose — every newline its builder emits is
+ * an INTENDED line break. So this hardener promotes UNCONDITIONALLY (no
+ * sentence-terminal-punctuation gate, unlike `normalizeParagraphBreaks`) with
+ * one exception: a line that participates in a genuine GFM block construct
+ * (list / table / blockquote / heading / fenced code) keeps its single `\n` so
+ * its native stacking / contiguity survives — a monospace table inside a ```
+ * fence is never touched (it is code-masked AND the fence lines are excluded).
+ * Real `\n\n` paragraph gaps (a builder's block separators) are preserved.
+ *
+ * This is the string-level sibling of `stackCardLines` (card-format.ts), which
+ * does the same promotion from a pre-split `string[]` of guaranteed
+ * single-line, non-block entries. Use `hardenCardBreaks` where the card body is
+ * already an assembled string (e.g. the `switchroomReply` chokepoint) and may
+ * legitimately contain GFM block constructs.
+ *
+ * Runs on code-masked text and is idempotent — a break already hardened to
+ * `  \n` re-hardens to the same `  \n`.
+ */
+export function hardenCardBreaks(text: string): string {
+  if (!text.includes('\n')) return text
+
+  const nonce = Math.random().toString(36).slice(2)
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+
+  // Collapse 3+ newline runs to a single clean `\n\n` gap (mirrors
+  // normalizeParagraphBreaks step 1) so a stray extra blank line never becomes
+  // an oversized gap. A genuine one-blank-line `\n\n` block gap is preserved.
+  const out = masked.replace(/\n{3,}/g, '\n\n')
+
+  // A line participating in a GFM block construct whose single-`\n` contiguity
+  // must survive (its interior must NOT get a hard break).
+  const isBlockConstructLine = (line: string): boolean =>
+    isListItemLine(line) ||
+    isTableRowLine(line) ||
+    isTableDelimiterLine(line) ||
+    isBlockquoteLine(line) ||
+    isHeadingLine(line) ||
+    isFenceOpenLine(line, placeholder)
+
+  const lines = out.split('\n')
+  const pieces: string[] = []
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i]
+    const isLast = i === lines.length - 1
+    const next = isLast ? '' : lines[i + 1]
+    // Promote only between two non-blank content lines where NEITHER is a GFM
+    // block-construct line (so lists / tables / quotes / headings / fences keep
+    // their native single-`\n` stacking). A blank current/next line is a `\n\n`
+    // paragraph gap — never promote across it.
+    const promote =
+      !isLast &&
+      line.trim() !== '' &&
+      next.trim() !== '' &&
+      !isBlockConstructLine(line) &&
+      !isBlockConstructLine(next)
+    if (promote) {
+      // Strip trailing whitespace so a re-run emits exactly one `  \n` (never
+      // accumulate spaces). Include `\r` for CRLF sources.
+      line = line.replace(/[ \t\r]+$/, '')
+    }
+    pieces.push(line)
+    if (isLast) break
+    pieces.push(promote ? '  \n' : '\n')
+  }
+
+  return restore(pieces.join(''))
+}
+
 // ---------------------------------------------------------------------------
 // Paragraph spacers — restore a VISIBLE blank line between prose paragraphs
 // ---------------------------------------------------------------------------
@@ -623,14 +728,11 @@ export function stripExcessBold(text: string): string {
   if (!text.includes('**')) return text
 
   const nonce = Math.random().toString(36).slice(2)
-  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+  const { masked, restore, placeholder, stripPlaceholders } = maskCodeRegions(text, nonce)
 
-  // Non-code character budget: masked text with the placeholders removed.
-  const placeholderRe = new RegExp(
-    `${placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\d+\x00`,
-    'g',
-  )
-  const visible = masked.replace(placeholderRe, '')
+  // Non-code character budget: masked text with BOTH fenced + inline masks
+  // removed (stripPlaceholders handles the two distinct prefixes).
+  const visible = stripPlaceholders(masked)
   if (visible.length < 100) return restore(masked)
 
   let boldChars = 0