switchroom 0.19.41 → 0.19.43

package/telegram-plugin/gateway/ipc-server.ts

@@ -152,12 +152,14 @@ export interface IpcServerOptions {
   ) => Promise<void>;
   /**
    * #2726 Part 2 — hostd asks the gateway to EDIT a previously-posted rollout
-   * status message as later phases arrive. Best-effort, no reply. Optional.
+   * status message as later phases arrive. Optional. #4065: the handler replies
+   * with a `rollout_status_edited` outcome so hostd can tell an applied edit
+   * from an edit into a deleted card; the roll never blocks on that reply.
    */
   onRolloutStatusEdit?: (
     client: IpcClient,
     msg: RolloutStatusEditMessage,
-  ) => void;
+  ) => void | Promise<void>;
   log?: (msg: string) => void;
   /**
    * How long (in ms) to wait without a heartbeat before force-closing the
@@ -813,14 +815,21 @@ export function createIpcServer(options: IpcServerOptions): IpcServer {
       case "rollout_status_edit":
         if (onRolloutStatusEdit) {
           try {
-            onRolloutStatusEdit(client, msg as RolloutStatusEditMessage);
+            void Promise.resolve(
+              onRolloutStatusEdit(client, msg as RolloutStatusEditMessage),
+            ).catch((err) => {
+              log(
+                `rollout_status_edit handler rejected (client=${client.id}): ${(err as Error).message}`,
+              );
+            });
           } catch (err) {
             log(
               `rollout_status_edit handler threw (client=${client.id}): ${(err as Error).message}`,
             );
           }
         }
-        // Fire-and-forget; no reply.
+        // The handler replies `rollout_status_edited` (#4065) when it can; an
+        // unwired gateway sends nothing and hostd's bounded wait expires.
         break;
       case "update_placeholder":
         // Legacy recall.py IPC — placeholder UX was removed in #553 PR 5.

package/telegram-plugin/gateway/liveness-wiring.ts

@@ -62,6 +62,7 @@ export function buildSilencePokeOptions(deps: LivenessWiringDeps): Parameters<ty
     endCurrentTurnForKey,
     getPendingInboundBuffer,
     trackRedeliveredInbound,
+    drainParkedTurnStarts,
     closeActivityLane,
     closeProgressLane,
     hangRestart,
@@ -593,6 +594,16 @@ export function buildSilencePokeOptions(deps: LivenessWiringDeps): Parameters<ty
       getInboundSpool(),
       trackRedeliveredInbound,
     )
+    // Two-state desync unwedge. `pendingInboundBuffer` (above) is NOT where a
+    // wedge-behind-a-dead-lock message sits: an already-`enqueue`d message lives
+    // in stream-render's `parkedTurnStarts`, and the busy park gate stays latched
+    // while that store is non-empty. A hung REPL never emits the `dequeue`/
+    // `remove` that drain it, so drain it HERE, scoped to the wedged chat/thread,
+    // routing each envelope back through the real `dequeue` turn-start path. The
+    // count joins the `drained_buffered` field below so the log stops reading a
+    // misleading `0/0` while real user messages were stranded. Guarded getter:
+    // absent (older deps) → 0, so the fallback degrades to its prior behaviour.
+    const fbDrainedParked = drainParkedTurnStarts?.(fbChatId, fbThreadId ?? null) ?? 0
     process.stderr.write(
       `telegram gateway: silence-poke framework-fallback ended wedged turn ` +
       `chat=${fbChatId} thread=${ctx.threadId ?? '-'} silence_ms=${ctx.silenceMs} ` +
@@ -601,6 +612,7 @@ export function buildSilencePokeOptions(deps: LivenessWiringDeps): Parameters<ty
       // keyed liveness check skipped the teardown, so the field lied.
       `currentTurn_nulled=${tearsDownLiveTurn} ` +
       `drained_buffered=${fbRedeliver.redelivered}/${fbRedeliver.drained}` +
+      `${fbDrainedParked > 0 ? ` drained_parked=${fbDrainedParked}` : ''}` +
       `${fbRedeliver.rebuffered > 0 ? ` rebuffered=${fbRedeliver.rebuffered}` : ''}` +
       `${fbExtraPurge.purged.length > 0 ? ` extra_keys_purged=${fbExtraPurge.purged.length}` : ''}\n`,
     )

package/telegram-plugin/gateway/model-command.ts

@@ -34,6 +34,27 @@ import {
   type ModelPickerOption,
 } from '../../src/agents/model-picker.js'
 import { assessThinkingEffortRisk } from '../../src/config/thinking-effort-risk.js'
+// The model-alias tables + expansion helpers live in the shared
+// `src/agents/model-aliases.ts` module so the gateway `/model` path and
+// scaffold-time config-default resolution expand from ONE table (#3998).
+// Imported for this module's internal use and re-exported below to preserve the
+// existing `model-command.js` public API (every importer keeps its entrypoint).
+import {
+  CLAUDE_MODEL_ALIASES,
+  SR_MODEL_ALIASES,
+  expandClaudeAlias,
+  expandSrAlias,
+  canonicalModelToken,
+  expandModelAlias,
+} from '../../src/agents/model-aliases.js'
+export {
+  CLAUDE_MODEL_ALIASES,
+  SR_MODEL_ALIASES,
+  expandClaudeAlias,
+  expandSrAlias,
+  canonicalModelToken,
+  expandModelAlias,
+}
 
 /**
  * Aliases the claude CLI resolves natively (`claude --help`: "an alias for
@@ -51,34 +72,6 @@ import { assessThinkingEffortRisk } from '../../src/config/thinking-effort-risk.
  */
 export const MODEL_ALIASES = ['opus', 'sonnet', 'haiku', 'fable', 'default'] as const
 
-/**
- * Short SWITCHROOM-side spellings for pinned **Anthropic** model ids. These are
- * expanded to the full `claude-*` id on the `/model` path BEFORE any
- * Claude-vs-external classification runs, so what reaches the `.session-model`
- * carrier (and therefore `claude --model`) is always the canonical id — the CLI
- * never sees the short spelling.
- *
- * Deliberately NOT `SR_MODEL_ALIASES`: that map means "external / OpenRouter /
- * the Anthropic OAuth header is NOT forwarded". These targets are Anthropic
- * OAuth-passthrough models, so putting them there would flip the
- * header-forwarding + external-billing classification and surface them under the
- * "🌐 External models" keyboard page with an `srFriendlyLabel`.
- *
- * Also NOT `MODEL_ALIASES`: that list is the aliases the claude CLI resolves
- * *itself*, and its members double as FAMILY tokens in `modelFamilyToken` /
- * `canonicalClaudeToken` / `servedModelMatchesRequested`. A pinned-id shortcut
- * is neither.
- *
- * NB the repo prefers family aliases over pinned ids (an alias tracks the
- * current flagship, a pinned id goes stale) — these exist because an operator
- * sometimes wants a specific pinned Opus, and typing `claude-opus-4-8` on a
- * phone is hostile. Keys are matched case-insensitively.
- */
-export const CLAUDE_MODEL_ALIASES: Record<string, string> = {
-  opus48: 'claude-opus-4-8',
-  'opus-4-8': 'claude-opus-4-8',
-}
-
 /**
  * Shape gate for the model argument. This string is typed literally
  * into the agent's tmux pane, so the gate is strict by construction:
@@ -1166,35 +1159,6 @@ export const SR_MODEL_LABELS: Record<string, string> = {
   'sr-gpt-5.6-luna': 'GPT-5.6 Luna',
 }
 
-/**
- * Short text-command aliases for sr-* models. These let the operator type
- * `/model flash`, `/model codex`, etc. instead of the full `sr-*` id.
- * Expanded in handleModelCommand before injection; the full sr-* id is what
- * reaches the agent session and LiteLLM.
- */
-export const SR_MODEL_ALIASES: Record<string, string> = {
-  flash: 'sr-gemini-2.5-flash',
-  gemini: 'sr-gemini-2.5-pro',
-  deepseek: 'sr-deepseek-v3',
-  r1: 'sr-deepseek-r1',
-  glm: 'sr-glm-5',
-  codex: 'sr-codex-5.5',
-  // Flagship keyboard buttons for the three providers added 2026-07-19. Each
-  // points at that provider's top tier; the cheaper tiers (grok-4.3,
-  // kimi-k2.7-code, gpt-5.6-terra/luna) stay typeable via `/model sr-<id>` and
-  // keep a friendly label above, matching the "labels are a superset of buttons"
-  // design (SR_MODEL_LABELS doc comment).
-  grok: 'sr-grok-4.5',
-  kimi: 'sr-kimi-k3',
-  gpt: 'sr-gpt-5.6-sol',
-  // Per-tier buttons for the GPT-5.6 line so each is a one-word shortcut
-  // (`gpt` stays the flagship-Sol default). Added 2026-07-19.
-  sol: 'sr-gpt-5.6-sol',
-  terra: 'sr-gpt-5.6-terra',
-  luna: 'sr-gpt-5.6-luna',
-}
-
-/** Expand a short alias (case-insensitive) to its full sr-* id, or return the original. */
 /**
  * #3042 review blocker 2a: can `token` be trusted for a boot-applied
  * `.session-model` carrier persist WITHOUT a live confirmation from claude?
@@ -1230,58 +1194,6 @@ export function isOfflineTrustedModelToken(token: string): boolean {
   return Object.values(CLAUDE_MODEL_ALIASES).includes(lower)
 }
 
-export function expandSrAlias(arg: string): string {
-  return SR_MODEL_ALIASES[arg.toLowerCase()] ?? arg
-}
-
-/**
- * The ONE canonical form of a model token — what `claude --model` is handed and
- * what every downstream gate compares against.
- *
- * Two normalizations, both narrow:
- *   - **trim** — unconditional. `unvalidatedIdCaveat` already trimmed while
- *     expansion did not, so the two disagreed on a padded token.
- *   - **lowercase, `claude-*` ONLY.** Every real Anthropic model id is lowercase
- *     and a phone autocapitalizes, so `/model Claude-Opus-4-8` used to be launched
- *     VERBATIM as an unvalidated id while the caveat exemption (which lowercases)
- *     suppressed the warning — a clean green ack for a token the caveat was
- *     written for. Non-`claude-` tokens are left alone: `sr-*` ids are matched
- *     case-insensitively by their own maps, and rewriting an arbitrary external
- *     id's case is not ours to do.
- *
- * Applied by `expandModelAlias`, so canonicalization happens on every `/model`
- * path (typed apply, mid-turn queue, menu tap, queued-across-restart persist)
- * whether or not the token hit a shortcut map — one canonical form flows to
- * `claude --model`, and `unvalidatedIdCaveat` sees exactly that form.
- */
-export function canonicalModelToken(arg: string): string {
-  const trimmed = arg.trim()
-  const lower = trimmed.toLowerCase()
-  return lower.startsWith('claude-') ? lower : trimmed
-}
-
-/** Expand a short pinned-Claude spelling (case-insensitive) to its full `claude-*` id. */
-export function expandClaudeAlias(arg: string): string {
-  return CLAUDE_MODEL_ALIASES[arg.trim().toLowerCase()] ?? arg
-}
-
-/**
- * The ONE expansion every `/model` argument goes through, on every path that
- * consumes a user-supplied token (typed apply, mid-turn queue, menu tap,
- * queued-across-restart persist). Claude shortcuts resolve first, then sr-*
- * shortcuts; the two key sets are disjoint by construction (a Claude shortcut
- * never expands to an `sr-*` id and vice versa), so order only documents intent.
- * The result is `canonicalModelToken`-normalized, so a miss can no longer emit a
- * verbatim mixed-case `claude-*` id that the caveat exemption then mis-matches.
- *
- * Expanding HERE — before `isClaudeModel` / `isSrModel` / `externalModelNames`
- * ever see the token — is what keeps a pinned-Claude shortcut on the Anthropic
- * OAuth passthrough instead of being misread as an external route.
- */
-export function expandModelAlias(arg: string): string {
-  return canonicalModelToken(expandSrAlias(expandClaudeAlias(arg)))
-}
-
 export function srFriendlyLabel(srName: string): string {
   return SR_MODEL_LABELS[srName] ?? srName.replace(/^sr-/, '').replace(/-/g, ' ')
 }

package/telegram-plugin/gateway/obligation-store.ts

@@ -43,6 +43,11 @@ export interface ObligationStoreFsSeam {
    *  entry lives in the parent's own cached metadata and is otherwise lost
    *  in a power cut. */
   fsyncDirSync: (path: string) => void
+  /** #4146: remove a snapshot this process will not maintain. Optional so any
+   *  existing seam (tests, other callers) keeps compiling and keeps working —
+   *  an absent `unlinkSync` degrades to "no cleanup", which is what those
+   *  callers do today. */
+  unlinkSync?: (path: string) => void
 }
 
 interface SnapshotEnvelope {
@@ -126,6 +131,56 @@ export function loadObligations(path: string, fs: ObligationStoreFsSeam): Obliga
   return env.obligations.filter(isObligationRow).map(sanitizeCapturedDelivery)
 }
 
+/**
+ * #4146 — drop a snapshot this process is NOT going to maintain.
+ *
+ * When the gateway is STATIC or `SWITCHROOM_OBLIGATION_LEDGER=0`, the ledger's
+ * `onChange` persister is never wired, so obligations open and close purely in
+ * memory while any previously-written `obligations.json` sits on disk
+ * unchanged. That leftover is not harmless: the W1-d audience classifier
+ * (`hooks/audience-classify.mjs`) reads this exact file to decide whether
+ * anyone is waiting on a chat, and an empty-but-stale open set reads there as
+ * POSITIVE evidence that nobody is — which is the one input that can make the
+ * classifier suppress a message owed to a human.
+ *
+ * Removing the file restores that classifier's stated invariant ("absent ⇒
+ * unknown ⇒ deliver") deterministically, with no freshness heuristic and no
+ * clock. Note this is safe precisely because the snapshot has exactly one
+ * writer: with the ledger ON, a merely-stopped gateway leaves a snapshot that
+ * is accurate rather than stale, so nothing is lost by only cleaning up in the
+ * modes where persistence is disabled.
+ *
+ * Best-effort and never throws — a failure degrades to the reader-side
+ * ledger-off guard in the hook.
+ *
+ * @returns `true` iff a file was actually removed.
+ */
+export function removeUnmaintainedSnapshot(
+  path: string,
+  fs: ObligationStoreFsSeam,
+  reason = 'persistence disabled',
+  log: (line: string) => void = (l) => process.stderr.write(l),
+): boolean {
+  const unlink = fs.unlinkSync
+  if (unlink == null) return false
+  try {
+    if (!fs.existsSync(path)) return false
+    unlink(path)
+    log(
+      `obligation-store: persistence is off (${reason}) — removed unmaintained ` +
+        `snapshot path=${path} so it cannot be read as "nobody is waiting" (#4146)\n`,
+    )
+    return true
+  } catch (err) {
+    log(
+      `obligation-store: could not remove unmaintained snapshot path=${path}: ` +
+        `${(err as Error).message} — audience classification falls back to the ` +
+        `reader-side ledger-off guard (#4146)\n`,
+    )
+    return false
+  }
+}
+
 /**
  * Persist the open set atomically (write sibling tmp → rename over the real
  * path). Best-effort relative to fs availability: a write failure is logged but

package/telegram-plugin/gateway/outbound-send-path.ts

@@ -29,6 +29,7 @@ import {
   stripExcessBold,
   addParagraphSpacers,
   splitMarkdownChunks,
+  splitPlainTextToCap,
   hardSliceToCap,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
@@ -36,6 +37,12 @@ import { scrubVoice } from '../text-voice-scrub.js'
 import { normalizeTemporal } from '../temporal-normalize.js'
 import { resolveEnvTimezone } from '../shared/local-time.js'
 import { isMessageTooLongError, isHtmlParseRejectError } from '../retry-api-call.js'
+import {
+  buildReplyParameters,
+  dropQuoteFromSendOpts,
+  isQuoteRejectionError,
+  sendOptsHaveQuote,
+} from '../reply-quote.js'
 
 // ── send-orchestration façade imports (#2996 P2) ──
 // Pure/deterministic helpers are imported; stateful or side-effecting gateway
@@ -52,6 +59,14 @@ import {
 } from '../format.js'
 import { richMessage } from '../rich-send.js'
 import { journalExternalDelivery } from './outbox-sweep.js'
+import { sha256Hex } from '../outbox.js'
+// #4141: the ONE shared framing implementation, also used by the outbox sweep
+// and (for the classifier half) the unbundled Stop hooks.
+import {
+  applyReplyThrowFraming,
+  formatReplyThrowFraming,
+  shouldFrameReplyThrow,
+} from '../hooks/audience-classify.mjs'
 import { queueFloodBlockedReply } from './flood-reply-queue.js'
 import { resolveChatIdFallback } from './chat-id-fallback.js'
 import { isFinalAnswerReply, isSubstantiveFinalReply, shouldJournalReplySiteDelivery } from '../final-answer-detect.js'
@@ -416,16 +431,58 @@ export async function sendReplyChunks(
     // rejects our markdown — better an unformatted answer than a
     // vanished one. The raw markdown source is itself readable prose, so
     // we send it verbatim rather than strip anything.
+    //
+    // #4043: chunks were split for the RICH cap (up to RICH_MESSAGE_MAX_CHARS =
+    // 32768), but this fallback ships them through the PLAIN `sendMessage`
+    // endpoint, which caps at 4096. Without a re-cap, the rescue send itself
+    // 400s with `message is too long` and the answer vanishes — the exact
+    // failure the fallback exists to prevent. Re-cap at safe boundaries first.
+    //
+    // Per-piece trailers: `opts` was built for ONE message, so shipping it
+    // verbatim to every piece duplicates the MESSAGE-scoped params.
+    //   - `reply_markup` (an inline keyboard) would render a LIVE button on
+    //     every piece. `single_use` only strips the keyboard from the message
+    //     that was tapped, so the user can fire the same action N times. It
+    //     rides the FINAL piece only — the same treatment the sweep's own
+    //     fallback applies (`outbox-sweep.ts` `sendChunkRich`/`withoutMarkup`),
+    //     and the same message the caller attached it to (the last chunk).
+    //   - `reply_parameters` would quote-reply from every piece. Only the
+    //     FIRST piece quotes, matching the caller's `replyMode !== 'all'`
+    //     rule that quotes chunk 0 only.
+    // Thread / link-preview / protect_content / disable_notification are
+    // per-message policy and correctly ride every piece, unchanged.
     const sendChunkPlainText = async (opts: Record<string, unknown>): Promise<void> => {
       const plain =
         chunks[i].length > 0
           ? chunks[i]
           : '⚠️ (a fragment could not be rendered for Telegram)'
-      const sent = await deps.sendLiteralRaw(opts, plain)
-      sentIds.push(sent.message_id)
-      deps.logOutbound('reply', chatId, sent.message_id, plain.length, `chunk=${i + 1}/${chunks.length} plaintext-fallback`)
+      const pieces = splitPlainTextToCap(plain)
+      const pieceOpts = (p: number): Record<string, unknown> => {
+        // Single piece ⇒ it is both first and final; pass `opts` through
+        // byte-identically so the non-split path stays exactly as it was.
+        if (pieces.length === 1) return opts
+        const o = { ...opts }
+        if (p !== pieces.length - 1) delete o.reply_markup
+        if (p !== 0) delete o.reply_parameters
+        return o
+      }
+      for (let p = 0; p < pieces.length; p++) {
+        const sent = await deps.sendLiteralRaw(pieceOpts(p), pieces[p])
+        sentIds.push(sent.message_id)
+        deps.logOutbound(
+          'reply',
+          chatId,
+          sent.message_id,
+          pieces[p].length,
+          pieces.length > 1
+            ? `chunk=${i + 1}/${chunks.length} plaintext-fallback piece=${p + 1}/${pieces.length}`
+            : `chunk=${i + 1}/${chunks.length} plaintext-fallback`,
+        )
+      }
       deps.stderr(
-        `telegram gateway: markdown parse-reject — resent chunk ${i + 1}/${chunks.length} as plain text\n`,
+        `telegram gateway: markdown parse-reject — resent chunk ${i + 1}/${chunks.length} as plain text` +
+          (pieces.length > 1 ? ` in ${pieces.length} piece(s) (4096-char plain cap)` : '') +
+          `\n`,
       )
     }
 
@@ -499,6 +556,20 @@ export async function sendReplyChunks(
           else if (isHtmlParseRejectError(retryErr)) await sendChunkPlainText(retryOpts)
           else throw retryErr
         }
+      } else if (isQuoteRejectionError(err) && sendOptsHaveQuote(sendOpts)) {
+        // Surgical-quote rejection: the quote must be an EXACT substring of the
+        // message being replied to, and Telegram 400s when it isn't found (a
+        // model paraphrase, a re-rendered fragment, an emoji/entity mismatch).
+        // That is a failure of the HIGHLIGHT, not of the answer — so drop the
+        // quote and land the reply as an ordinary reply to the same message,
+        // rather than throwing the composed answer away.
+        const retryOpts = dropQuoteFromSendOpts(sendOpts)
+        const sent = await sendChunk(retryOpts, false)
+        sentIds.push(sent.message_id)
+        deps.logOutbound('reply', chatId, sent.message_id, chunks[i].length, `chunk=${i + 1}/${chunks.length} quote-dropped`)
+        deps.stderr(
+          `telegram gateway: quote not found in the replied-to message — resent chunk ${i + 1}/${chunks.length} without the quote\n`,
+        )
       } else if (isMessageTooLongError(err)) {
         await sendChunkResplit(sendOpts)
       } else if (isHtmlParseRejectError(err)) {
@@ -1949,10 +2020,10 @@ export async function sendReply(
         return {
           ...(shouldReplyTo
             ? {
-                reply_parameters: {
-                  message_id: reply_to,
-                  ...(quoteText != null ? { quote: { text: quoteText, position: 0 } } : {}),
-                },
+                // `quote` is a Bot API String and `quote_position` a separate
+                // sibling Integer — see reply-quote.ts. Emitting an object here
+                // 400'd every quoted reply the fleet ever sent.
+                reply_parameters: buildReplyParameters(reply_to!, quoteText),
               }
             : {}),
           ...(tid != null ? { message_thread_id: tid } : {}),
@@ -2514,6 +2585,15 @@ export async function deliverCapturedProse(
   text: string
   /** Turn elapsed for the honest "(waited Ns)" apology clause; optional. */
   turnDurationMs?: number
+  /**
+   * #4141 — this turn's reply tool threw, so `text` is prose the model wrote
+   * AFTER its delivery attempt failed, not text it chose to send as the answer.
+   * When `true` the send is prefixed with a one-line provenance banner. This is
+   * the ELECTED-path counterpart of the outbox sweep's framing: on this path
+   * the Stop hook defers to the single-writer election and writes NO outbox
+   * record, so the sweep's framing can never reach the message.
+   */
+  replyToolThrewThisTurn?: boolean
   },
 ): Promise<void> {
   const {
@@ -2523,6 +2603,18 @@ export async function deliverCapturedProse(
   } = deps
   const { chatId, threadId, statusKeyStr, registryKey, originTurnId, text, turnDurationMs } = args
   const now = Date.now()
+  // #4141 — framing is a rendering concern, decided ONCE here and applied only
+  // to the bytes handed to Telegram. Everything keyed on identity (the dedup
+  // check + record below, and the journal's `textSha256`) deliberately keeps
+  // using the RAW `text`, so the label cannot change what counts as "the same
+  // answer" — a later reply-tool retry of the same prose still dedups, and the
+  // exactly-once-among-backstops journal key is unchanged. Same
+  // additive-by-construction property the sweep path has, re-established here
+  // because this path has its own send ladder and its own dedup.
+  const framed = shouldFrameReplyThrow(
+    { replyToolThrewThisTurn: args.replyToolThrewThisTurn },
+    { frameEnabled: process.env.SWITCHROOM_TG_OUTBOX_PROVENANCE_FRAMING !== '0' },
+  )
   // #3228 Finding 1 — the three settlement points (sent / skipped-dedup /
   // failed) all funnel through the pure `settleCapturedProseDelivery` core so
   // the failure posture is deterministic and unit-tested. `outcome` is set on
@@ -2530,7 +2622,7 @@ export async function deliverCapturedProse(
   let outcome: CapturedProseSendOutcome
   const already = outboundDedup.check(chatId, threadId, text, now, registryKey)
   if (already == null) {
-    let out = normalizeParagraphBreaks(repairEscapedWhitespace(text))
+    let out = normalizeParagraphBreaks(repairEscapedWhitespace(framed ? applyReplyThrowFraming(text) : text))
     out = redactOutboundText(out, 'captured_prose')
     const chunks = splitMarkdownChunks(out, RICH_MESSAGE_MAX_CHARS)
     const sentIds: number[] = []
@@ -2577,11 +2669,31 @@ export async function deliverCapturedProse(
       // journal line from this site following a reply-tool line under the same
       // nonce (replyAlreadyDeliveredThisTurn:true) is direct, journal-only
       // proof of a bridge double-send.
-      journalExternalDelivery({ turnNonce: originTurnId, text, tgMessageId: sentIds[sentIds.length - 1], replyAlreadyDeliveredThisTurn: false })
+      journalExternalDelivery({
+        turnNonce: originTurnId,
+        text,
+        tgMessageId: sentIds[sentIds.length - 1],
+        replyAlreadyDeliveredThisTurn: false,
+        // #4141 durable terminal stamp — parity with the sweep's
+        // `DeliveredEntry.framedProvenance`, so "was this labelled?" is
+        // answerable from the journal alone, hours later.
+        ...(framed ? { framedProvenance: 'reply-throw' as const } : {}),
+      })
       process.stderr.write(
         `telegram gateway: captured-prose delivery — sent ${out.length} chars recovered from ` +
           `transcript scan (chat=${chatId} origin=${originTurnId})\n`,
       )
+      if (framed) {
+        process.stderr.write(
+          formatReplyThrowFraming({
+            turnNonce: originTurnId,
+            turnId: originTurnId,
+            chatId,
+            textSha256: sha256Hex(text),
+            source: 'captured-prose-bridge',
+          }),
+        )
+      }
       outcome = 'sent'
     } catch (err) {
       // #3228 Finding 1 — the send threw, so the answer did NOT reach the user.
@@ -2660,7 +2772,11 @@ export async function deliverCapturedProse(
         `(chat=${chatId} origin=${originTurnId})\n`,
     )
     const plain = redactOutboundText(text, 'captured_prose')
-    const plainChunks = splitMarkdownChunks(plain, RICH_MESSAGE_MAX_CHARS)
+    // #4043: these pieces go through the PLAIN `sendMessage` endpoint (4096
+    // cap), not the rich one — splitting at RICH_MESSAGE_MAX_CHARS produced
+    // pieces Telegram rejects with `message is too long`, so a long recovered
+    // answer fell through to the generic apology and was lost.
+    const plainChunks = splitPlainTextToCap(plain)
     try {
       let liveThreadId: number | undefined = threadId
       const plainSentIds: number[] = []