switchroom 0.19.35 → 0.19.36

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

@@ -6936,10 +6936,18 @@ function listItemContent(line) {
 function isFullyBolded(fragment) {
   return /^\*\*[^*]+\*\*[.,:;!?]?$/.test(fragment.trim());
 }
+function isPseudoHeadingBlock(block) {
+  const lines = block.split(`
+`).filter((l) => l.trim() !== "");
+  if (lines.length !== 1)
+    return false;
+  const t = lines[0].trim();
+  return t.length <= PSEUDO_HEADING_MAX_CHARS && isFullyBolded(t);
+}
 function unbold(fragment) {
   return fragment.replace(/\*\*([^*]+)\*\*/g, "$1");
 }
-function stripExcessBold(text) {
+function stripExcessBold(text, onStrip) {
   if (!text.includes("**"))
     return text;
   const nonce = Math.random().toString(36).slice(2);
@@ -6950,10 +6958,15 @@ function stripExcessBold(text) {
   let boldChars = 0;
   for (const m of visible.matchAll(/\*\*([^*]+)\*\*/g))
     boldChars += m[1].length;
-  if (boldChars / visible.length > 0.3) {
-    return restore(unbold(masked));
-  }
+  const ratio = boldChars / visible.length;
   const blocks = masked.split(/\n{2,}/);
+  if (ratio > 0.3) {
+    const rebuilt2 = blocks.map((block) => isPseudoHeadingBlock(block) ? block : unbold(block));
+    const out2 = rejoinBlocks(masked, rebuilt2);
+    if (out2 !== masked)
+      onStrip?.({ rule: "global", ratio });
+    return restore(out2);
+  }
   const rebuilt = blocks.map((block) => {
     const lines = block.split(`
 `).filter((l) => l.trim() !== "");
@@ -6970,17 +6983,23 @@ function stripExcessBold(text) {
       return block;
     if (!lines.every((l) => isFullyBolded(l)))
       return block;
-    if (lines.length === 1 && lines[0].trim().length <= 48)
+    if (isPseudoHeadingBlock(block))
       return block;
     return unbold(block);
   });
+  const out = rejoinBlocks(masked, rebuilt);
+  if (out !== masked)
+    onStrip?.({ rule: "per-block", ratio });
+  return restore(out);
+}
+function rejoinBlocks(masked, rebuilt) {
   const seps = masked.match(/\n{2,}/g) ?? [];
   let out = rebuilt[0] ?? "";
   for (let i = 1;i < rebuilt.length; i++)
     out += (seps[i - 1] ?? `
 
 `) + rebuilt[i];
-  return restore(out);
+  return out;
 }
 function isListItemLine(line) {
   const t = line.trimStart();
@@ -7183,7 +7202,7 @@ function backOffOpenInline(text, cut) {
   }
   return earliest;
 }
-var RICH_MESSAGE_MAX_CHARS = 32768, PARAGRAPH_SPACER = "\u00a0", INLINE_SPAN_PATTERNS;
+var RICH_MESSAGE_MAX_CHARS = 32768, PARAGRAPH_SPACER = "\u00a0", PSEUDO_HEADING_MAX_CHARS = 48, INLINE_SPAN_PATTERNS;
 var init_format = __esm(() => {
   INLINE_SPAN_PATTERNS = [
     /`[^`\n]+`/g,
@@ -12660,16 +12679,22 @@ var init_patterns = __esm(() => {
     },
     {
       rule_id: "bearer_auth_header",
-      regex: /Authorization\s*[:=]\s*Bearer\s+([A-Za-z0-9._\-+=]+)/g,
+      regex: /Authorization\s*[:=]\s*Bearer\s+([A-Za-z0-9._\-+=]+)/gi,
       captureIndex: 1,
       slugHint: "bearer_token"
     },
     {
       rule_id: "bearer_loose",
-      regex: /\bBearer\s+([A-Za-z0-9._\-+=]{18,})\b/g,
+      regex: /\bBearer\s+([A-Za-z0-9._\-+=]{18,})\b/gi,
       captureIndex: 1,
       slugHint: "bearer_token"
     },
+    {
+      rule_id: "basic_auth_header",
+      regex: /Authorization\s*[:=]\s*Basic\s+([A-Za-z0-9+/=]{8,})/gi,
+      captureIndex: 1,
+      slugHint: "basic_auth"
+    },
     {
       rule_id: "pem_private_key",
       regex: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]+?-----END [A-Z ]*PRIVATE KEY-----/g,
@@ -12729,7 +12754,104 @@ function shannonEntropy(s) {
   return h;
 }
 
+// secret-detect/inert-values.ts
+function runIsCredentialShaped(run) {
+  let classes = 0;
+  if (/[a-z]/.test(run))
+    classes++;
+  if (/[A-Z]/.test(run))
+    classes++;
+  if (/[0-9]/.test(run))
+    classes++;
+  return run.length >= (classes >= 2 ? MIXED_CLASS_RUN_MIN : SINGLE_CLASS_RUN_MIN);
+}
+function hasCredentialShapedRun(value) {
+  for (const run of value.match(CREDENTIAL_RUN_RE) ?? []) {
+    if (runIsCredentialShaped(run))
+      return true;
+  }
+  return false;
+}
+function isInertValue(value) {
+  if (!INERT_VALUE_RE.some((re) => re.test(value)))
+    return false;
+  return !hasCredentialShapedRun(value);
+}
+function stripTrailingPunctuation(value) {
+  return value.replace(TRAILING_PUNCT_RE, "");
+}
+var INERT_VALUE_RE, CREDENTIAL_RUN_RE, MIXED_CLASS_RUN_MIN = 12, SINGLE_CLASS_RUN_MIN = 16, INERT_GATED_RULES, TRAILING_PUNCT_RE;
+var init_inert_values = __esm(() => {
+  INERT_VALUE_RE = [
+    /^\[REDACTED(?::[A-Za-z0-9_]+)?\]$/i,
+    /^\$\{?[A-Za-z_][A-Za-z0-9_]*\}?$/,
+    /^\{\{[^\n\r\u2028\u2029]*\}\}$/,
+    /^<[^<>\n\r\u2028\u2029]*>$/,
+    /^%[A-Za-z_][A-Za-z0-9_]*%$/,
+    /^vault:[A-Za-z0-9_./-]*$/i,
+    /^[*x\u2022.]+$/i,
+    /^(?:process\.env|import\.meta\.env|os\.environ)(?:\.[A-Za-z_$][A-Za-z0-9_$]*|\[["']?[A-Za-z_$][A-Za-z0-9_$]*["']?\])*$/,
+    /^(?:changeme|change-me|replaceme|replace-me|placeholder|todo|tbd|yourkey|your-key|yourpassword|your-password|yoursecret|your-secret|yourtoken|your-token)(?:[-_][A-Za-z0-9-]+)?$/i,
+    /^[a-z]+(?: [a-z]+){2,}$/
+  ];
+  CREDENTIAL_RUN_RE = /[A-Za-z0-9]{12,}/g;
+  INERT_GATED_RULES = new Set([
+    "env_key_value",
+    "json_secret_field",
+    "cli_flag"
+  ]);
+  TRAILING_PUNCT_RE = /[.,;:!?)\]}]+$/;
+});
+
 // secret-detect/kv-scanner.ts
+function charClassCount(value) {
+  let n = 0;
+  if (/[a-z]/.test(value))
+    n++;
+  if (/[A-Z]/.test(value))
+    n++;
+  if (/[0-9]/.test(value))
+    n++;
+  if (/[^A-Za-z0-9]/.test(value))
+    n++;
+  return n;
+}
+function looksLikeMemorablePassword(value) {
+  if (isInertValue(value))
+    return false;
+  const core = stripTrailingPunctuation(value);
+  if (core.length < 8 || core.length > 64)
+    return false;
+  if (isInertValue(core))
+    return false;
+  if (new Set(core).size < 4)
+    return false;
+  return charClassCount(core) >= MEMORABLE_PW_MIN_CLASSES;
+}
+function scanMemorablePasswords(text) {
+  const hits = [];
+  MEMORABLE_PW_RE.lastIndex = 0;
+  let m;
+  while ((m = MEMORABLE_PW_RE.exec(text)) !== null) {
+    const keyName = m[1];
+    const value = m[3];
+    if (!value || !looksLikeMemorablePassword(value))
+      continue;
+    const valueOffsetInMatch = m[0].indexOf(value, keyName.length);
+    if (valueOffsetInMatch < 0)
+      continue;
+    const start = m.index + valueOffsetInMatch;
+    hits.push({
+      rule_id: MEMORABLE_PW_RULE_ID,
+      start,
+      end: start + value.length,
+      matched_text: value,
+      key_name: keyName,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
 function scanKeyValue(text) {
   const hits = [];
   KV_RE.lastIndex = 0;
@@ -12738,6 +12860,8 @@ function scanKeyValue(text) {
     const [, keyName, value] = m;
     if (!value)
       continue;
+    if (isInertValue(value))
+      continue;
     const h = shannonEntropy(value);
     if (h < KV_ENTROPY_THRESHOLD)
       continue;
@@ -12757,9 +12881,44 @@ function scanKeyValue(text) {
   }
   return hits;
 }
-var KV_RE, KV_ENTROPY_THRESHOLD = 4;
+var KV_RE, KV_ENTROPY_THRESHOLD = 4, MEMORABLE_PW_RE, MEMORABLE_PW_RULE_ID = "memorable_password", MEMORABLE_PW_MIN_CLASSES = 2;
 var init_kv_scanner = __esm(() => {
+  init_inert_values();
   KV_RE = /\b([A-Za-z_][A-Za-z0-9_-]*(?:password|passwd|token|secret|key|api[_-]?key))\s*[:=]\s*["']?([^\s"'\\]{8,})["']?/gi;
+  MEMORABLE_PW_RE = /\b([A-Za-z0-9_-]*(?:password|passwd|passphrase|pwd))\b\s*(?:[:=]\s*|\s+is\s+)(["']?)([^\s"']{8,64})\2/gi;
+});
+
+// secret-detect/db-uri.ts
+function isInertPassword(value) {
+  if (value.startsWith("[REDACTED"))
+    return true;
+  return /^[*x]+$/i.test(value);
+}
+function scanDbUris(text) {
+  const hits = [];
+  DB_URI_RE.lastIndex = 0;
+  let m;
+  while ((m = DB_URI_RE.exec(text)) !== null) {
+    const scheme = m[1];
+    const user = m[2];
+    const password = m[3];
+    if (isInertPassword(password))
+      continue;
+    const start = m.index + scheme.length + 3 + user.length + 1;
+    hits.push({
+      rule_id: DB_URI_RULE_ID,
+      start,
+      end: start + password.length,
+      matched_text: password,
+      key_name: `${scheme}_password`,
+      confidence: "ambiguous"
+    });
+  }
+  return hits;
+}
+var DB_URI_RE, DB_URI_RULE_ID = "db_uri_password";
+var init_db_uri = __esm(() => {
+  DB_URI_RE = /\b([a-zA-Z][a-zA-Z0-9+.-]+):\/\/([^\s:/@]+):([^\s/?#]+)@([^\s/@?#]+)/g;
 });
 
 // secret-detect/generic-entropy.ts
@@ -12953,6 +13112,8 @@ function detectSecrets(text) {
         const globalStart = win.offset + matchStart;
         const globalEnd = globalStart + cap.length;
         const keyName = p.rule_id === "env_key_value" ? m[1] : undefined;
+        if (INERT_GATED_RULES.has(p.rule_id) && isInertValue(cap))
+          continue;
         if (p.rule_id === "env_key_value") {
           const ENV_KV_MIN_LEN = 12;
           const ENV_KV_MIN_ENTROPY = 3.5;
@@ -12975,6 +13136,12 @@ function detectSecrets(text) {
     for (const h of kvHits) {
       raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
     }
+    for (const h of scanDbUris(win.text)) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
+    for (const h of scanMemorablePasswords(win.text)) {
+      raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
+    }
     const genHits = scanGenericSecrets(win.text);
     for (const h of genHits) {
       raw.push({ ...h, start: h.start + win.offset, end: h.end + win.offset });
@@ -13024,6 +13191,8 @@ function dropOverlaps(hits) {
 var init_secret_detect = __esm(() => {
   init_patterns();
   init_kv_scanner();
+  init_db_uri();
+  init_inert_values();
   init_generic_entropy();
   init_chunker();
   init_suppressor();
@@ -71039,6 +71208,23 @@ function describeProviderCreditRemedy(provider) {
 }
 
 // operator-events.ts
+var OPERATOR_EVENT_KINDS = [
+  "credentials-expired",
+  "credentials-invalid",
+  "proxy-misconfig",
+  "credit-exhausted",
+  "provider-credit-exhausted",
+  "mcp-dependency-blocked",
+  "quota-exhausted",
+  "rate-limited",
+  "agent-crashed",
+  "agent-restarted-unexpectedly",
+  "unknown-4xx",
+  "unknown-5xx",
+  "config-warning",
+  "always-allow-persist-failed",
+  "mental-model-persist-failed"
+];
 function classifyClaudeError(raw) {
   try {
     return classifyInner(raw);
@@ -77648,7 +77834,12 @@ function normalizeOutboundBody(rawText, site, redact2, opts = {}) {
     text4 = normalizeParagraphBreaks(text4);
   text4 = redact2(text4, site);
   if (!literalText) {
-    let formatted = stripExcessBold(normalizePunctuation(text4));
+    let formatted = stripExcessBold(normalizePunctuation(text4), (d) => {
+      try {
+        process.stderr.write(`telegram gateway: strip-excess-bold: fired site=${site} rule=${d.rule} ratio=${d.ratio.toFixed(3)}
+`);
+      } catch {}
+    });
     if (addSpacers)
       formatted = addParagraphSpacers(formatted);
     text4 = formatted;
@@ -79094,7 +79285,12 @@ function normalizeOutboundBody2(rawText, site, redact2, opts = {}) {
     text4 = normalizeParagraphBreaks(text4);
   text4 = redact2(text4, site);
   if (!literalText) {
-    let formatted = stripExcessBold(normalizePunctuation(text4));
+    let formatted = stripExcessBold(normalizePunctuation(text4), (d) => {
+      try {
+        process.stderr.write(`telegram gateway: strip-excess-bold: fired site=${site} rule=${d.rule} ratio=${d.ratio.toFixed(3)}
+`);
+      } catch {}
+    });
     if (addSpacers)
       formatted = addParagraphSpacers(formatted);
     text4 = formatted;
@@ -83583,6 +83779,27 @@ var MODEL_ARG_RE2 = /^[A-Za-z0-9][A-Za-z0-9._/\[\]-]{0,99}$/;
 function isValidModelArg2(arg) {
   return MODEL_ARG_RE2.test(arg);
 }
+var DEFAULT_SESSION_MODEL_RESOLUTION_TIMEOUT_MS = 180000;
+var SESSION_MODEL_RESOLUTION_POLL_MS = 250;
+function resolveSessionModelResolutionTimeoutMs(raw) {
+  if (raw == null || raw.trim() === "")
+    return DEFAULT_SESSION_MODEL_RESOLUTION_TIMEOUT_MS;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : DEFAULT_SESSION_MODEL_RESOLUTION_TIMEOUT_MS;
+}
+async function waitForSessionModelResolution(input) {
+  const pollMs = input.pollMs ?? SESSION_MODEL_RESOLUTION_POLL_MS;
+  const sleep2 = input.sleep ?? ((ms) => new Promise((resolve7) => setTimeout(resolve7, ms)));
+  const startedAt = Date.now();
+  for (;; ) {
+    if (input.barrierExists())
+      return true;
+    const remaining = input.timeoutMs - (Date.now() - startedAt);
+    if (remaining <= 0)
+      return false;
+    await sleep2(Math.min(pollMs, remaining));
+  }
+}
 function isSrModel2(name) {
   return name.startsWith("sr-");
 }
@@ -88847,17 +89064,7 @@ function recordWebhookEvent(rec, deps = {}) {
 init_format();
 import { renameSync as renameSync17, unlinkSync as unlinkSync20, chmodSync as chmodSync11 } from "fs";
 var MAX_BUFFER_SIZE = 1024 * 1024;
-var VALID_OPERATOR_KINDS = new Set([
-  "credentials-expired",
-  "credentials-invalid",
-  "credit-exhausted",
-  "quota-exhausted",
-  "rate-limited",
-  "agent-crashed",
-  "agent-restarted-unexpectedly",
-  "unknown-4xx",
-  "unknown-5xx"
-]);
+var VALID_OPERATOR_KINDS = new Set(OPERATOR_EVENT_KINDS);
 var AGENT_NAME_RE3 = /^[a-z0-9][a-z0-9_-]{0,50}$/;
 var OPERATOR_EVENT_DETAIL_MAX = 1000;
 function validateClientMessage(msg) {
@@ -99461,10 +99668,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.35";
-var COMMIT_SHA = "76ae22ca";
-var COMMIT_DATE = "2026-07-30T01:27:21Z";
-var LATEST_PR = 4011;
+var VERSION2 = "0.19.36";
+var COMMIT_SHA = "ba505b15";
+var COMMIT_DATE = "2026-07-30T07:53:24Z";
+var LATEST_PR = 4019;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -112706,76 +112913,87 @@ async function startGateway() {
         try {
           const smAgentDir = resolveAgentDirFromEnv();
           if (smAgentDir) {
-            const activePath = join68(smAgentDir, ".active-session-model");
-            if (existsSync57(activePath)) {
-              try {
-                const launched = readFileSync60(activePath, "utf8").trim();
-                const configured = (() => {
-                  const d = switchroomExecJson(["agent", "list"]);
-                  const raw = d?.agents?.find((a) => a.name === getMyAgentName())?.model ?? null;
-                  return resolveMainModel(raw ?? undefined);
-                })();
-                const isApplyBoot = launched.length > 0 && launched !== configured;
-                sessionModelSource.setOverride(isApplyBoot ? launched : null, { verify: true });
-                const modelBootCardDeps = {
-                  agent: getMyAgentName(),
-                  chat: modelSwitchMarkerChat,
-                  log: (line) => process.stderr.write(line),
-                  sendCard: (chatId, body, opts) => lockedBot.api.sendMessage(chatId, body, opts)
-                };
-                if (isApplyBoot) {
-                  sessionModelSource.setDivergenceHandler(buildServedModelDivergenceHandler(modelBootCardDeps));
-                }
-                const confirmation = modelSwitchReason != null ? classifyModelSwitchConfirmation({
-                  reason: modelSwitchReason,
-                  launched,
-                  configured
-                }) : null;
-                process.stderr.write(formatModelRelaunchDiagLog({
-                  agent: getMyAgentName(),
-                  launched,
-                  configured,
-                  confirmation,
-                  isApplyBoot
-                }));
-                if (confirmation != null) {
-                  deliverModelSwitchBootNotice({
-                    ...modelBootCardDeps,
+            const resolutionTimeoutMs = resolveSessionModelResolutionTimeoutMs(process.env.SWITCHROOM_SESSION_MODEL_RESOLUTION_TIMEOUT_MS);
+            const resolved = await waitForSessionModelResolution({
+              barrierExists: () => existsSync57(join68(smAgentDir, ".session-model-resolved")),
+              timeoutMs: resolutionTimeoutMs
+            });
+            if (!resolved) {
+              const target = modelSwitchReason == null ? "(none)" : parseModelSwitchTarget(modelSwitchReason) ?? "(unknown)";
+              process.stderr.write(`telegram gateway: gw /model relaunch UNRESOLVED agent=${getMyAgentName()} target=${target} (barrier timeout after ${resolutionTimeoutMs}ms)
+`);
+            } else {
+              const activePath = join68(smAgentDir, ".active-session-model");
+              if (existsSync57(activePath)) {
+                try {
+                  const launched = readFileSync60(activePath, "utf8").trim();
+                  const configured = (() => {
+                    const d = switchroomExecJson(["agent", "list"]);
+                    const raw = d?.agents?.find((a) => a.name === getMyAgentName())?.model ?? null;
+                    return resolveMainModel(raw ?? undefined);
+                  })();
+                  const isApplyBoot = launched.length > 0 && launched !== configured;
+                  sessionModelSource.setOverride(isApplyBoot ? launched : null, { verify: true });
+                  const modelBootCardDeps = {
+                    agent: getMyAgentName(),
+                    chat: modelSwitchMarkerChat,
+                    log: (line) => process.stderr.write(line),
+                    sendCard: (chatId, body, opts) => lockedBot.api.sendMessage(chatId, body, opts)
+                  };
+                  if (isApplyBoot) {
+                    sessionModelSource.setDivergenceHandler(buildServedModelDivergenceHandler(modelBootCardDeps));
+                  }
+                  const confirmation = modelSwitchReason != null ? classifyModelSwitchConfirmation({
+                    reason: modelSwitchReason,
+                    launched,
+                    configured
+                  }) : null;
+                  process.stderr.write(formatModelRelaunchDiagLog({
+                    agent: getMyAgentName(),
+                    launched,
+                    configured,
                     confirmation,
-                    hasSessionModelAlert: existsSync57(join68(smAgentDir, ".session-model-alert"))
-                  });
-                }
-              } catch {}
-            }
-            const activeEffortPath = join68(smAgentDir, ".active-session-effort");
-            if (existsSync57(activeEffortPath)) {
-              try {
-                const launchedEffort = readFileSync60(activeEffortPath, "utf8").trim();
-                const configuredEffort = getConfiguredEffortForPersist();
-                sessionEffortOverride = launchedEffort.length > 0 && launchedEffort !== configuredEffort ? launchedEffort : null;
-              } catch {}
-            }
-            const alertPath = join68(smAgentDir, ".session-model-alert");
-            if (existsSync57(alertPath)) {
-              let alertText = null;
-              try {
-                alertText = readFileSync60(alertPath, "utf8").trim();
-              } catch {
-                alertText = null;
+                    isApplyBoot
+                  }));
+                  if (confirmation != null) {
+                    deliverModelSwitchBootNotice({
+                      ...modelBootCardDeps,
+                      confirmation,
+                      hasSessionModelAlert: existsSync57(join68(smAgentDir, ".session-model-alert"))
+                    });
+                  }
+                } catch {}
               }
-              try {
-                unlinkSync30(alertPath);
-              } catch {}
-              if (alertText && alertText.length > 0) {
-                const operators = loadAccess().allowFrom;
-                for (const operator of operators) {
-                  if (!operator)
-                    continue;
-                  lockedBot.api.sendMessage(operator, `\u26A0\uFE0F ${alertText}`).catch((err) => process.stderr.write(`telegram gateway: session-model alert send failed for ${operator}: ${err?.message ?? String(err)}
-`));
+              const activeEffortPath = join68(smAgentDir, ".active-session-effort");
+              if (existsSync57(activeEffortPath)) {
+                try {
+                  const launchedEffort = readFileSync60(activeEffortPath, "utf8").trim();
+                  const configuredEffort = getConfiguredEffortForPersist();
+                  sessionEffortOverride = launchedEffort.length > 0 && launchedEffort !== configuredEffort ? launchedEffort : null;
+                } catch {}
+              }
+              const alertPath = join68(smAgentDir, ".session-model-alert");
+              if (existsSync57(alertPath)) {
+                let alertText = null;
+                try {
+                  alertText = readFileSync60(alertPath, "utf8").trim();
+                } catch {
+                  alertText = null;
                 }
-                process.stderr.write(`telegram gateway: session-model: LiteLLM-down override drop \u2014 ${alertText}
+                try {
+                  unlinkSync30(alertPath);
+                } catch {}
+                if (alertText && alertText.length > 0) {
+                  const operators = loadAccess().allowFrom;
+                  for (const operator of operators) {
+                    if (!operator)
+                      continue;
+                    lockedBot.api.sendMessage(operator, `\u26A0\uFE0F ${alertText}`).catch((err) => process.stderr.write(`telegram gateway: session-model alert send failed for ${operator}: ${err?.message ?? String(err)}
+`));
+                  }
+                  process.stderr.write(`telegram gateway: session-model: LiteLLM-down override drop \u2014 ${alertText}
 `);
+                }
               }
             }
           }

package/telegram-plugin/format.ts

@@ -761,6 +761,35 @@ function isFullyBolded(fragment: string): boolean {
   return /^\*\*[^*]+\*\*[.,:;!?]?$/.test(fragment.trim())
 }
 
+/**
+ * Max length (markers included) of a standalone fully-bolded line that is
+ * treated as a legitimate pseudo-heading (`**Section**`) rather than an
+ * over-bolded paragraph. Single source of truth for BOTH the per-block rule
+ * and the global-ratio heading exemption.
+ */
+const PSEUDO_HEADING_MAX_CHARS = 48
+
+/**
+ * True when a blank-line-delimited block is a single-line pseudo-heading: one
+ * non-empty line that is a single fully-bolded span of ≤PSEUDO_HEADING_MAX_CHARS
+ * characters (`**Summary**`, `**Next steps:**`). Multi-line blocks are never
+ * headings, so this can never mislabel a bolded paragraph as exempt.
+ */
+function isPseudoHeadingBlock(block: string): boolean {
+  const lines = block.split('\n').filter((l) => l.trim() !== '')
+  if (lines.length !== 1) return false
+  const t = lines[0].trim()
+  return t.length <= PSEUDO_HEADING_MAX_CHARS && isFullyBolded(t)
+}
+
+/** Diagnostic emitted when the over-bold tripwire actually removes bold. */
+export interface ExcessBoldStripDiagnostic {
+  /** Which rule fired: the whole-message ratio, or per-block flattening. */
+  rule: 'global' | 'per-block'
+  /** Measured bold ratio: bold chars / visible (non-code) chars. */
+  ratio: number
+}
+
 /** Strip `**bold**` markers from a fragment, keeping the text. */
 function unbold(fragment: string): string {
   return fragment.replace(/\*\*([^*]+)\*\*/g, '$1')
@@ -778,16 +807,24 @@ function unbold(fragment: string): string {
  * Deliberately conservative:
  *   - Messages under 100 non-code characters are exempt (a short reply whose
  *     one key fact is bolded is exactly the house style).
- *   - A single-line fully-bolded paragraph of ≤48 chars is treated as a
- *     pseudo-heading (the "**Section**" label the fleet style encourages) and
- *     is NOT stripped by the per-block rule (it still counts toward the
- *     global ratio).
+ *   - A single-line fully-bolded paragraph of ≤PSEUDO_HEADING_MAX_CHARS chars
+ *     is treated as a pseudo-heading (the "**Section**" label the fleet style
+ *     encourages) and is NOT stripped — neither by the per-block rule NOR by
+ *     the global-ratio rule (it still counts toward the global ratio, so a
+ *     genuinely over-bolded message still trips, but its section headings
+ *     survive instead of the whole reply going plain).
  *   - A list with any non-fully-bolded item is left alone.
  *
  * Code spans/fences are masked (maskCodeRegions) and never counted or
  * modified. Idempotent: stripped output has no `**` spans left to trip on.
+ *
+ * `onStrip` is an optional diagnostic sink invoked exactly once, only when
+ * bold is actually removed, carrying which rule fired and the measured ratio.
  */
-export function stripExcessBold(text: string): string {
+export function stripExcessBold(
+  text: string,
+  onStrip?: (d: ExcessBoldStripDiagnostic) => void,
+): string {
   if (!text.includes('**')) return text
 
   const nonce = Math.random().toString(36).slice(2)
@@ -800,14 +837,24 @@ export function stripExcessBold(text: string): string {
 
   let boldChars = 0
   for (const m of visible.matchAll(/\*\*([^*]+)\*\*/g)) boldChars += m[1].length
+  const ratio = boldChars / visible.length
+
+  // Blank-line-delimited blocks of the masked text (shared by both rules).
+  const blocks = masked.split(/\n{2,}/)
 
-  if (boldChars / visible.length > 0.3) {
-    // Clearly over-bolded — strip every bold span, keep the text.
-    return restore(unbold(masked))
+  if (ratio > 0.3) {
+    // Clearly over-bolded — strip every bold span, keeping the text, EXCEPT
+    // standalone short pseudo-heading blocks (`**Section**`), which stay bold
+    // so a bold-dense digest keeps its section headings.
+    const rebuilt = blocks.map((block) =>
+      isPseudoHeadingBlock(block) ? block : unbold(block),
+    )
+    const out = rejoinBlocks(masked, rebuilt)
+    if (out !== masked) onStrip?.({ rule: 'global', ratio })
+    return restore(out)
   }
 
-  // Per-block check on blank-line-delimited blocks of the masked text.
-  const blocks = masked.split(/\n{2,}/)
+  // Per-block check on the same blocks.
   const rebuilt = blocks.map((block) => {
     const lines = block.split('\n').filter((l) => l.trim() !== '')
     if (lines.length === 0 || !block.includes('**')) return block
@@ -824,17 +871,25 @@ export function stripExcessBold(text: string): string {
     const isProseBlock = lines.every((l) => !isMarkerLine(l, placeholder))
     if (!isProseBlock) return block
     if (!lines.every((l) => isFullyBolded(l))) return block
-    if (lines.length === 1 && lines[0].trim().length <= 48) return block
+    if (isPseudoHeadingBlock(block)) return block
     return unbold(block)
   })
 
-  // Rejoin with the original gap shapes: split() lost them, so re-split the
-  // masked text capturing the separators and interleave.
+  const out = rejoinBlocks(masked, rebuilt)
+  if (out !== masked) onStrip?.({ rule: 'per-block', ratio })
+  return restore(out)
+}
+
+/**
+ * Rejoin blocks produced by `masked.split(/\n{2,}/)` after per-block mapping,
+ * restoring the ORIGINAL blank-gap shapes (split() drops the separators, so
+ * re-capture them from the masked source and interleave).
+ */
+function rejoinBlocks(masked: string, rebuilt: string[]): string {
   const seps = masked.match(/\n{2,}/g) ?? []
   let out = rebuilt[0] ?? ''
   for (let i = 1; i < rebuilt.length; i++) out += (seps[i - 1] ?? '\n\n') + rebuilt[i]
-
-  return restore(out)
+  return out
 }
 
 // ---------------------------------------------------------------------------