switchroom 0.21.4 → 0.21.6

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.21.4", COMMIT_SHA = "aa63e74c";
+var VERSION = "0.21.6", COMMIT_SHA = "ffc152ca";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";

package/dist/host-control/main.js

@@ -21565,7 +21565,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.21.4";
+var VERSION = "0.21.6";
 
 // src/setup/hindsight-recall-passthrough.ts
 var HINDSIGHT_RECALL_TAG_WEIGHT_SEED = Object.freeze({ sidechain: 0.8 });

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.21.4",
+  "version": "0.21.6",
   "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": {
@@ -28,7 +28,7 @@
     "test:vitest": "vitest run",
     "test:bun": "bun test telegram-plugin/tests/agent-state-dir-preload.test.ts telegram-plugin/tests/hindsight-bank-preload.test.ts telegram-plugin/tests/catch-all-forwarded-history.test.ts src/vault/grants.test.ts src/vault/grants-db.test.ts src/vault/write-grants.test.ts src/vault/broker/server-grants.test.ts src/vault/broker/server-write-grants.test.ts src/vault/broker/server-scope-persist.test.ts src/vault/broker/server-tokenless-scope.test.ts src/vault/broker/server-mint-grant-passphrase-attest.test.ts src/vault/broker/server-passphrase-attest.test.ts src/vault/broker/server-mint-grant-posture-attest.test.ts src/vault/broker/server-admin-only-keys.test.ts src/vault/broker/client-token.test.ts src/vault/broker/server-unlock.test.ts src/vault/broker/auto-unlock.test.ts src/vault/broker/drift-detection.test.ts tests/vault-broker-passphrase.test.ts src/cli/vault-get-broker.test.ts src/vault/resolver-via-broker.test.ts src/vault/broker/scope.test.ts src/vault/broker/server.test.ts src/litellm/provision-apply-e2e.test.ts src/drive/disconnect.test.ts src/drive/grants.test.ts src/drive/oauth.test.ts src/drive/onboarding.test.ts src/drive/reconciler.test.ts src/drive/vault-slots.test.ts src/drive/wrapper.test.ts src/vault/approvals/kernel.test.ts src/vault/approvals/approval-origin.test.ts src/vault/approvals/self-approval-bypass.test.ts src/vault/approvals/schema-idempotent.test.ts src/vault/broker/server-approvals.test.ts telegram-plugin/tests/boot-probes.test.ts telegram-plugin/tests/boot-version-string.test.ts telegram-plugin/tests/history.test.ts telegram-plugin/tests/boot-briefing-builder.test.ts telegram-plugin/tests/cross-turn-card-gate.test.ts telegram-plugin/tests/emission-authority-open-gate.test.ts telegram-plugin/tests/emission-authority-ping-gate.test.ts telegram-plugin/tests/emission-authority-card-drain-gate.test.ts telegram-plugin/tests/per-topic-current-turn.test.ts telegram-plugin/tests/history-reaper.test.ts telegram-plugin/tests/ipc-server-client.test.ts telegram-plugin/tests/ipc-server-race.test.ts telegram-plugin/tests/ipc-server-buzz-dedup.test.ts telegram-plugin/tests/ipc-server-query-pending-permission.test.ts telegram-plugin/tests/ipc-server-check-pre-approved.test.ts telegram-plugin/tests/rollout-narration-edit-socket.test.ts telegram-plugin/tests/gateway-bridge.test.ts telegram-plugin/tests/gateway-startup-mutex.test.ts telegram-plugin/tests/gateway-clean-shutdown-marker.test.ts telegram-plugin/tests/boot-card-dedupe.test.ts telegram-plugin/tests/boot-card-reason.test.ts telegram-plugin/tests/progress-update.test.ts telegram-plugin/tests/progress-fallback-cap.test.ts telegram-plugin/tests/progress-cap.test.ts telegram-plugin/tests/quota-cache.test.ts telegram-plugin/tests/silent-reply-guard.test.ts telegram-plugin/tests/unhandled-rejection-policy.test.ts telegram-plugin/tests/registry-turns.test.ts telegram-plugin/registry/subagents.test.ts telegram-plugin/registry/subagents-bugs.test.ts telegram-plugin/tests/subagent-watcher-parent-turn-key.test.ts telegram-plugin/tests/worker-origin-gap-dispatch.test.ts telegram-plugin/tests/subagent-nested-dispatch.test.ts telegram-plugin/tests/nested-worker-visibility-harness.test.ts telegram-plugin/tests/turns-writer.test.ts telegram-plugin/tests/resume-inbound-builder.test.ts telegram-plugin/tests/subagent-tracker-hooks.test.ts telegram-plugin/tests/resolve-calling-subagent.test.ts telegram-plugin/tests/gateway-update-placeholder-dispatch.test.ts telegram-plugin/tests/status-query-telemetry.test.ts telegram-plugin/tests/reaction-trigger.test.ts telegram-plugin/tests/reaction-trigger-flow.test.ts telegram-plugin/tests/subagent-watcher-workflow-visibility.test.ts telegram-plugin/uat/load-env.test.ts telegram-plugin/uat/feed-matcher.test.ts telegram-plugin/uat/uat-driver.test.ts telegram-plugin/gateway/webhook-ingest-server.test.ts telegram-plugin/tests/skill-proposal-card.test.ts",
     "test:watch": "vitest",
-    "lint": "tsc --noEmit && node scripts/check-plugin-references.mjs && bash scripts/check-bot-api-wrapping.sh && node scripts/check-bun-test-imports.mjs && node scripts/check-test-runner-coverage.mjs && node scripts/check-bun-module-mock-scope.mjs && node scripts/check-no-pii-secrets.mjs && node scripts/check-bench-baseline-anonymised.mjs && node scripts/check-vault-test-hermeticity.mjs && node scripts/check-auth-test-hermeticity.mjs && node scripts/check-agent-state-dir-hermeticity.mjs && node scripts/check-hindsight-bank-hermeticity.mjs && node scripts/check-no-broadcast-delivery.mjs && node scripts/check-stale-tool-descriptions.mjs && node scripts/check-mcp-instructions-budget.mjs && node scripts/check-web-subscription-honest.mjs && node scripts/check-no-unpinned-npx-playwright.mjs && node scripts/check-gateway-line-ratchet.mjs && node scripts/check-retry-flood-hooks.mjs && node scripts/check-callback-ctx-wrapping.mjs && node scripts/check-status-pin-single-path.mjs && node scripts/check-litellm-config-guard.mjs && node scripts/check-release-asset-names.mjs && node scripts/check-foreign-db-readonly.mjs && node scripts/check-changelog-entry.mjs && node scripts/check-agent-attribution-trailers.mjs && node scripts/check-hindsight-write-redaction.mjs && bun scripts/check-secret-pattern-parity.ts && bun scripts/check-hostd-template-guard.ts",
+    "lint": "tsc --noEmit && node scripts/check-plugin-references.mjs && bash scripts/check-bot-api-wrapping.sh && node scripts/check-bun-test-imports.mjs && node scripts/check-test-runner-coverage.mjs && node scripts/check-bun-module-mock-scope.mjs && node scripts/check-no-pii-secrets.mjs && node scripts/check-bench-baseline-anonymised.mjs && node scripts/check-vault-test-hermeticity.mjs && node scripts/check-auth-test-hermeticity.mjs && node scripts/check-agent-state-dir-hermeticity.mjs && node scripts/check-hindsight-bank-hermeticity.mjs && node scripts/check-no-broadcast-delivery.mjs && node scripts/check-stale-tool-descriptions.mjs && node scripts/check-mcp-instructions-budget.mjs && node scripts/check-web-subscription-honest.mjs && node scripts/check-no-unpinned-npx-playwright.mjs && node scripts/check-gateway-line-ratchet.mjs && node scripts/check-retry-flood-hooks.mjs && node scripts/check-callback-ctx-wrapping.mjs && node scripts/check-ctx-send-wrapping.mjs && node scripts/check-status-pin-single-path.mjs && node scripts/check-litellm-config-guard.mjs && node scripts/check-release-asset-names.mjs && node scripts/check-foreign-db-readonly.mjs && node scripts/check-changelog-entry.mjs && node scripts/check-agent-attribution-trailers.mjs && node scripts/check-hindsight-write-redaction.mjs && bun scripts/check-secret-pattern-parity.ts && bun scripts/check-hostd-template-guard.ts",
     "lint:tsc": "tsc --noEmit",
     "lint:hindsight-write-redaction": "node scripts/check-hindsight-write-redaction.mjs",
     "lint:secret-pattern-parity": "bun scripts/check-secret-pattern-parity.ts",
@@ -46,6 +46,7 @@
     "lint:gateway-line-ratchet": "node scripts/check-gateway-line-ratchet.mjs",
     "lint:retry-flood-hooks": "node scripts/check-retry-flood-hooks.mjs",
     "lint:callback-ctx-wrapping": "node scripts/check-callback-ctx-wrapping.mjs",
+    "lint:ctx-send-wrapping": "node scripts/check-ctx-send-wrapping.mjs",
     "lint:status-pin-single-path": "node scripts/check-status-pin-single-path.mjs",
     "lint:mcp-instructions-budget": "node scripts/check-mcp-instructions-budget.mjs",
     "lint:litellm-config-guard": "node scripts/check-litellm-config-guard.mjs",

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

@@ -44729,6 +44729,7 @@ function shouldEmitShadowTrace(eventKind, effectCount, globalKind, verbose = gwT
 // shared/bot-runtime.ts
 init_rich_send();
 var tgPostTagStore = new AsyncLocalStorage2;
+var sendContextStore = new AsyncLocalStorage2;
 function escapeHtmlForTg(text) {
   return text.replace(/([\\`*_~=\[\]|])/g, "\\$1");
 }
@@ -45728,7 +45729,8 @@ function buildReplyForwardContext(p) {
   const replyToMsg = p.ctx.message?.reply_to_message;
   const replyToMessageId = replyToMsg?.message_id;
   const quoteText = p.ctx.message?.quote?.text;
-  const replyToTextRaw = quoteText != null && quoteText.length > 0 ? quoteText : replyToMsg ? replyToMsg.text ?? replyToMsg.caption ?? undefined : undefined;
+  const richParentText = extractRichMessageText(replyToMsg?.rich_message);
+  const replyToTextRaw = quoteText != null && quoteText.length > 0 ? quoteText : replyToMsg ? replyToMsg.text ?? replyToMsg.caption ?? richParentText ?? undefined : undefined;
   const replyToText = replyToTextRaw != null ? replyToTextRaw.length > p.replyToTextMax ? replyToTextRaw.slice(0, p.replyToTextMax - 1) + "\u2026" : replyToTextRaw : undefined;
   const replyToTextEscaped = formatReplyToText(replyToTextRaw, p.replyToTextMax);
   const forwardOrigins = p.coalescedForwardOrigins ?? dedupeForwardOrigins2([parseForwardOrigin2(p.ctx.message?.forward_origin)]);
@@ -45749,18 +45751,18 @@ function resolveReplyToFromBuffer(p) {
   let replyToRole;
   let replyToKind;
   const liveTextEmpty = replyToTextEscaped == null || replyToTextEscaped.length === 0;
-  if (p.historyEnabled && p.replyToMessageId != null && liveTextEmpty) {
+  if (p.historyEnabled && p.replyToMessageId != null) {
     try {
       const recovered = p.lookup(p.replyToMessageId);
-      if (recovered != null && recovered.role === "system" && recovered.kind) {
-        replyToKind = recovered.kind;
-      }
-      if (recovered && recovered.text.length > 0) {
-        replyToText = recovered.text.length > p.replyToTextMax ? recovered.text.slice(0, p.replyToTextMax - 1) + "\u2026" : recovered.text;
-        replyToTextEscaped = formatReplyToText(recovered.text, p.replyToTextMax);
-        replyToRole = recovered.role;
-      } else if (recovered) {
+      if (recovered != null) {
         replyToRole = recovered.role;
+        if (recovered.role === "system" && recovered.kind) {
+          replyToKind = recovered.kind;
+        }
+        if (liveTextEmpty && recovered.text.length > 0) {
+          replyToText = recovered.text.length > p.replyToTextMax ? recovered.text.slice(0, p.replyToTextMax - 1) + "\u2026" : recovered.text;
+          replyToTextEscaped = formatReplyToText(recovered.text, p.replyToTextMax);
+        }
       }
     } catch {}
   }
@@ -67220,6 +67222,37 @@ function installRichMarkdownGuard(bot) {
     return prev(method, payload, signal);
   });
 }
+var sendContextStore2 = new AsyncLocalStorage5;
+function withTgSendContext(ctx, fn) {
+  return sendContextStore2.run(ctx, fn);
+}
+function installSystemMessageObserver(bot, observe) {
+  bot.api.config.use(async (prev, method, payload, signal) => {
+    const res = await prev(method, payload, signal);
+    try {
+      const r = res;
+      if (r != null && typeof r === "object" && r.ok === true) {
+        observe(r.result, resolveSendContext(payload));
+      }
+    } catch {}
+    return res;
+  });
+}
+function resolveSendContext(payload) {
+  const ctx = sendContextStore2.getStore();
+  const p = payload ?? {};
+  const rawChat = p.chat_id;
+  const chat_id = ctx?.chat_id ?? (typeof rawChat === "string" || typeof rawChat === "number" ? String(rawChat) : undefined);
+  const rawThread = p.message_thread_id;
+  const threadId = ctx?.threadId ?? (typeof rawThread === "number" ? rawThread : undefined);
+  if (chat_id == null && threadId == null && ctx?.verb == null)
+    return;
+  return {
+    ...chat_id != null ? { chat_id } : {},
+    ...threadId != null ? { threadId } : {},
+    ...ctx?.verb != null ? { verb: ctx.verb } : {}
+  };
+}
 
 // shared/sent-text-capture.ts
 var SENT_TEXT = Symbol.for("switchroom.telegram.sentText");
@@ -104434,10 +104467,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.21.4";
-var COMMIT_SHA = "aa63e74c";
-var COMMIT_DATE = "2026-08-10T17:32:03Z";
-var LATEST_PR = 4597;
+var VERSION2 = "0.21.6";
+var COMMIT_SHA = "ffc152ca";
+var COMMIT_DATE = "2026-08-11T03:22:29Z";
+var LATEST_PR = 4605;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -108611,15 +108644,7 @@ var rawRobustApiCall = createRetryApiCall2({
   floodWaitRemainingMs: probeFloodWaitRemainingMs
 });
 var observeSentMessage = isGatewayMain && HISTORY_ENABLED ? makeSystemMessageObserver({ insert: recordSystemOutbound, updateText: updateSystemOutboundText }) : undefined;
-var robustApiCall = (fn, opts) => {
-  const p = sendGate.gate(() => rawRobustApiCall(fn, opts), opts);
-  if (observeSentMessage == null)
-    return p;
-  return p.then((res) => {
-    observeSentMessage(res, opts);
-    return res;
-  });
-};
+var robustApiCall = (fn, opts) => sendGate.gate(() => withTgSendContext(opts, () => rawRobustApiCall(fn, opts)), opts);
 var swallowingApiCall = createSwallowingRetryApiCall(robustApiCall, (line) => process.stderr.write(line));
 var resetPrivacyForNewSession = makePrivacyResetForNewSession((chatId, threadId, text5) => void swallowingApiCall(() => lockedBot.api.sendMessage(chatId, text5, threadId != null ? { message_thread_id: threadId, disable_notification: false } : { disable_notification: false }), { chat_id: chatId, verb: "privacy-reset-alert", priorityClass: "critical" }));
 var gatedSetMessageReaction = (chatId, messageId, reaction) => robustApiCall(() => lockedBot.api.setMessageReaction(chatId, messageId, reaction), {
@@ -117665,6 +117690,8 @@ async function initGatewayBot() {
   installTgPostLogger(bot);
   installRichMarkdownGuard(bot);
   installSentTextCapture(bot);
+  if (observeSentMessage != null)
+    installSystemMessageObserver(bot, observeSentMessage);
   installEditFloodFuse(bot, {
     ...editFloodFuseConfigFromEnv(process.env),
     onTrip: (i) => process.stderr.write(`edit-flood-fuse ${i.action} method=${i.method} key=${i.key} class=${i.cls}

package/telegram-plugin/gateway/gateway.ts

@@ -302,7 +302,7 @@ import {
 import { installEditFloodFuse, editFloodFuseConfigFromEnv } from '../edit-flood-fuse.js'
 import { createSendGate, sendGateConfigFromEnv, isSendGateShed } from '../send-gate.js'
 import { createStatsLogger, createFloodWindowObserver } from '../send-gate-observability.js'
-import { installTgPostLogger, installRichMarkdownGuard, withTgPostTags } from '../shared/bot-runtime.js'
+import { installTgPostLogger, installRichMarkdownGuard, withTgPostTags, withTgSendContext, installSystemMessageObserver } from '../shared/bot-runtime.js'
 import { installSentTextCapture } from '../shared/sent-text-capture.js'
 import {
   floodStatePath,
@@ -5603,28 +5603,25 @@ const rawRobustApiCall = createRetryApiCall({
   floodWaitRemainingMs: probeFloodWaitRemainingMs,
 })
 
-// #4571 — card/system-surface history lane. Every card the gateway posts
-// (activity card, status pin, approval/boot/issues/worker-feed cards, progress
-// lines, notices) goes through `robustApiCall`, so observing its RESOLVED
-// result is the one chokepoint that makes every posted message id resolvable
-// when the operator quote-replies to it. Never throws; see
-// system-message-observer.ts for the send-vs-edit and throttling contract.
-// Gated on the SAME condition as `initHistory` above — a non-main gateway
-// process never opens the DB, so an observer there would be pure noise.
-// The empty-body alarm (#4576) is the observer's own default — see
-// `defaultEmptyCardTextWarning` in system-message-observer.ts.
+// #4571 — card/system-surface history lane: every card the gateway posts must leave
+// a row so its id resolves when the operator quote-replies to it. #4599 moved the
+// hook off `robustApiCall` (which the `ctx.replyWithRichMessage` slash-command card
+// path bypasses entirely) onto the grammy transformer layer — see
+// `installSystemMessageObserver`, wired at bot construction, and
+// system-message-observer.ts for the send-vs-edit / throttling / alarm contract.
+// Gated as `initHistory` is: a non-main gateway never opens the DB.
 const observeSentMessage = isGatewayMain && HISTORY_ENABLED
   ? makeSystemMessageObserver({ insert: recordSystemOutbound, updateText: updateSystemOutboundText })
   : undefined
 
+// `withTgSendContext` publishes {chat_id, threadId, verb} down to the transformer layer
+// where the observer runs — how a card keeps its `kind`. Sends outside this wrapper
+// still record, just without a verb.
 const robustApiCall = <T>(
   fn: () => Promise<T>,
   opts?: Parameters<typeof rawRobustApiCall<T>>[1],
-): Promise<T> => {
-  const p = sendGate.gate(() => rawRobustApiCall(fn, opts), opts)
-  if (observeSentMessage == null) return p
-  return p.then((res) => { observeSentMessage(res, opts); return res })
-}
+): Promise<T> =>
+  sendGate.gate(() => withTgSendContext(opts, () => rawRobustApiCall(fn, opts)), opts)
 
 // Fire-and-forget wrapper for outbound surfaces that previously had
 // `.catch(() => {})` directly on `bot.api.*` calls. Resolves to undefined
@@ -15061,11 +15058,11 @@ export async function handleInbound(
   } = replyForwardCtx
 
   // Reply-to buffer fallback (post-reset continuity, resolveReplyToFromBuffer).
-  // On a native reply to the BOT's OWN message, Telegram delivers
-  // reply_to_message.message_id but NOT its .text — so the live reply text is
-  // empty even though we authored (and, via recordOutbound, persisted) that
-  // message to history.db (role='assistant', 30-day retention). Recover it so
-  // the antecedent survives a session reset. Fills replyToText (raw, so the
+  // On a native reply to a PLAIN bot-sent message, Telegram delivers
+  // reply_to_message.message_id but NOT its .text (a RICH parent — every card —
+  // carries rich_message and is resolved LIVE upstream since #4598), so the live
+  // reply text is empty even though we persisted it (role='assistant', 30-day
+  // retention). Recover it so it survives a reset. Fills replyToText (raw, so the
   // recordInbound write below persists it — envelope-only would leave the row
   // NULL and starve future briefings), replyToTextEscaped (channel meta), and
   // replyToRole (the reply_to_role attribute). Only when the live text is
@@ -22887,6 +22884,9 @@ async function initGatewayBot(): Promise<void> {
   // on the resolved Message for the shapes a response can't supply. After the fmt
   // guard so it composes OUTSIDE it. See sent-text-capture.ts.
   installSentTextCapture(bot)
+  // #4599 card-history lane: AFTER sent-text-capture so it composes outside it and
+  // can read the request-side stamp. The seam `ctx.replyWithRichMessage` can't bypass.
+  if (observeSentMessage != null) installSystemMessageObserver(bot, observeSentMessage)
   // #3620 flood fuse — installed LAST so it composes OUTERMOST: the one seam no
   // outbound call can bypass (grammY has no route to the network that skips the
   // transformer stack). Kill-switch SWITCHROOM_EDIT_FUSE=0; see edit-flood-fuse.ts.

package/telegram-plugin/gateway/inbound-router.ts

@@ -35,6 +35,7 @@ import {
 } from './inbound-interceptors.js'
 import type { InboundMessage } from './ipc-protocol.js'
 import { deriveTurnId } from './derive-turn-id.js'
+import { extractRichMessageText } from './rich-message-handler.js'
 import { formatReplyToText } from '../steering.js'
 import { fmtLocalStamp, resolveEnvTimezone } from '../shared/local-time.js'
 import { safeResolvePersonName, type PersonDirectory } from './resolve-person.js'
@@ -160,10 +161,33 @@ export function buildReplyForwardContext(p: ReplyForwardContextParams): {
   // gateway runs when neither is present. Accessed defensively in case the
   // installed grammy/@grammyjs/types predate `TextQuote`.
   const quoteText = p.ctx.message?.quote?.text
+  // Rich-message parents (#4598). Every card the gateway posts goes out via
+  // Bot API 10.1 `sendRichMessage`, so a native reply to one delivers a
+  // `reply_to_message` whose body lives under `rich_message.blocks` with
+  // `text` / `caption` ABSENT. Reading only `.text ?? .caption` therefore
+  // yielded `undefined` for 100% of card parents and pushed every such reply
+  // onto the history-buffer fallback — which cannot help when no row was ever
+  // recorded (a send while the gateway was down, or one that bypassed the
+  // recording chokepoint).
+  //
+  // Measured on the wire, not inferred: a user reply to a `sendRichMessage`
+  // card yields `reply_to_message` keys
+  // `[message_id, from, chat, date, rich_message]`, `text`/`caption` absent,
+  // `rich_message.blocks` fully populated. The older "Telegram omits the
+  // parent body" comments on this path predate rich messages.
+  //
+  // Flattened by the SAME renderer the inbound rich-message handler and the
+  // outbound card observer use, so all three agree on what a card "says".
+  // Returns `undefined` (never `''`) for an unrenderable block tree, so
+  // `resolveReplyToFromBuffer`'s `liveTextEmpty` gate still falls through to
+  // the buffer instead of pinning an empty antecedent.
+  const richParentText = extractRichMessageText(
+    (replyToMsg as { rich_message?: unknown } | undefined)?.rich_message,
+  )
   const replyToTextRaw = (quoteText != null && quoteText.length > 0)
     ? quoteText
     : replyToMsg
-      ? (replyToMsg.text ?? replyToMsg.caption ?? undefined)
+      ? (replyToMsg.text ?? replyToMsg.caption ?? richParentText ?? undefined)
       : undefined
   const replyToText = replyToTextRaw != null
     ? (replyToTextRaw.length > p.replyToTextMax
@@ -198,8 +222,11 @@ export function buildReplyForwardContext(p: ReplyForwardContextParams): {
 export interface ReplyToBufferFallbackParams {
   /** From {@link buildReplyForwardContext}. */
   replyToMessageId: number | undefined
-  /** Raw reply text off the live update (for the SQLite write); empty when the
-   *  reply target is the bot's own message (Telegram omits its text). */
+  /** Raw reply text off the live update (for the SQLite write). Empty only
+   *  when the live update carried NO readable parent body at all — a plain
+   *  `sendMessage` parent (Telegram omits `.text` on the bot's own plain
+   *  messages), or a rich parent whose blocks render to nothing. A normal
+   *  card parent now arrives populated off `rich_message` (#4598). */
   replyToText: string | undefined
   /** XML-escaped reply text for the channel meta; empty in the same case. */
   replyToTextEscaped: string | undefined
@@ -219,21 +246,36 @@ export interface ReplyToBufferFallbackParams {
 }
 
 /**
- * Reply-to buffer fallback (post-reset continuity). On a native reply to the
- * BOT's OWN message, Telegram delivers `reply_to_message.message_id` but NOT
- * its `.text` — so the live reply text is empty even though the gateway
- * authored (and, via `recordOutbound`, persisted) that message. This recovers
- * the antecedent from the local history buffer so it survives a session reset
- * (`resume_mode: handoff`), where the transcript is gone.
+ * Reply-to buffer fallback (post-reset continuity). On a native reply to a
+ * PLAIN message the bot itself sent, Telegram delivers
+ * `reply_to_message.message_id` but NOT its `.text` — so the live reply text
+ * is empty even though the gateway authored (and, via `recordOutbound`,
+ * persisted) that message. This recovers the antecedent from the local history
+ * buffer so it survives a session reset (`resume_mode: handoff`), where the
+ * transcript is gone.
+ *
+ * Since #4598 this is the SECOND line of defence FOR THE TEXT, not the first:
+ * a reply to a RICH parent (every card) now carries its body on
+ * `reply_to_message.rich_message` and is resolved live in
+ * {@link buildReplyForwardContext}, so a live-resolved body is never
+ * overwritten from the buffer.
+ *
+ * The LOOKUP itself, however, still runs on every reply while history is on.
+ * `replyToRole` and `replyToKind` have no live-update source at all, so
+ * skipping the lookup whenever the live text resolved would strip
+ * `reply_to_role` / `reply_to_kind` from precisely the recorded-card replies
+ * the #4571 kind lane was built for.
  *
  * Returns updated `replyToText` (raw, for the SQLite `recordInbound` write —
  * envelope-only would leave the row NULL and starve future handoff briefings),
  * `replyToTextEscaped` (for the channel-meta `reply_to_text`), and the
  * recovered `replyToRole` ('assistant' = the bot's own message, disambiguating
  * the "you're replying to yourself" case). Pure except for the injected
- * `lookup`. Only fills in when the live reply text is empty — never overwrites
- * a non-empty live value (a partial-quote or a reply to a person's message).
- * Degrades silently to the id-only inputs on any lookup failure.
+ * `lookup`. Only fills in the TEXT when the live reply text is empty — never
+ * overwrites a non-empty live value (a partial-quote, a reply to a person's
+ * message, or a live-rendered rich parent). Role and kind are filled in from
+ * any buffer hit regardless. Degrades silently to the id-only inputs on any
+ * lookup failure.
  */
 export function resolveReplyToFromBuffer(p: ReplyToBufferFallbackParams): {
   replyToText: string | undefined
@@ -248,23 +290,32 @@ export function resolveReplyToFromBuffer(p: ReplyToBufferFallbackParams): {
   let replyToRole: 'user' | 'assistant' | 'system' | undefined
   let replyToKind: string | undefined
   const liveTextEmpty = replyToTextEscaped == null || replyToTextEscaped.length === 0
-  if (p.historyEnabled && p.replyToMessageId != null && liveTextEmpty) {
+  if (p.historyEnabled && p.replyToMessageId != null) {
     try {
       const recovered = p.lookup(p.replyToMessageId)
-      if (recovered != null && recovered.role === 'system' && recovered.kind) {
-        replyToKind = recovered.kind
-      }
-      if (recovered && recovered.text.length > 0) {
-        replyToText =
-          recovered.text.length > p.replyToTextMax
-            ? recovered.text.slice(0, p.replyToTextMax - 1) + '…'
-            : recovered.text
-        replyToTextEscaped = formatReplyToText(recovered.text, p.replyToTextMax)
-        replyToRole = recovered.role
-      } else if (recovered) {
-        // Row exists (authorship known) but text is empty/redacted — still
-        // surface the role so the model knows whose message it is replying to.
+      if (recovered != null) {
+        // Role and kind are produced ONLY here — there is no live-update
+        // source for either. So the lookup runs on EVERY reply, not just the
+        // ones whose text the live update failed to carry: gating it on
+        // `liveTextEmpty` would mean a full reply to a recorded card resolved
+        // its body live (#4598) and silently lost `reply_to_role="system"` +
+        // `reply_to_kind` (#4571) — exactly the case the kind lane exists for,
+        // and the thing #4599 goes to AsyncLocalStorage lengths to record.
+        // Costs one SQLite point-read per reply.
         replyToRole = recovered.role
+        if (recovered.role === 'system' && recovered.kind) {
+          replyToKind = recovered.kind
+        }
+        // The TEXT is still second line of defence: never overwrite a
+        // non-empty live value (a partial quote, a person's message, or a
+        // rich parent rendered off the wire).
+        if (liveTextEmpty && recovered.text.length > 0) {
+          replyToText =
+            recovered.text.length > p.replyToTextMax
+              ? recovered.text.slice(0, p.replyToTextMax - 1) + '…'
+              : recovered.text
+          replyToTextEscaped = formatReplyToText(recovered.text, p.replyToTextMax)
+        }
       }
     } catch {
       // History disabled mid-run / requireDb throws / row missing — degrade

package/telegram-plugin/gateway/system-message-observer.ts

@@ -24,10 +24,29 @@
  * Rather than add a `recordSystemOutbound(...)` call to each of the ~110 raw
  * send sites (which is exactly the kind of per-call-site discipline that
  * decays — the `reply` path was the only site anyone remembered), this hooks
- * the ONE chokepoint every gateway outbound already goes through:
- * `gateway.ts`'s `robustApiCall` (chat-lock → send-gate → retry policy). Every
- * card send in the gateway is routed through it, enforced by the
- * `check-bot-api-wrapping` lint guard.
+ * ONE chokepoint and observes the resolved response there.
+ *
+ * WHICH chokepoint took two goes, and the first answer was wrong (#4599). This
+ * docblock used to say the hook sat on `gateway.ts`'s `robustApiCall` — "the
+ * ONE chokepoint every gateway outbound already goes through … enforced by the
+ * `check-bot-api-wrapping` lint guard". Both halves were false from the day it
+ * merged. grammY's `ctx.*` sugar builds the payload and calls `bot.api.*`
+ * itself, so `switchroomReply` — the helper every SLASH-COMMAND card answers
+ * through (`/usage`, `/model`, `/auth`, `/approvals`, `/start`, `/help`) — sends
+ * via `ctx.replyWithRichMessage` and never touches `robustApiCall`; and the
+ * lint guard could not have caught that, because its verb pattern matched only
+ * `(bot|lockedBot|ctx)\.api\.<verb>`, never mentioned `sendRichMessage`, and
+ * structurally cannot match a `ctx.replyWith*` call at all. Measured, not
+ * inferred: a live agent's `/usage` card at id 20938 left NO row while the
+ * `tg-post` transformer logged its `sendRichMessage` POST.
+ *
+ * The hook therefore lives at the grammy API TRANSFORMER layer
+ * (`installSystemMessageObserver` in `shared/bot-runtime.ts`), which grammy
+ * resolves immediately around the HTTP POST — below every helper, `ctx.*`
+ * shorthand, `lockedBot`, and `bot.api.raw`. No call shape reaches Telegram
+ * without passing through it, so no future verb can opt out the way
+ * `switchroomReply` silently did. `robustApiCall` still publishes its `verb`
+ * down to that layer (`withTgSendContext`) so cards keep their `kind`.
  *
  * The observer reads the Telegram RESPONSE, which buys three things for free:
  *   - the real `message_id` (the only thing a reply can point at),
@@ -90,7 +109,7 @@ export interface SentMessageLike {
   rich_message?: unknown
 }
 
-/** The subset of `robustApiCall`'s opts the observer reads. */
+/** The call-site metadata the observer reads (`bot-runtime.ts`'s `TgSendContext`). */
 export interface ObservedCallOpts {
   chat_id?: string
   threadId?: number
@@ -293,7 +312,7 @@ type TrackedState = { lane: 'system' | 'foreign'; lastStoredMs: number; storedLe
 
 /**
  * Build the observer. The returned function is called with the RESOLVED result
- * of every `robustApiCall` and never throws.
+ * of every outbound Bot API call (from the transformer layer) and never throws.
  */
 export function makeSystemMessageObserver(
   deps: SystemMessageObserverDeps,

package/telegram-plugin/shared/bot-runtime.ts

@@ -5,8 +5,10 @@
  * standalone foreman bot before its retirement.
  *
  * What lives here:
- *   - `installTgPostLogger` / `installRichMarkdownGuard` — the grammy API
- *     transformers every outbound call transits.
+ *   - `installTgPostLogger` / `installRichMarkdownGuard` /
+ *     `installSystemMessageObserver` — the grammy API transformers every
+ *     outbound call transits. This layer, not any caller-side wrapper, is the
+ *     one seam no `ctx.*` helper or raw `bot.api.*` call can bypass.
  *   - `makeSwitchroomExec` / `makeSwitchroomExecCombined` — factory fns for
  *     the switchroom CLI exec helpers (callers pass their own CLI path / config
  *     env so each process can be configured independently).
@@ -292,6 +294,121 @@ export function installRichMarkdownGuard(bot: Bot): void {
   })
 }
 
+// ─── outbound send observation (#4571 / #4599) ────────────────────────────
+
+/**
+ * The call-site metadata a send observer wants but the wire payload cannot
+ * supply. Structurally the same shape as `ObservedCallOpts` in
+ * `gateway/system-message-observer.ts`; declared here so this module keeps its
+ * no-imports-from-gateway rule.
+ */
+export interface TgSendContext {
+  chat_id?: string
+  threadId?: number
+  /** The caller's own label for what this send IS (`activity-summary.send`). */
+  verb?: string
+}
+
+const sendContextStore = new AsyncLocalStorage<TgSendContext | undefined>()
+
+/**
+ * Publish the enclosing call's `{chat_id, threadId, verb}` to the API
+ * transformer layer for the duration of `fn`'s async chain. `gateway.ts`'s
+ * `robustApiCall` wraps every call it issues; anything sent outside it (a
+ * `ctx.reply*` helper, a raw `bot.api.*`) simply observes with no verb.
+ */
+export function withTgSendContext<T>(ctx: TgSendContext | undefined, fn: () => T): T {
+  return sendContextStore.run(ctx, fn)
+}
+
+/** Exposed for the transformer (and tests). Undefined outside a wrapped call. */
+export function _getTgSendContext(): TgSendContext | undefined {
+  return sendContextStore.getStore()
+}
+
+/**
+ * Install the card-history send observer as a grammy API TRANSFORMER — the
+ * real universal outbound seam (#4599).
+ *
+ * #4571 hooked the observer onto `gateway.ts`'s `robustApiCall`, and
+ * `system-message-observer.ts` claimed that was "the ONE chokepoint every
+ * gateway outbound already goes through … enforced by the
+ * `check-bot-api-wrapping` lint guard". That claim was false on both halves.
+ * grammY's `ctx.*` sugar builds the payload and calls `bot.api.*` directly, so
+ * `switchroomReply` (`gateway.ts`, the helper every SLASH-COMMAND card answers
+ * through — `/usage`, `/model`, `/auth`, `/approvals`, `/start`, `/help`) sends
+ * via `ctx.replyWithRichMessage` and never transits `robustApiCall` at all; and
+ * the lint guard could not have caught it, because its verb pattern matched
+ * only `(bot|lockedBot|ctx)\.api\.<verb>` — it never mentioned `sendRichMessage`
+ * and structurally cannot match a `ctx.replyWith*` helper.
+ *
+ * Measured, not inferred: on a live agent's buffer the `/usage` card at id
+ * 20938 left NO row, while the `tg-post` transformer in this very file logged
+ * its `sendRichMessage` POST. The transformer layer SAW the send the recorder
+ * missed. That is the whole argument for moving here: grammy resolves this
+ * chain immediately around the HTTP POST, below every helper, every `ctx.*`
+ * shorthand, `lockedBot`, and `bot.api.raw` — there is no call shape that
+ * reaches Telegram without passing through it, so no future verb can silently
+ * opt out the way `switchroomReply` did.
+ *
+ * `observe` is injected rather than imported: this module must not depend on
+ * anything under `gateway/` (see the file header). The caller keeps ownership
+ * of the history writers, the `isGatewayMain && HISTORY_ENABLED` gate, and the
+ * empty-body alarm.
+ *
+ * Only a RESOLVED, `ok:true` response is observed. grammy hands this chain the
+ * raw `ApiResponse` and converts `{ok:false}` into a thrown `GrammyError` only
+ * after the chain returns (see `installTgPostLogger`'s docblock), so a
+ * rejection arrives here as a resolved body and must be skipped — recording a
+ * Telegram error object as a card body is exactly the empty-row failure #4576
+ * was. Non-message results (`getUpdates` arrays, `getMe`, `true` from
+ * `answerCallbackQuery`) are filtered by the observer's own shape test.
+ *
+ * Pure observation: the response is returned untouched and nothing here can
+ * throw into the send path.
+ */
+export function installSystemMessageObserver(
+  bot: Bot,
+  observe: (result: unknown, opts?: TgSendContext) => void,
+): void {
+  bot.api.config.use(async (prev, method, payload, signal) => {
+    const res = await prev(method, payload, signal)
+    try {
+      const r = res as unknown as { ok?: boolean; result?: unknown }
+      if (r != null && typeof r === 'object' && r.ok === true) {
+        observe(r.result, resolveSendContext(payload))
+      }
+    } catch {
+      /* observing a send must never break the send */
+    }
+    return res
+  })
+}
+
+/**
+ * Merge the caller-published context with what the outbound PAYLOAD itself
+ * carries. The context wins where both exist (it is the caller's own intent);
+ * the payload is what keeps an unwrapped `ctx.reply*` send attributable to a
+ * chat and topic at all. The response's own `chat.id` still outranks both
+ * downstream — this is only the fallback tier.
+ */
+function resolveSendContext(payload: unknown): TgSendContext | undefined {
+  const ctx = sendContextStore.getStore()
+  const p = (payload ?? {}) as Record<string, unknown>
+  const rawChat = p.chat_id
+  const chat_id =
+    ctx?.chat_id ??
+    (typeof rawChat === 'string' || typeof rawChat === 'number' ? String(rawChat) : undefined)
+  const rawThread = p.message_thread_id
+  const threadId = ctx?.threadId ?? (typeof rawThread === 'number' ? rawThread : undefined)
+  if (chat_id == null && threadId == null && ctx?.verb == null) return undefined
+  return {
+    ...(chat_id != null ? { chat_id } : {}),
+    ...(threadId != null ? { threadId } : {}),
+    ...(ctx?.verb != null ? { verb: ctx.verb } : {}),
+  }
+}
+
 // ─── robustApiCall factory: REMOVED (#3863) ───────────────────────────────
 //
 // `createRobustApiCall` used to live here as a second `createRetryApiCall`

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

@@ -49,8 +49,13 @@ import {
   type EnvelopeBuildParams,
 } from '../gateway/inbound-router.js'
 import { makeSystemMessageObserver } from '../gateway/system-message-observer.js'
-import { Bot } from 'grammy'
-import { installRichMarkdownGuard } from '../shared/bot-runtime.js'
+import { Bot, Context } from 'grammy'
+import {
+  installRichMarkdownGuard,
+  installSystemMessageObserver,
+  makeSwitchroomReply,
+  withTgSendContext,
+} from '../shared/bot-runtime.js'
 import { installSentTextCapture } from '../shared/sent-text-capture.js'
 import { richMessage } from '../rich-send.js'
 
@@ -317,6 +322,170 @@ describe('#4576: the stored card body is NOT empty — real sendRichMessage resp
   })
 })
 
+describe('#4599: the SLASH-COMMAND card path is recorded too', () => {
+  const BOT_INFO = {
+    id: 123456, is_bot: true as const, first_name: 'Test', username: 'test_bot',
+    can_join_groups: false, can_read_all_group_messages: false,
+    supports_inline_queries: false, can_connect_to_business: false,
+    has_main_web_app: false,
+  }
+
+  /**
+   * The gateway's REAL transformer stack with the observer installed exactly
+   * where gateway.ts installs it (after `installSentTextCapture`), transport
+   * stubbed to answer with the true `Message.RichMessageMessage` shape echoing
+   * the markdown that was actually POSTed.
+   *
+   * `editMessageText` re-uses the `message_id` in the payload, so an edit
+   * returns the id it edited — the shape the observer's send-vs-edit rule
+   * depends on.
+   */
+  function makeCardBot(observe: (result: unknown, opts?: { verb?: string }) => void) {
+    let nextId = 30_000
+    const posted: string[] = []
+    const fakeFetch = (async (_url: unknown, init: { body?: string } | undefined) => {
+      const payload = JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>
+      posted.push(String(payload.__method__ ?? ''))
+      const rich = payload.rich_message as { markdown?: unknown } | undefined
+      const id = typeof payload.message_id === 'number' ? payload.message_id : nextId++
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({
+          ok: true,
+          result: {
+            message_id: id,
+            date: 0,
+            chat: { id: Number(CHAT), type: 'private' },
+            ...(typeof rich?.markdown === 'string'
+              ? { rich_message: { blocks: [{ type: 'paragraph', text: { text: rich.markdown } }] } }
+              : { text: String(payload.text ?? '') }),
+          },
+        }),
+      } as unknown as Response
+    }) as unknown as typeof fetch
+
+    const bot = new Bot('123456:TEST_TOKEN', { botInfo: BOT_INFO, client: { fetch: fakeFetch } })
+    installRichMarkdownGuard(bot)
+    installSentTextCapture(bot)
+    installSystemMessageObserver(bot, observe)
+    return { bot, posted }
+  }
+
+  /** A grammy Context for an inbound `/usage`, as the command handler receives it. */
+  function makeCtx(bot: Bot): Context {
+    return new Context(
+      {
+        update_id: 1,
+        message: {
+          message_id: 20_930,
+          date: 0,
+          chat: { id: Number(CHAT), type: 'private' as const },
+          from: { id: 111, is_bot: false, first_name: 'Alice' },
+          text: '/usage',
+        },
+      } as never,
+      bot.api,
+      BOT_INFO,
+    )
+  }
+
+  it('a /usage card sent via switchroomReply leaves exactly one non-empty row', async () => {
+    // THE #4599 DEFECT, pinned. `switchroomReply` answers every slash command
+    // through `ctx.replyWithRichMessage`, which builds its own payload and calls
+    // `bot.api.*` directly — it never transits `robustApiCall`, where the #4571
+    // recorder was hooked. Measured on a live agent: the `/usage` card at id
+    // 20938 left no row, so a quote-reply to it resolved to nothing. A recorder
+    // that only sees `robustApiCall` cannot pass this test.
+    const observe = makeObserver()
+    const { bot } = makeCardBot(observe)
+    const switchroomReply = makeSwitchroomReply(() => undefined)
+    const BODY = 'Usage this week — Opus 41 percent, Sonnet 12 percent'
+
+    await switchroomReply(makeCtx(bot), BODY, { html: true })
+
+    const cards = query({ chat_id: CHAT, limit: 50, include_system: true }).filter(
+      (r) => r.role === 'system',
+    )
+    expect(cards).toHaveLength(1)
+    expect(cards[0]!.text).toBe(BODY)
+
+    // …and the quote-reply the operator actually makes now resolves.
+    const resolved = resolveReplyToFromBuffer({
+      replyToMessageId: cards[0]!.message_id,
+      replyToText: undefined,
+      replyToTextEscaped: undefined,
+      historyEnabled: true,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+      lookup: boundLookup,
+    })
+    expect(resolved.replyToRole).toBe('system')
+    expect(resolved.replyToText).toBe(BODY)
+  })
+
+  it('the PLAIN ctx.reply branch of switchroomReply is recorded as well', async () => {
+    const observe = makeObserver()
+    const { bot } = makeCardBot(observe)
+    const switchroomReply = makeSwitchroomReply(() => undefined)
+
+    await switchroomReply(makeCtx(bot), 'plain notice, no markdown', {})
+
+    const cards = query({ chat_id: CHAT, limit: 50, include_system: true }).filter(
+      (r) => r.role === 'system',
+    )
+    expect(cards).toHaveLength(1)
+    expect(cards[0]!.text).toBe('plain notice, no markdown')
+  })
+
+  it('a wrapped send keeps its verb → kind, and its edits do NOT add a second row', async () => {
+    // The behaviour the move must PRESERVE: `robustApiCall` publishes its verb
+    // through `withTgSendContext`, so the 117 live `role='system'` rows keep
+    // their `kind` (`activity-summary`, `worker-feed`, …) instead of degrading
+    // to null now that the recorder no longer sits on that wrapper.
+    let clock = 1_000
+    const observe = makeObserver(() => clock)
+    const { bot } = makeCardBot(observe)
+
+    const sent = await withTgSendContext({ chat_id: CHAT, verb: 'activity-summary.send' }, () =>
+      bot.api.sendRichMessage(Number(CHAT), richMessage('Working — 3 tools')),
+    )
+    const id = (sent as { message_id: number }).message_id
+
+    clock += 60_000
+    await withTgSendContext({ chat_id: CHAT, verb: 'activity-summary.edit' }, () =>
+      bot.api.editMessageText(Number(CHAT), id, richMessage('Working — 11 tools')),
+    )
+
+    const cards = query({ chat_id: CHAT, limit: 50, include_system: true }).filter(
+      (r) => r.role === 'system',
+    )
+    expect(cards).toHaveLength(1)
+    expect(cards[0]!.message_id).toBe(id)
+    expect(cards[0]!.kind).toBe('activity-summary')
+    expect(cards[0]!.text).toBe('Working — 11 tools')
+  })
+
+  it('a Telegram REJECTION is never recorded as a card', async () => {
+    // grammy resolves the transformer chain with the raw `{ok:false}` body and
+    // only throws afterwards, so a failed send reaches the observer as a
+    // RESOLVED response. Recording its error object would be #4576 all over.
+    const observe = makeObserver()
+    const failFetch = (async () =>
+      ({
+        ok: true,
+        status: 200,
+        json: async () => ({ ok: false, error_code: 400, description: 'chat not found' }),
+      }) as unknown as Response) as unknown as typeof fetch
+    const bot = new Bot('123456:TEST_TOKEN', { botInfo: BOT_INFO, client: { fetch: failFetch } })
+    installSystemMessageObserver(bot, observe)
+
+    await expect(
+      bot.api.sendRichMessage(Number(CHAT), richMessage('never lands')),
+    ).rejects.toThrow()
+    expect(query({ chat_id: CHAT, limit: 50, include_system: true })).toHaveLength(0)
+  })
+})
+
 describe('the card lane does not pollute normal history reads', () => {
   it('query() (get_recent_messages) lists the conversation, never the cards', () => {
     const observe = makeObserver()

package/telegram-plugin/tests/orphaned-db-sweep.test.ts

@@ -700,14 +700,22 @@ describe('startOrphanedDbSweep', () => {
     // Multiple ticks: proves the interval repeats, not just fires once.
     expect(lines.length).toBeGreaterThan(1)
 
-    stop()
-    // A tick is async, so one may be in flight when stop() lands. Let it settle
-    // before snapshotting — the property under test is "no NEW ticks start",
-    // not "no line is ever appended after the stop() call returns".
-    await sleep(60)
     const atStop = lines.length
-    await sleep(250)
-    // A stop() that did not clear the interval would add ~50 more lines here.
-    expect(lines.length).toBe(atStop)
+    stop()
+    // The property under test is "no NEW ticks start", not "no line is ever
+    // appended after stop() returns": the tick body is async, so one tick can
+    // already be in flight when stop() lands and will still emit its line.
+    //
+    // The sweep's own `running` guard means AT MOST ONE can be in flight, so
+    // the tolerance is exactly one line — assert that, rather than trying to
+    // out-wait the in-flight tick and then demanding exact equality. Every
+    // fixed settle window is a guess a loaded runner beats: 60ms flaked two of
+    // three consecutive merge-queue passes and a 40ms quiescence poll flaked
+    // again on the very next one (#4601), because a tick that has not yet
+    // resolved looks identical to quiescence.
+    await sleep(400)
+    // Not a weakening: an uncleared 5ms interval adds dozens of lines here, so
+    // this still fails hard on a stop() that does not clear the timer.
+    expect(lines.length - atStop).toBeLessThanOrEqual(1)
   })
 })

package/telegram-plugin/tests/reply-to-buffer-fallback.test.ts

@@ -25,6 +25,10 @@
  *     partial quote) over the full parent `.text`.
  *   - `buildInboundEnvelope` emits `reply_to_role` when known and `reply_to_text`
  *     from the recovered escaped form.
+ *   - `buildReplyForwardContext` reads a RICH parent's body off
+ *     `reply_to_message.rich_message` LIVE (#4598) — the only path that can
+ *     resolve a card the buffer never recorded. The last describe block pins
+ *     that, including a killer case a buffer-only implementation must fail.
  *
  * The persisted-row-non-NULL half of the 1a contract (which needs a real
  * bun:sqlite history.db) lives in reply-to-buffer-history.test.ts (bun).
@@ -98,20 +102,32 @@ describe('resolveReplyToFromBuffer — reply-to buffer fallback (1a)', () => {
   })
 
   it('does NOT overwrite a non-empty LIVE reply text (reply to a person, or a partial quote)', () => {
-    const lookup = () => {
-      throw new Error('lookup must not be called when live text is present')
-    }
     const out = resolveReplyToFromBuffer({
       replyToMessageId: 9,
       replyToText: 'live raw text',
       replyToTextEscaped: 'live escaped text',
       historyEnabled: true,
       replyToTextMax: REPLY_TO_TEXT_MAX,
-      lookup,
+      lookup: () => ({ role: 'user', text: 'STALE BUFFER TEXT' }),
     })
     expect(out.replyToText).toBe('live raw text')
     expect(out.replyToTextEscaped).toBe('live escaped text')
+    // …but the lookup still supplies the ROLE, which has no live-update source.
+    expect(out.replyToRole).toBe('user')
+  })
+
+  it('a missing row does not clobber a live reply text', () => {
+    const out = resolveReplyToFromBuffer({
+      replyToMessageId: 9,
+      replyToText: 'live raw text',
+      replyToTextEscaped: 'live escaped text',
+      historyEnabled: true,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+      lookup: () => null,
+    })
+    expect(out.replyToText).toBe('live raw text')
     expect(out.replyToRole).toBeUndefined()
+    expect(out.replyToKind).toBeUndefined()
   })
 
   it('history-disabled guard: never calls lookup, degrades to id-only, does not throw', () => {
@@ -208,6 +224,195 @@ describe('buildReplyForwardContext — native partial-quote preference (2a)', ()
   })
 })
 
+/**
+ * Rich-message parents (#4598).
+ *
+ * Every card the gateway posts ships via Bot API 10.1 `sendRichMessage`, so a
+ * native reply to one delivers a `reply_to_message` with `rich_message.blocks`
+ * populated and `text` / `caption` ABSENT. Measured on the wire against a real
+ * bot: keys `[message_id, from, chat, date, rich_message]`.
+ *
+ * Before #4598 the body of a card antecedent was 100% buffer-sourced, so a
+ * card that never made it into `history.db` — posted while the gateway was
+ * down, or through a send path that bypassed the recording chokepoint — was
+ * permanently unresolvable no matter how the recording side was fixed. These
+ * pin the LIVE read.
+ */
+describe('buildReplyForwardContext — rich_message parent (#4598)', () => {
+  /** The shape Telegram actually delivers for a reply to a card. */
+  function richParent(message_id: number) {
+    return {
+      message_id,
+      rich_message: {
+        blocks: [
+          { type: 'paragraph', text: [{ type: 'bold', text: 'Usage' }, ' this week'] },
+          { type: 'paragraph', text: 'Opus 41% then Sonnet 12%' },
+        ],
+      },
+    }
+  }
+
+  const RENDERED = 'Usage this week\nOpus 41% then Sonnet 12%'
+
+  it('reads the parent body off rich_message when text and caption are absent', () => {
+    const ctx = makeCtx({ reply_to_message: richParent(9938) })
+    const out = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    expect(out.replyToMessageId).toBe(9938)
+    expect(out.replyToText).toBe(RENDERED)
+    expect(out.replyToTextEscaped).toBe(RENDERED)
+  })
+
+  it('truncates a long rich body to the cap, like every other antecedent', () => {
+    const ctx = makeCtx({
+      reply_to_message: {
+        message_id: 1,
+        rich_message: { blocks: [{ type: 'paragraph', text: 'x'.repeat(400) }] },
+      },
+    })
+    const out = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    expect(out.replyToText).toHaveLength(REPLY_TO_TEXT_MAX)
+    expect(out.replyToText?.endsWith('…')).toBe(true)
+  })
+
+  it('yields undefined (not empty string) for an unrenderable block tree, so the buffer still runs', () => {
+    // A thinking-only / media-stripped card renders to nothing. It must fall
+    // THROUGH to the buffer rather than pinning the antecedent to ''.
+    const ctx = makeCtx({
+      reply_to_message: { message_id: 5, rich_message: { blocks: [{ type: 'thinking' }] } },
+    })
+    const live = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    expect(live.replyToText).toBeUndefined()
+    expect(live.replyToTextEscaped).toBeUndefined()
+
+    const out = resolveReplyToFromBuffer({
+      replyToMessageId: live.replyToMessageId,
+      replyToText: live.replyToText,
+      replyToTextEscaped: live.replyToTextEscaped,
+      historyEnabled: true,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+      lookup: () => ({ role: 'system', text: 'stored card body', kind: 'activity-summary' }),
+    })
+    expect(out.replyToText).toBe('stored card body')
+    expect(out.replyToKind).toBe('activity-summary')
+  })
+
+  it('prefers a native partial quote over the rich parent body', () => {
+    const ctx = makeCtx({
+      reply_to_message: richParent(7),
+      quote: { text: 'Opus 41%', position: 5, is_manual: true },
+    })
+    const out = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    expect(out.replyToText).toBe('Opus 41%')
+  })
+
+  it('THE BUFFER-ONLY KILLER: the live rich body wins over a DIFFERENT stored row', () => {
+    // A buffer-only implementation resolves this reply from the stored row and
+    // returns the STALE text — which is the point: this is the one test in the
+    // file that a recording-side-only fix cannot pass. The lookup DOES run
+    // (role/kind have no live source, see the next test) but it must not be
+    // allowed to win the text, so the stub deliberately returns a different
+    // body from the one on the wire.
+    const ctx = makeCtx({ reply_to_message: richParent(9925) })
+    const live = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+
+    let lookupCalls = 0
+    const out = resolveReplyToFromBuffer({
+      replyToMessageId: live.replyToMessageId,
+      replyToText: live.replyToText,
+      replyToTextEscaped: live.replyToTextEscaped,
+      historyEnabled: true,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+      lookup: () => {
+        lookupCalls++
+        return { role: 'system', text: 'STALE BUFFER TEXT', kind: 'usage-card' }
+      },
+    })
+
+    expect(out.replyToText).toBe(RENDERED)
+    expect(out.replyToTextEscaped).toBe(RENDERED)
+    expect(out.replyToText).not.toContain('STALE BUFFER TEXT')
+    // The row was consulted — for role/kind only, never for the body.
+    expect(lookupCalls).toBe(1)
+  })
+
+  it('a live-resolved rich body still carries reply_to_role AND reply_to_kind through the envelope', () => {
+    // The regression the `liveTextEmpty` gate introduced: an operator FULL-
+    // replies (no partial quote) to a live activity card whose row IS in
+    // history.db. The body now resolves live off `rich_message` — and if that
+    // short-circuits the lookup, the envelope loses `reply_to_role="system"`
+    // and `reply_to_kind="activity-summary"` entirely, killing the #4571 kind
+    // lane for exactly the case it was built for.
+    const ctx = makeCtx({ reply_to_message: richParent(9925) })
+    const live = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    const resolved = resolveReplyToFromBuffer({
+      replyToMessageId: live.replyToMessageId,
+      replyToText: live.replyToText,
+      replyToTextEscaped: live.replyToTextEscaped,
+      historyEnabled: true,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+      // The row IS recorded — same card, stored body.
+      lookup: () => ({ role: 'system', text: RENDERED, kind: 'activity-summary' }),
+    })
+    expect(resolved.replyToRole).toBe('system')
+    expect(resolved.replyToKind).toBe('activity-summary')
+
+    const msg = buildInboundEnvelope(
+      makeEnvelopeParams({
+        ctx,
+        replyToMessageId: live.replyToMessageId,
+        replyToTextEscaped: resolved.replyToTextEscaped,
+        replyToRole: resolved.replyToRole,
+        replyToKind: resolved.replyToKind,
+      }),
+    )
+    expect(msg.meta?.reply_to_text).toBe(RENDERED)
+    expect(msg.meta?.reply_to_role).toBe('system')
+    expect(msg.meta?.reply_to_kind).toBe('activity-summary')
+  })
+
+  it('carries the live rich body through to the inbound envelope', () => {
+    const ctx = makeCtx({ reply_to_message: richParent(9925) })
+    const live = buildReplyForwardContext({
+      ctx,
+      coalescedForwardOrigins: undefined,
+      replyToTextMax: REPLY_TO_TEXT_MAX,
+    })
+    const msg = buildInboundEnvelope(
+      makeEnvelopeParams({
+        ctx,
+        replyToMessageId: live.replyToMessageId,
+        replyToTextEscaped: live.replyToTextEscaped,
+      }),
+    )
+    expect(msg.meta?.reply_to_message_id).toBe('9925')
+    expect(msg.meta?.reply_to_text).toBe(RENDERED)
+  })
+})
+
 function makeEnvelopeParams(overrides: Partial<EnvelopeBuildParams>): EnvelopeBuildParams {
   return {
     ctx: makeCtx({}),

package/telegram-plugin/tests/system-message-observer.test.ts

@@ -1,7 +1,9 @@
 /**
  * system-message-observer — the card-lane recorder's pure behaviour (#4571).
  *
- * The observer hangs off gateway.ts's single `robustApiCall` chokepoint and
+ * The observer hangs off the grammy API transformer seam, installed at bot
+ * construction (#4599 moved it there from gateway.ts's `robustApiCall`, which
+ * the `ctx.replyWithRichMessage` slash-command path bypassed entirely), and
  * turns every card the gateway posts (activity summary, status pin, approval /
  * boot / issues cards, progress lines) into ONE resolvable history row. The
  * two properties that make it safe to run on the hot send path are asserted
@@ -12,12 +14,20 @@
  *   2. an id that turns out to belong to a real reply / inbound is demoted to
  *      `foreign` and never written to again.
  *
+ * Both install the observer in their OWN harness bot, so a third block at the
+ * bottom of this file pins the single PRODUCTION install line in
+ * `initGatewayBot()` — see its docblock.
+ *
  * The end-to-end proof (card posted → id resolvable → a reply pointing at it
  * is understood) needs a real bun:sqlite history.db and lives in
  * card-history-lane.test.ts (bun).
  */
 
 import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+import ts from 'typescript'
 import {
   makeSystemMessageObserver,
   normalizeSendVerb,
@@ -223,3 +233,76 @@ describe('makeSystemMessageObserver', () => {
     expect(store.rows.get(1)?.text).toBe('card 1 edited')
   })
 })
+
+/**
+ * Boot-wiring pin (#4599).
+ *
+ * Every behaviour test above installs the observer in its OWN harness, so
+ * deleting the single production install line in `initGatewayBot()` leaves all
+ * of them green while ALL card recording silently vanishes — worse than
+ * pre-#4571, because the old `robustApiCall` hook is gone and the empty-body
+ * alarm now lives INSIDE the observer, so nothing would fire either. Grammy's
+ * installed transformers are anonymous fns with nothing to grip at runtime, so
+ * this is a source-level AST assertion on the boot path — the same approach
+ * `format-guard-pins.test.ts` uses for `installRichMarkdownGuard`.
+ */
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_PATH = resolve(__dirname, '..', 'gateway', 'gateway.ts')
+const GATEWAY_SRC = readFileSync(GATEWAY_PATH, 'utf8')
+const gatewaySource = ts.createSourceFile(
+  GATEWAY_PATH,
+  GATEWAY_SRC,
+  ts.ScriptTarget.Latest,
+  true,
+  ts.ScriptKind.TS,
+)
+
+function findFunction(name: string): ts.FunctionDeclaration | undefined {
+  for (const s of gatewaySource.statements) {
+    if (ts.isFunctionDeclaration(s) && s.name?.text === name) return s
+  }
+  return undefined
+}
+
+function countCallsTo(root: ts.Node, name: string): number {
+  let count = 0
+  const visit = (node: ts.Node): void => {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === name
+    ) {
+      count++
+      // Installed on the constructed bot instance, with the real observer.
+      expect(node.arguments[0]?.getText(gatewaySource)).toBe('bot')
+      expect(node.arguments[1]?.getText(gatewaySource)).toBe('observeSentMessage')
+    }
+    ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return count
+}
+
+describe('boot wiring: installSystemMessageObserver is installed on the production Bot', () => {
+  it('imports installSystemMessageObserver from ../shared/bot-runtime.js', () => {
+    // The import must exist for the boot call to resolve; a refactor that drops
+    // the import would break the seam.
+    expect(GATEWAY_SRC).toMatch(
+      /import\s*\{[^}]*\binstallSystemMessageObserver\b[^}]*\}\s*from\s*'\.\.\/shared\/bot-runtime\.js'/,
+    )
+  })
+
+  it('calls installSystemMessageObserver(bot, observeSentMessage) exactly once inside initGatewayBot()', () => {
+    const fn = findFunction('initGatewayBot')
+    expect(fn?.body).toBeDefined()
+    expect(countCallsTo(fn!.body!, 'installSystemMessageObserver')).toBe(1)
+  })
+
+  it('builds the production observer from the real history writers', () => {
+    // The install is conditional on `observeSentMessage`; pin what fills it, or
+    // the line above could survive against a permanently-undefined observer.
+    expect(GATEWAY_SRC).toMatch(
+      /const observeSentMessage = isGatewayMain && HISTORY_ENABLED\s*\n?\s*\?\s*makeSystemMessageObserver\(/,
+    )
+  })
+})