switchroom 0.16.23 → 0.16.27

package/telegram-plugin/gateway/skill-proposal-card.ts

@@ -0,0 +1,167 @@
+/**
+ * One-tap skill-improvement proposal card (#2670, "one-tap
+ * self-improvement").
+ *
+ * The weekly skill-synthesis cron drafts a proposed personal skill and
+ * persists it (full draft bundle) in the self-improve proposal store
+ * (`src/self-improve/skill-proposals.ts`). This module renders that
+ * proposal as a Telegram Approve / Dismiss card and builds the synthetic
+ * inbound the gateway injects when the operator taps Approve — instructing
+ * the live agent to APPLY the stored draft through the existing
+ * `skill_init_personal` / `skill_edit_personal` write pipeline (so the
+ * merged `scanBundleForSecrets` gate runs; the agent never self-applies —
+ * the operator tap is the authorization, satisfying `no-self-escalation`).
+ *
+ * Pure builders, kept out of gateway.ts so the card text + callback shape
+ * + inbound shape are pinned by tests independent of the bot plumbing.
+ *
+ * callback_data shape (must fit Telegram's 64-byte limit):
+ *   skprop:approve:<id>
+ *   skprop:deny:<id>
+ * where <id> is the proposal's UUID from the store.
+ */
+
+import type { InboundMessage } from './ipc-protocol.js'
+
+export const SKILL_PROPOSAL_CALLBACK_PREFIX = 'skprop:'
+
+/** Narrow shape of a stored proposal the card/inbound builders need.
+ *  Mirrors SkillProposal in src/self-improve/skill-proposals.ts without
+ *  importing across the tsconfig boundary. */
+export interface SkillProposalView {
+  id: string
+  skill_slug: string
+  is_new: boolean
+  lesson: string
+  evidence: string
+  /** SKILL.md body, for the optional "show full draft" / step preview. */
+  skill_md?: string
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+}
+
+/** A short bullet preview of the drafted procedure (first few non-empty,
+ *  non-frontmatter lines of SKILL.md), capped for the card. */
+export function previewSteps(skillMd: string | undefined, maxLines = 5): string[] {
+  if (!skillMd) return []
+  // Drop YAML frontmatter block if present.
+  let body = skillMd
+  if (body.startsWith('---')) {
+    const end = body.indexOf('\n---', 3)
+    if (end >= 0) body = body.slice(body.indexOf('\n', end + 1) + 1)
+  }
+  const out: string[] = []
+  for (const raw of body.split('\n')) {
+    const line = raw.trim()
+    if (!line || line.startsWith('#')) continue
+    out.push(line.replace(/^[-*\d.)\s]+/, '').slice(0, 120))
+    if (out.length >= maxLines) break
+  }
+  return out
+}
+
+/** Render the proposal card text (HTML parse mode). */
+export function renderSkillProposalCard(p: SkillProposalView): string {
+  const verb = p.is_new ? 'New personal skill' : 'Update to personal skill'
+  const lines: string[] = []
+  lines.push(`🧩 <b>Skill improvement proposed</b>`)
+  lines.push('')
+  lines.push(`<b>${escapeHtml(verb)}:</b> <code>${escapeHtml(p.skill_slug)}</code>`)
+  lines.push(`<b>Lesson:</b> ${escapeHtml(p.lesson)}`)
+  if (p.evidence) lines.push(`<i>${escapeHtml(p.evidence)}</i>`)
+  const steps = previewSteps(p.skill_md)
+  if (steps.length > 0) {
+    lines.push('')
+    lines.push('<b>Draft procedure:</b>')
+    for (const s of steps) lines.push(`• ${escapeHtml(s)}`)
+  }
+  lines.push('')
+  lines.push(
+    '<i>Tap Add to apply it (runs through the secret-scan write pipeline). ' +
+      'Tap Dismiss and it won’t be proposed again.</i>',
+  )
+  return lines.join('\n')
+}
+
+/** Inline keyboard for the proposal card. */
+export function skillProposalKeyboard(id: string): {
+  inline_keyboard: Array<Array<{ text: string; callback_data: string }>>
+} {
+  return {
+    inline_keyboard: [
+      [
+        { text: '✅ Add skill', callback_data: `${SKILL_PROPOSAL_CALLBACK_PREFIX}approve:${id}` },
+        { text: '🚫 Dismiss', callback_data: `${SKILL_PROPOSAL_CALLBACK_PREFIX}deny:${id}` },
+      ],
+    ],
+  }
+}
+
+/** Parse a `skprop:` callback into { action, id }, or null if not ours. */
+export function parseSkillProposalCallback(
+  data: string,
+): { action: 'approve' | 'deny'; id: string } | null {
+  if (!data.startsWith(SKILL_PROPOSAL_CALLBACK_PREFIX)) return null
+  const rest = data.slice(SKILL_PROPOSAL_CALLBACK_PREFIX.length)
+  const idx = rest.indexOf(':')
+  if (idx < 0) return null
+  const action = rest.slice(0, idx)
+  const id = rest.slice(idx + 1)
+  if ((action !== 'approve' && action !== 'deny') || id.length === 0) return null
+  return { action, id }
+}
+
+export interface SkillProposalInboundContext {
+  agent: string
+  chat_id: string
+  threadId?: number
+}
+
+/**
+ * Build the synthetic inbound injected when the operator taps Approve.
+ * It instructs the live agent to apply the stored draft via the personal-
+ * skill write pipeline — the agent never self-applies; this tap is the
+ * authorization. `meta.source = "skill_proposal_apply"` so the bridge
+ * renders it as `<channel source="skill_proposal_apply">`.
+ */
+export function buildSkillProposalApplyInbound(opts: {
+  ctx: SkillProposalInboundContext
+  proposalId: string
+  skillSlug: string
+  isNew: boolean
+  operatorId: string
+  nowMs?: number
+}): InboundMessage {
+  const ts = opts.nowMs ?? Date.now()
+  const tool = opts.isNew ? 'skill_init_personal' : 'skill_edit_personal'
+  return {
+    type: 'inbound',
+    chatId: opts.ctx.chat_id,
+    ...(opts.ctx.threadId != null ? { threadId: opts.ctx.threadId } : {}),
+    messageId: ts,
+    user: 'skill-synthesis',
+    userId: 0,
+    ts,
+    text:
+      `✅ Operator approved your proposed skill \`${opts.skillSlug}\` ` +
+      `(proposal ${opts.proposalId}). Apply it now: read the stored draft ` +
+      `from the self-improve proposal store and call \`${tool}\` with that ` +
+      `exact draft bundle. Do NOT re-draft or add anything from this ` +
+      `conversation — write the stored bundle verbatim so the secret-scan ` +
+      `write pipeline validates it. Confirm to the operator when it lands.`,
+    meta: {
+      source: 'skill_proposal_apply',
+      agent: opts.ctx.agent,
+      ...(opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {}),
+      proposal_id: opts.proposalId,
+      skill_slug: opts.skillSlug,
+      is_new: String(opts.isNew),
+      operator_id: opts.operatorId,
+    },
+  }
+}

package/telegram-plugin/inline-keyboard-callbacks.ts

@@ -200,7 +200,10 @@ export interface FinalizeCallbackContext {
   answerCallbackQuery: (
     opts?: { text?: string; show_alert?: boolean },
   ) => Promise<unknown>
-  editMessageText: (text: string, opts?: Record<string, unknown>) => Promise<unknown>
+  editMessageText: (
+    text: string | { markdown: string },
+    opts?: Record<string, unknown>,
+  ) => Promise<unknown>
 }
 
 export interface FinalizeCallbackOptions {
@@ -225,11 +228,12 @@ export interface FinalizeCallbackOptions {
    */
   newText: string
   /**
-   * Parse mode for `newText`. Match the original message's parse mode —
-   * mixing modes mid-edit silently breaks formatting. Optional; omitted
-   * means plain text.
+   * When true, `newText` is edited as a LITERAL plain string (no markdown
+   * parsing) — match the original message's send shape. Default (false) →
+   * the rich-markdown path, so `newText` is rendered as GFM markdown
+   * (#2669, successor to the old `parseMode` option).
    */
-  parseMode?: 'HTML' | 'Markdown' | 'MarkdownV2'
+  literalText?: boolean
   /**
    * Side effect invoked AFTER `editMessageText` resolves. Use for
    * synthesizing the `<channel source="...">` inbound that wakes the
@@ -274,14 +278,16 @@ export async function finalizeCallback(
   })
   // Invariant 2 — strip keyboard + append status line, atomic edit.
   try {
-    await ctx.editMessageText(opts.newText, {
-      reply_markup: { inline_keyboard: [] },
-      ...(opts.parseMode ? { parse_mode: opts.parseMode } : {}),
-      // Default link_preview_options off — most finalized cards don't
-      // benefit from preview cards, and a stale preview survives the
-      // edit otherwise.
-      link_preview_options: { is_disabled: true },
-    })
+    await ctx.editMessageText(
+      opts.literalText ? opts.newText : { markdown: opts.newText },
+      {
+        reply_markup: { inline_keyboard: [] },
+        // Default link_preview_options off — most finalized cards don't
+        // benefit from preview cards, and a stale preview survives the
+        // edit otherwise.
+        link_preview_options: { is_disabled: true },
+      },
+    )
   } catch (err) {
     // MESSAGE_NOT_MODIFIED (text didn't change) and MESSAGE_TO_EDIT_NOT_FOUND
     // (operator already deleted the card) are both benign. Other failures

package/telegram-plugin/issues-card.ts

@@ -17,7 +17,7 @@
  */
 
 import { readFileSync, writeFileSync } from "node:fs";
-import { escapeHtml } from "./card-format.js";
+import { escapeMarkdown } from "./card-format.js";
 import type { IssueEvent, IssueSeverity } from "../src/issues/index.js";
 
 export interface BotApiForIssuesCard {
@@ -92,7 +92,7 @@ export function renderIssuesCard(opts: RenderIssuesCardOpts): string | null {
   const maxSeverity = sorted[0].severity;
   const headerEmoji = SEVERITY_EMOJI[maxSeverity];
   const count = sorted.length;
-  const header = `${headerEmoji} <b>${escapeHtml(opts.agentName)}</b> · ${count} ${count === 1 ? "issue" : "issues"}`;
+  const header = `${headerEmoji} **${escapeMarkdown(opts.agentName)}** · ${count} ${count === 1 ? "issue" : "issues"}`;
 
   const maxRows = opts.maxRows ?? DEFAULT_MAX_ROWS;
   const visible = sorted.slice(0, maxRows);
@@ -101,22 +101,22 @@ export function renderIssuesCard(opts: RenderIssuesCardOpts): string | null {
   const now = opts.now ?? Date.now();
   const rows = visible.map((e) => {
     const emoji = SEVERITY_EMOJI[e.severity];
-    const occ = e.occurrences > 1 ? ` <i>(×${e.occurrences})</i>` : "";
+    const occ = e.occurrences > 1 ? ` _(×${e.occurrences})_` : "";
     const ago = relTime(now - e.last_seen);
-    const head = `${emoji} <code>${escapeHtml(e.fingerprint)}</code>  ${escapeHtml(e.summary)}${occ} — <i>${ago}</i>`;
+    const head = `${emoji} \`${e.fingerprint}\`  ${escapeMarkdown(e.summary)}${occ} — _${ago}_`;
     // Render the `detail` line below the summary when present and short
     // enough to be a remediation hint (not a multi-line stderr tail).
     // Convention from the cron prompt template: agents put "Fix: <cmd>"
     // or "→ <cmd>" in detail. Long stderr details are omitted from the
     // card to keep the layout tight; users can run /issues to see them.
     const remediation = formatRemediation(e.detail);
-    return remediation == null ? head : `${head}\n  → <i>${escapeHtml(remediation)}</i>`;
+    return remediation == null ? head : `${head}\n  → _${escapeMarkdown(remediation)}_`;
   });
 
   const lines = [header, "", ...rows];
   if (overflow > 0) {
     lines.push("");
-    lines.push(`<i>+${overflow} more not shown — run <code>/issues</code></i>`);
+    lines.push(`_+${overflow} more not shown — run \`/issues\`_`);
   }
   return lines.join("\n");
 }
@@ -326,7 +326,6 @@ export function createIssuesCardHandle(
       if (body === lastBody && messageId != null) return;
 
       const sendOpts: Record<string, unknown> = {
-        parse_mode: "HTML",
         disable_web_page_preview: true,
         // Status card, not the user's answer — silence the open ping.
         // (editMessageText ignores disable_notification, so the shared

package/telegram-plugin/model-unavailable.ts

@@ -366,10 +366,10 @@ export function formatModelUnavailableCard(
   opts: FormatCardOptions = {},
 ): string {
   const now = opts.now ?? new Date()
-  const slotPart = opts.slot ? ` (slot <b>${escHtml(opts.slot)}</b>)` : ''
+  const slotPart = opts.slot ? ` (slot **${escHtml(opts.slot)}**)` : ''
   const reason = formatReason(detection, now)
   const lines = [
-    `⚠️ <b>Model unavailable</b> on agent <b>${escHtml(agent)}</b>${slotPart}`,
+    `⚠️ **Model unavailable** on agent **${escHtml(agent)}**${slotPart}`,
     `Reason: ${reason}`,
     '',
   ]
@@ -378,7 +378,7 @@ export function formatModelUnavailableCard(
     // swap; a follow-up announcement (causal-shape) will land within
     // ~1s. Mention it explicitly so the user knows not to react.
     lines.push(
-      '<i>Auto-failover in progress — see the announcement below.</i>',
+      '_Auto-failover in progress — see the announcement below._',
     )
   } else {
     // Default — kinds where auto-fallback can't help (network)
@@ -386,10 +386,10 @@ export function formatModelUnavailableCard(
     // a verb (post-RFC-H); `/auth use <label>` is the canonical
     // fleet-wide swap.
     lines.push(
-      '<b>What to try</b>',
-      '• <code>/auth use &lt;label&gt;</code> — switch the fleet to a healthy account',
-      '• <code>/auth add</code> — attach another subscription',
-      '• <code>/usage</code> — show quota breakdown',
+      '**What to try**',
+      '• \`/auth use <label>\` — switch the fleet to a healthy account',
+      '• \`/auth add\` — attach another subscription',
+      '• \`/usage\` — show quota breakdown',
     )
   }
   return lines.join('\n')
@@ -471,9 +471,5 @@ export function resolveModelUnavailableFromOperatorEvent(
 // ─── HTML escape (mirrors operator-events.ts) ────────────────────────────────
 
 function escHtml(text: string): string {
-  return text
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
+  return text.replace(/([\\`*_~=\[\]|])/g, '\\$1')
 }

package/telegram-plugin/operator-events-history.ts

@@ -78,7 +78,7 @@ export function formatLastEventLine(
   }
 
   const kindIcon = EVENT_KIND_ICON[ev.kind] ?? '⚪'
-  return `  <i>last: ${kindIcon} ${ev.kind} (${age})</i>`
+  return `  _last: ${kindIcon} ${ev.kind} (${age})_`
 }
 
 const EVENT_KIND_ICON: Record<string, string> = {

package/telegram-plugin/operator-events.ts

@@ -217,9 +217,9 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'credentials-expired':
       return {
         text: [
-          `🔑 <b>Claude login expired</b> for <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
-          `Tap <b>Reauth now</b> to refresh credentials.`,
+          `🔑 **Claude login expired** for **${agent}**.`,
+          detail ? `_${detail}_` : '',
+          `Tap **Reauth now** to refresh credentials.`,
         ]
           .filter(Boolean)
           .join('\n'),
@@ -236,9 +236,9 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'credentials-invalid':
       return {
         text: [
-          `🔑 <b>Invalid Claude credentials</b> for <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
-          `Run <code>/auth reauth ${agent}</code> or tap below.`,
+          `🔑 **Invalid Claude credentials** for **${agent}**.`,
+          detail ? `_${detail}_` : '',
+          `Run \`/auth reauth ${agent}\` or tap below.`,
         ]
           .filter(Boolean)
           .join('\n'),
@@ -255,9 +255,9 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'credit-exhausted':
       return {
         text: [
-          `💳 <b>Credit balance too low</b> for <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
-          `Use <code>/auth use &lt;label&gt;</code> to switch account slot or <code>/auth add</code> to add one.`,
+          `💳 **Credit balance too low** for **${agent}**.`,
+          detail ? `_${detail}_` : '',
+          `Use \`/auth use <label>\` to switch account slot or \`/auth add\` to add one.`,
         ]
           .filter(Boolean)
           .join('\n'),
@@ -274,9 +274,9 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
       // are the historical source; this is now the single owner.
       return {
         text: [
-          `⚠️ <b>Quota exhausted</b> for <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
-          `All account slots are at the usage limit. Switchroom will auto-fallback when another slot is available. Use <code>/auth use &lt;label&gt;</code> to switch manually.`,
+          `⚠️ **Quota exhausted** for **${agent}**.`,
+          detail ? `_${detail}_` : '',
+          `All account slots are at the usage limit. Switchroom will auto-fallback when another slot is available. Use \`/auth use <label>\` to switch manually.`,
         ]
           .filter(Boolean)
           .join('\n'),
@@ -290,8 +290,8 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'rate-limited':
       return {
         text: [
-          `🚦 <b>Rate limited</b> for <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
+          `🚦 **Rate limited** for **${agent}**.`,
+          detail ? `_${detail}_` : '',
           `Claude is temporarily rate-limiting requests. Will retry automatically.`,
         ]
           .filter(Boolean)
@@ -306,8 +306,8 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'agent-crashed':
       return {
         text: [
-          `💥 <b>Agent crashed</b>: <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
+          `💥 **Agent crashed**: **${agent}**.`,
+          detail ? `_${detail}_` : '',
         ]
           .filter(Boolean)
           .join('\n'),
@@ -324,8 +324,8 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'agent-restarted-unexpectedly':
       return {
         text: [
-          `🔄 <b>Agent restarted unexpectedly</b>: <b>${agent}</b>.`,
-          detail ? `<i>${detail}</i>` : '',
+          `🔄 **Agent restarted unexpectedly**: **${agent}**.`,
+          detail ? `_${detail}_` : '',
           `This may indicate a crash-loop. Check logs if it happens again.`,
         ]
           .filter(Boolean)
@@ -343,8 +343,8 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'unknown-4xx':
       return {
         text: [
-          `⚠️ <b>API error (4xx)</b> for <b>${agent}</b>.`,
-          detail ? `<code>${detail}</code>` : '',
+          `⚠️ **API error (4xx)** for **${agent}**.`,
+          detail ? `\`${detail}\`` : '',
         ]
           .filter(Boolean)
           .join('\n'),
@@ -361,8 +361,8 @@ export function renderOperatorEvent(ev: OperatorEvent): RenderResult {
     case 'unknown-5xx':
       return {
         text: [
-          `🔥 <b>Server error (5xx)</b> for <b>${agent}</b>.`,
-          detail ? `<code>${detail}</code>` : '',
+          `🔥 **Server error (5xx)** for **${agent}**.`,
+          detail ? `\`${detail}\`` : '',
           `Anthropic may be experiencing issues. Will retry automatically.`,
         ]
           .filter(Boolean)
@@ -411,12 +411,8 @@ export function resetAllCooldowns(): void {
   cooldownMap.clear()
 }
 
-// ─── HTML escape ─────────────────────────────────────────────────────────────
+// ─── Markdown escape (#2669) ──────────────────────────────────────────────────
 
 function escHtml(text: string): string {
-  return text
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
+  return text.replace(/([\\`*_~=\[\]|])/g, '\\$1')
 }

package/telegram-plugin/package.json

@@ -32,7 +32,7 @@
     "@secretlint/secretlint-rule-preset-recommend": "^12.2.0",
     "@secretlint/types": "^12.2.0",
     "@xterm/headless": "^6.0.0",
-    "grammy": "^1.21.0",
+    "grammy": "^1.44",
     "posthog-node": "^5.29.2"
   },
   "engines": {

package/telegram-plugin/pending-work-progress.ts

@@ -49,14 +49,13 @@
  * interval is short (5s) but edits are spaced at EDIT_INTERVAL_MS so
  * the Telegram bot.api editMessageText rate stays well under limits.
  *
- * Edits preserve the anchor's original `parse_mode` (issue #1698). The
- * anchor was sent through the reply tool, which defaults to HTML; an
- * earlier version of this module dropped parse_mode on edit, which made
- * the next "still working (Nm)" tick re-render `<b>` / `<code>` tags as
- * literal text. The suffix itself is plain text (no `<`/`>`/`&`) so it
- * is safe under any parse_mode. On subsequent edits the prior suffix is
- * stripped before re-appending so the message never accumulates duplicate
- * suffixes.
+ * Edits preserve the anchor's original send shape — rich-markdown vs the
+ * literal `format:'text'` path (#2669, successor to the #1698 parse-mode
+ * contract). The anchor was sent through the reply tool, which defaults to
+ * the rich-markdown path; the edit re-sends via the SAME path so the
+ * anchor body keeps rendering the way it first did. On subsequent edits
+ * the prior suffix is stripped before re-appending so the message never
+ * accumulates duplicate suffixes.
  *
  * Kill switch: `SWITCHROOM_DISABLE_PENDING_PROGRESS=1` disables the
  * whole subsystem. The conversational-pacing prompt is unaffected.
@@ -65,32 +64,36 @@
 export const EDIT_INTERVAL_MS = 60_000
 export const POLL_INTERVAL_MS = 5_000
 export const MAX_LIFETIME_MS = 30 * 60_000
-/** Telegram message length limit is 4096; budget headroom for the
+/** Rich-message wire cap is 32768 (#2669); budget headroom for the
  *  suffix and any escape expansion. If the anchor text plus suffix
  *  would exceed this, we skip the edit (the user still sees the
  *  original) rather than truncate the model's authored prose. */
-export const TELEGRAM_MSG_CAP = 4000
+export const TELEGRAM_MSG_CAP = 32768
 
 /**
  * Regex matching the suffix we append. Used to strip a prior suffix
  * before appending the next one. The (\d+) covers "1m" / "12m" / etc.
  * The reachability clause is optional so anchors carrying a pre-v0.14.30
- * suffix (no clause) are still stripped during a rolling upgrade.
- * Kept anchored to end-of-string so it only matches OUR suffix, not
- * something the model happened to write.
+ * suffix (no clause) are still stripped during a rolling upgrade. Both the
+ * legacy em-dash prefix (`— still working`) and the rich-markdown italic
+ * form (`_still working … _`, #2669) are matched so a rolling upgrade
+ * strips either. Kept anchored to end-of-string so it only matches OUR
+ * suffix, not something the model happened to write.
  */
 const SUFFIX_RE =
-  /\n\n— still working \(\d+m\)( · message me anytime, I'll keep you posted)?$/
+  /\n\n(?:— |_)still working \(\d+m\)( · message me anytime, I'll keep you posted)?_?$/
 
 export interface PendingProgressEditCtx {
   chatId: string
   threadId: number | null
   messageId: number
   newText: string
-  /** Telegram parse_mode the original anchor was sent with (#1698).
-   *  The edit must use the same mode or pre-rendered HTML / MarkdownV2
-   *  tags in `anchorOriginalText` re-render as literal text. */
-  parseMode: 'HTML' | 'MarkdownV2' | undefined
+  /** True when the original anchor was a literal `format:'text'` send
+   *  (plain `sendMessage`, no rich-message wrapper). The edit must match:
+   *  a rich anchor re-edits via `editMessageText({ markdown })`, a literal
+   *  anchor re-edits as a plain string (#2669 single-rich-path migration of
+   *  the #1698 parse-mode-preservation contract). */
+  literalText: boolean
 }
 
 /**
@@ -145,11 +148,11 @@ interface State {
   /** The captured anchor text — what the model wrote, *minus* any
    *  prior pending-progress suffix. Used as the base for every edit. */
   anchorOriginalText: string
-  /** parse_mode the anchor was originally sent with. Edits must
-   *  reuse this or the rendered HTML / MarkdownV2 tags in
-   *  anchorOriginalText render as literal text on the next tick
-   *  (issue #1698). */
-  anchorParseMode: 'HTML' | 'MarkdownV2' | undefined
+  /** True when the anchor was a literal `format:'text'` send. Edits must
+   *  match the original send shape (rich vs literal) or the suffix re-edit
+   *  changes how the anchor body renders (the #2669 single-rich-path
+   *  successor to the #1698 parse-mode-preservation contract). */
+  anchorLiteralText: boolean
   /** Wall-clock ms when the cross-turn ambient state was *activated*
    *  (at turn_end with pending+anchor). null before activation. */
   activatedAt: number | null
@@ -178,7 +181,7 @@ function ensure(key: string): State {
       pending: false,
       anchorMessageId: null,
       anchorOriginalText: '',
-      anchorParseMode: undefined,
+      anchorLiteralText: false,
       activatedAt: null,
       lastEditAt: null,
     }
@@ -216,7 +219,7 @@ export function startTurn(key: string): void {
   s.pending = false
   s.anchorMessageId = null
   s.anchorOriginalText = ''
-  s.anchorParseMode = undefined
+  s.anchorLiteralText = false
 }
 
 /**
@@ -241,21 +244,18 @@ export function noteOutbound(
   opts: {
     messageId: number
     text: string
-    /** parse_mode the anchor was sent with. Captured so the
-     *  cross-turn edit tick can reuse it (#1698). Undefined or
-     *  omitted means the original send had no parse_mode (plain
-     *  text). Production callers MUST pass this — every reply path
-     *  knows its own parse_mode. Defaulted to undefined only so test
-     *  fixtures don't have to thread it through where they're
-     *  asserting other behaviour. */
-    parseMode?: 'HTML' | 'MarkdownV2' | undefined
+    /** True when the anchor was a literal `format:'text'` send. Captured
+     *  so the cross-turn edit tick re-edits with the same shape (#2669
+     *  single-rich-path successor to the #1698 parse-mode contract).
+     *  Omitted ⇒ false (the rich-markdown default). */
+    literalText?: boolean
   },
 ): void {
   if (!enabled()) return
   const s = ensure(key)
   s.anchorMessageId = opts.messageId
   s.anchorOriginalText = opts.text.replace(SUFFIX_RE, '')
-  s.anchorParseMode = opts.parseMode
+  s.anchorLiteralText = opts.literalText ?? false
 }
 
 /**
@@ -399,7 +399,7 @@ function tick(now: number): void {
     // user-visible counter reads honestly (we only edit at intervals
     // ≥ EDIT_INTERVAL_MS = 60s).
     const minutes = Math.max(1, Math.round(elapsed / 60_000))
-    const suffix = `\n\n— still working (${minutes}m) · message me anytime, I'll keep you posted`
+    const suffix = `\n\n_still working (${minutes}m) · message me anytime, I'll keep you posted_`
     const newText = s.anchorOriginalText + suffix
 
     if (newText.length > TELEGRAM_MSG_CAP) {
@@ -417,7 +417,7 @@ function tick(now: number): void {
       threadId,
       messageId: s.anchorMessageId,
       newText,
-      parseMode: s.anchorParseMode,
+      literalText: s.anchorLiteralText,
     }
     // Fire-and-forget so a slow edit doesn't block the tick loop.
     // Errors are logged but never bubble (a 429 / "message not modified"