switchroom 0.20.0 → 0.20.2

package/telegram-plugin/gateway/buzz-mirror.ts

@@ -24,6 +24,7 @@
  */
 
 import { randomUUID } from "crypto";
+import { join } from "path";
 import type { OutboundToBuzzMessage } from "./ipc-protocol.js";
 import {
   resolveRoute,
@@ -32,6 +33,10 @@ import {
   type BuzzCoords,
   type Channel,
 } from "./channel-route.js";
+import {
+  createCorrelationStore,
+  type CorrelationStore,
+} from "./buzz-mirror-correlation-store.js";
 
 export type BuzzPeerSender = (msg: OutboundToBuzzMessage) => boolean;
 
@@ -47,6 +52,14 @@ export interface BuzzMirrorConfig {
    * threaded replies still work (they carry their own channelId).
    */
   defaultChannelId: string;
+  /**
+   * Absolute path to the durable msg→Buzz correlation journal (#4222). When
+   * set, the `${chatId}:${messageId}` → published-event map is persisted and
+   * reloaded on construction, so an `edit_message` correction survives a gateway
+   * restart. Omit (dev/one-shot/tests) to keep the map in-memory only — same
+   * bound, no durability. See `buzz-mirror-correlation-store.ts`.
+   */
+  correlationJournalPath?: string;
   /** Optional log sink (defaults to a no-op). */
   log?: (msg: string) => void;
 }
@@ -68,6 +81,27 @@ export interface MirrorReplyInput {
    * the published Buzz event to correct.
    */
   telegramMessageKeys: string[];
+  /**
+   * `${chatId}:${messageId}` of the Telegram message this outbound answer is
+   * itself a reply to (its Telegram `reply_to` antecedent), when it has one.
+   * Used ONLY on the telegram-origin path to thread the mirrored Buzz event
+   * under the antecedent's previously-published Buzz event (NIP-10 outbound
+   * continuity). When the antecedent was never mirrored (e.g. it is a user's
+   * inbound message, or it aged past the correlation bound) the lookup misses
+   * and the mirror stays a flat top-level post — no wrong/guessed tag. Absent
+   * for a non-reply answer. Ignored on the buzz-origin path (that thread is
+   * bound by `ownerBuzzCoords`, not a Telegram antecedent).
+   */
+  antecedentTelegramMessageKey?: string;
+  /**
+   * True IFF `antecedentTelegramMessageKey` is the quote-opt-in DEFAULT — i.e.
+   * the caller had no explicit/model-supplied `reply_to` and defaulted it to the
+   * latest INBOUND user message (#4301). That message is never in the
+   * correlation store, so its lookup ALWAYS misses; distinguishing it lets the
+   * mirror log the expected flat fallback quietly with a distinct reason instead
+   * of as an "outbound thread MISS", so a genuine eviction miss stays visible.
+   */
+  antecedentIsQuoteOptInDefault?: boolean;
 }
 
 export interface MirrorCorrectionInput {
@@ -86,6 +120,14 @@ const MAX_TRACKED = 4096;
 interface PendingPublish {
   channelId: string;
   telegramMessageKeys: string[];
+  /**
+   * The NIP-10 thread root this in-flight event belongs to, when it threaded
+   * under a parent. Undefined for a fresh top-level post — in which case the
+   * event's OWN id (learned in `onPublishResult`) becomes the thread root. Stored
+   * so the correlation record carries the root a LATER reply's `root` marker
+   * needs.
+   */
+  threadRootId?: string;
 }
 
 class BuzzMirror {
@@ -97,9 +139,20 @@ class BuzzMirror {
   private readonly pending = new Map<string, PendingPublish>();
   private readonly pendingOrder: string[] = [];
 
-  /** `${chatId}:${messageId}` → the published Buzz event it maps to. */
-  private readonly msgToBuzz = new Map<string, { eventId: string; channelId: string }>();
-  private readonly msgOrder: string[] = [];
+  /**
+   * `${chatId}:${messageId}` → the published Buzz event it maps to. Durable
+   * (JSONL journal) when `correlationJournalPath` is configured, so a correction
+   * survives a gateway restart (#4222); the store enforces the same MAX_TRACKED
+   * FIFO bound in memory and on disk.
+   */
+  private readonly msgToBuzz: CorrelationStore;
+
+  /**
+   * Count of `mirrorCorrection` calls whose key was genuinely absent from the
+   * correlation store (never mirrored, or evicted past the bound) — surfaced for
+   * the loud-miss regression assertion, not just the log line.
+   */
+  private correctionMisses = 0;
 
   /** `${chatId}:${messageId}` → live correction debounce timer. */
   private readonly correctionTimers = new Map<string, ReturnType<typeof setTimeout>>();
@@ -107,6 +160,16 @@ class BuzzMirror {
   constructor(cfg: BuzzMirrorConfig) {
     this.cfg = cfg;
     this.log = cfg.log ?? (() => {});
+    this.msgToBuzz = createCorrelationStore({
+      journalPath: cfg.correlationJournalPath,
+      capacity: MAX_TRACKED,
+      log: this.log,
+    });
+  }
+
+  /** Test/introspection: number of corrections that missed the correlation store. */
+  getCorrectionMisses(): number {
+    return this.correctionMisses;
   }
 
   /** Register the transport to the duplex Buzz peer (ipcServer.sendToBuzzPeer). */
@@ -114,6 +177,13 @@ class BuzzMirror {
     this.sender = sender;
   }
 
+  /** Release the correlation journal fd and cancel any pending correction timers. */
+  close(): void {
+    for (const timer of this.correctionTimers.values()) clearTimeout(timer);
+    this.correctionTimers.clear();
+    this.msgToBuzz.close();
+  }
+
   private evict<T>(map: Map<string, T>, order: string[]): void {
     while (order.length > MAX_TRACKED) {
       const k = order.shift();
@@ -158,10 +228,61 @@ class BuzzMirror {
         replyToEventId = input.ownerBuzzCoords.eventId;
         threadRootId = input.ownerBuzzCoords.threadRoot;
       } else {
-        // TELEGRAM-origin → fresh top-level post to the configured channel. Not
-        // an owner-bound thread, so the S1 guard does not apply (design §3.3).
+        // TELEGRAM-origin → post to the configured channel. Not an owner-bound
+        // thread, so the S1 guard does not apply (design §3.3).
         if (!this.cfg.defaultChannelId) return; // no channel to post into
         channelId = this.cfg.defaultChannelId;
+
+        // NIP-10 OUTBOUND thread continuity: if this answer is itself a reply to
+        // a Telegram message that was ALREADY mirrored to Buzz, thread the new
+        // event under that antecedent's published event — a `reply` marker for
+        // the immediate parent and a `root` marker for the thread root — so a
+        // Telegram-origin reply chain renders threaded on the Buzz desktop
+        // instead of flat. The antecedent→event resolution reuses the SAME
+        // durable msg→event correlation store (#4280) the correction path uses;
+        // no new lookup surface. A MISS (antecedent never mirrored — e.g. it is
+        // the user's own inbound message — or evicted past MAX_TRACKED) leaves
+        // the post flat rather than emitting a wrong/guessed tag.
+        if (input.antecedentTelegramMessageKey) {
+          const parent = this.msgToBuzz.get(input.antecedentTelegramMessageKey);
+          if (parent && parent.channelId === channelId) {
+            replyToEventId = parent.eventId; // immediate parent → NIP-10 `reply`
+            // Thread root → NIP-10 `root`. Fall back to the parent's own id when
+            // the parent has no recorded root (it was itself top-level, or was
+            // journaled before threadRoot was tracked): then parent IS the root.
+            threadRootId = parent.threadRoot ?? parent.eventId;
+          } else if (parent) {
+            // #4299 CROSS-CHANNEL GUARD: the antecedent WAS mirrored, but into a
+            // DIFFERENT Buzz channel than this event's target (e.g. it was
+            // recorded via a buzz-origin threaded reply whose channelId came from
+            // the inbound event's own `h`-tag). This event publishes into
+            // `defaultChannelId`; threading it under a foreign-channel parent
+            // would carry e-tags that point into another group. Mirror FLAT
+            // instead — same fallback as a MISS, no cross-group e-tag.
+            this.log(
+              `buzz-mirror: outbound thread CROSS-CHANNEL — antecedent ` +
+                `${input.antecedentTelegramMessageKey} was mirrored into channel ` +
+                `${parent.channelId} != target ${channelId}; mirroring flat ` +
+                `(no cross-group e-tag)`,
+            );
+          } else if (input.antecedentIsQuoteOptInDefault) {
+            // #4301: quote-opt-in defaulted `reply_to` to the latest INBOUND user
+            // message, which is never in the correlation store — so this "miss"
+            // is EXPECTED, not an eviction. Log it quietly with a distinct reason
+            // (no "MISS") so genuine eviction misses stay visible in the logs.
+            this.log(
+              `buzz-mirror: outbound thread default-quote — antecedent ` +
+                `${input.antecedentTelegramMessageKey} is the latest inbound user ` +
+                `message (never mirrored); mirroring flat (expected, not an eviction)`,
+            );
+          } else {
+            this.log(
+              `buzz-mirror: outbound thread MISS — no Buzz correlation for ` +
+                `Telegram antecedent ${input.antecedentTelegramMessageKey}; ` +
+                `mirroring flat (never mirrored, or evicted past the bound)`,
+            );
+          }
+        }
       }
 
       this.publish(
@@ -187,7 +308,22 @@ class BuzzMirror {
   mirrorCorrection(input: MirrorCorrectionInput): void {
     try {
       const target = this.msgToBuzz.get(input.telegramMessageKey);
-      if (!target) return; // this Telegram message was never mirrored to Buzz
+      if (!target) {
+        // No mapping for this key — either it was genuinely never mirrored, or
+        // it aged out past MAX_TRACKED (memory AND journal). Either way the
+        // correction cannot land, so DON'T fail silently: emit a loud log and
+        // bump the miss counter so the gap is observable (#4222, audit "at
+        // minimum" ask). Pre-#4222 a restart also landed here (empty map) — the
+        // durable journal is what keeps that from being the common case.
+        this.correctionMisses++;
+        this.log(
+          `buzz-mirror: CORRECTION MISS — no Buzz correlation for Telegram ` +
+            `message ${input.telegramMessageKey}; the edit could NOT be mirrored ` +
+            `(never mirrored, or evicted past MAX_TRACKED=${MAX_TRACKED}). ` +
+            `Buzz copy may be stale. total_misses=${this.correctionMisses}`,
+        );
+        return;
+      }
 
       const existing = this.correctionTimers.get(input.telegramMessageKey);
       if (existing) clearTimeout(existing);
@@ -239,12 +375,17 @@ class BuzzMirror {
       return;
     }
     // Record the published event against each Telegram message it mirrored, so
-    // a later edit_message on any of them can target it for a correction.
+    // a later edit_message on any of them can target it for a correction AND a
+    // later reply whose antecedent is one of these messages can thread under it.
+    // The store persists (durable journal) + enforces the MAX_TRACKED FIFO bound.
+    //
+    // threadRoot: the root this event belongs to. If it threaded under a parent
+    // (`p.threadRootId` set) that parent's root IS this event's root; otherwise
+    // this is a fresh top-level post and its OWN id is the thread root.
+    const threadRoot = p.threadRootId ?? msg.eventId;
     for (const key of p.telegramMessageKeys) {
-      this.msgToBuzz.set(key, { eventId: msg.eventId, channelId: p.channelId });
-      this.msgOrder.push(key);
+      this.msgToBuzz.set(key, { eventId: msg.eventId, channelId: p.channelId, threadRoot });
     }
-    this.evict(this.msgToBuzz, this.msgOrder);
   }
 
   private publish(
@@ -270,6 +411,7 @@ class BuzzMirror {
     this.pending.set(correlationId, {
       channelId: fields.channelId,
       telegramMessageKeys,
+      threadRootId: fields.threadRootId,
     });
     this.pendingOrder.push(correlationId);
     this.evict(this.pending, this.pendingOrder);
@@ -285,6 +427,7 @@ let singleton: BuzzMirror | null = null;
  * every hook site is a no-op.
  */
 export function initBuzzMirror(cfg: BuzzMirrorConfig): BuzzMirror {
+  singleton?.close(); // release any prior instance's journal fd + timers
   singleton = new BuzzMirror(cfg);
   return singleton;
 }
@@ -293,6 +436,24 @@ export function getBuzzMirror(): BuzzMirror | null {
   return singleton;
 }
 
+/**
+ * Resolve the durable msg→Buzz correlation journal path from env (#4222). Lives
+ * under the same `$TELEGRAM_STATE_DIR/buzz/` dir as the sidecar's dedup journal
+ * but at a DISTINCT filename — a collision on `journal.jsonl` would corrupt
+ * both. `BUZZ_MIRROR_CORRELATION_PATH` overrides. When `TELEGRAM_STATE_DIR` is
+ * unset (dev/one-shot), returns undefined so the store degrades to in-memory
+ * only rather than scattering a journal under the home dir.
+ */
+export function resolveCorrelationJournalPath(
+  env: Record<string, string | undefined> = process.env,
+): string | undefined {
+  const override = env.BUZZ_MIRROR_CORRELATION_PATH?.trim();
+  if (override) return override;
+  const stateDir = env.TELEGRAM_STATE_DIR?.trim();
+  if (!stateDir) return undefined;
+  return join(stateDir, "buzz", "mirror-correlation.jsonl");
+}
+
 /**
  * Boot the hub mirror from env at gateway startup — the single wiring seam the
  * gateway calls. DARK BY DEFAULT and by construction: returns null (leaving
@@ -300,8 +461,10 @@ export function getBuzzMirror(): BuzzMirror | null {
  *   (1) `BUZZ_ENABLED` is truthy, AND
  *   (2) the S2-narrowed mode (`parseConfiguredMirrorMode`) is `both`;
  *       a configured `origin`/`off` degrades to dark, never a half-live mirror.
- * The Buzz env vars are UNSET everywhere in this branch (projection deferred),
- * so in practice this is inert. `sender` is the transport to the duplex peer
+ * The Buzz env vars are projected at compose time from `channels.buzz`
+ * (src/agents/compose.ts), with BUZZ_ENABLED=1 gated on `enabled === true`;
+ * an enabled:false/absent block leaves them unset, so for those agents this
+ * is inert by construction. `sender` is the transport to the duplex peer
  * (`ipcServer.sendToBuzzPeer`). Returns the booted instance for tests.
  */
 export function maybeBootBuzzMirror(
@@ -315,6 +478,7 @@ export function maybeBootBuzzMirror(
     mode,
     agentName: env.SWITCHROOM_AGENT_NAME?.trim() ?? "",
     defaultChannelId: env.BUZZ_CHANNEL_IDS?.trim() ?? "",
+    correlationJournalPath: resolveCorrelationJournalPath(env),
     log: (m) => process.stderr.write(`telegram gateway: buzz-mirror — ${m}\n`),
   });
   bm.attachSender(sender);
@@ -323,6 +487,7 @@ export function maybeBootBuzzMirror(
 
 /** Test-only: tear down the singleton so cases don't leak state into each other. */
 export function __resetBuzzMirrorForTests(): void {
+  singleton?.close();
   singleton = null;
 }
 

package/telegram-plugin/gateway/gateway.ts

@@ -127,6 +127,7 @@ import {
   routeInbound,
   admitInbound,
   buildReplyForwardContext,
+  resolveReplyToFromBuffer,
   buildInboundEnvelope,
   INBOUND_ROUTER_V2,
   runPreTurnIntercepts,
@@ -433,7 +434,7 @@ import { parseLitellmNoticeWindowMs } from '../litellm-local-notice.js'
 import { createLitellmLocalNoticeRunner, decideRateLimitedSurface } from './litellm-local-notice-wiring.js'
 import { runFleetAutoFallback, renderFallbackFailureNotice, evaluateFallbackFailureNotice, evaluateAllBlockedNotice, type FallbackFailureNoticeState, type FallbackAllBlockedNoticeState } from '../auto-fallback-fleet.js'
 import { startRestartWatchdog } from './restart-watchdog.js'
-import { validateStringArray } from './access-validator.js'
+import { createAccessStore } from './access-store.js'
 
 /**
  * Truncation cap for the `reply_to_text` channel-meta attribute (issue #119).
@@ -1536,10 +1537,6 @@ export type Access = {
   }
 }
 
-function defaultAccess(): Access {
-  return { dmPolicy: 'pairing', allowFrom: [], groups: {}, pending: {} }
-}
-
 // Rich-message wire cap (#2669): the rich path allows 32768 UTF-8 chars.
 const MAX_CHUNK_LIMIT = RICH_MESSAGE_MAX_CHARS
 const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024
@@ -1580,90 +1577,18 @@ function assertSendable(f: string): void {
   }
 }
 
-function readAccessFile(): Access {
-  try {
-    const raw = readFileSync(ACCESS_FILE, 'utf8')
-    const parsed = JSON.parse(raw) as Partial<Access>
-    const allowFrom = validateStringArray('allowFrom', parsed.allowFrom ?? [])
-    const groups: Record<string, GroupPolicy> = {}
-    for (const [chatId, policy] of Object.entries(parsed.groups ?? {})) {
-      groups[chatId] = {
-        ...policy,
-        allowFrom: validateStringArray(`groups.${chatId}.allowFrom`, policy.allowFrom ?? []),
-      }
-    }
-    return {
-      dmPolicy: parsed.dmPolicy ?? 'pairing',
-      allowFrom,
-      groups,
-      pending: parsed.pending ?? {},
-      mentionPatterns: parsed.mentionPatterns,
-      ackReaction: parsed.ackReaction,
-      replyToMode: parsed.replyToMode,
-      textChunkLimit: parsed.textChunkLimit,
-      chunkMode: parsed.chunkMode,
-      parseMode: parsed.parseMode,
-      disableLinkPreview: parsed.disableLinkPreview,
-      coalescingGapMs: parsed.coalescingGapMs,
-      litellmNoticeWindowMs: parsed.litellmNoticeWindowMs,
-      coalesceMaxAttachments: parsed.coalesceMaxAttachments,
-      interruptSafeBoundary: parsed.interruptSafeBoundary,
-      interruptMaxWaitMs: parsed.interruptMaxWaitMs,
-      statusReactions: parsed.statusReactions,
-      historyEnabled: parsed.historyEnabled,
-      historyRetentionDays: parsed.historyRetentionDays,
-      // #596: telegram features projected into access.json by scaffold.
-      // Without these passthroughs, gateway readers (`access.voice_in`,
-      // `access.telegraph`, `access.stickers`) silently see undefined.
-      stickers: parsed.stickers,
-      voice_in: parsed.voice_in,
-      voice_out: parsed.voice_out,
-      telegraph: parsed.telegraph,
-      // #789: button-choice-confirmation config projected by scaffold.
-      button_choice_confirmation: parsed.button_choice_confirmation,
-    }
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return defaultAccess()
-    try { renameSync(ACCESS_FILE, `${ACCESS_FILE}.corrupt-${Date.now()}`) } catch {}
-    process.stderr.write(`telegram gateway: access.json is corrupt, moved aside. Starting fresh.\n`)
-    return defaultAccess()
-  }
-}
-
-const BOOT_ACCESS: Access | null = STATIC
-  ? (() => {
-      const a = readAccessFile()
-      if (a.dmPolicy === 'pairing') {
-        process.stderr.write('telegram gateway: static mode — dmPolicy "pairing" downgraded to "allowlist"\n')
-        a.dmPolicy = 'allowlist'
-      }
-      a.pending = {}
-      return a
-    })()
-  : null
-
-function loadAccess(): Access {
-  return BOOT_ACCESS ?? readAccessFile()
-}
-
-/**
- * Read `people.json` (the scaffold's plain projection of `users:` entries
- * that carry a `person_id`). Fail-open: ENOENT or corrupt/malformed JSON
- * returns an empty array rather than throwing — this feature must never
- * block startup. Unlike `access.json` this file is never gateway-mutated,
- * so there's no "move corrupt file aside" concern; the scaffold owns and
- * regenerates it on every reconcile.
- */
-function readPeopleFile(): RawPersonEntry[] {
-  try {
-    const raw = readFileSync(PEOPLE_FILE, 'utf8')
-    const parsed = JSON.parse(raw) as { entries?: unknown }
-    if (!Array.isArray(parsed.entries)) return []
-    return parsed.entries as RawPersonEntry[]
-  } catch {
-    return []
-  }
-}
+// Access/allowlist file layer (access.json + people.json). Extracted to
+// ./access-store.ts (switchroom#4248) to relieve the gateway line-ratchet;
+// behavior is byte-identical. The factory runs the static-mode BOOT_ACCESS
+// snapshot eagerly at THIS point in startup — same timing as the inline
+// version — so the frozen-allowlist semantics are unchanged.
+const { loadAccess, readPeopleFile, assertAllowedChat, saveAccess, pruneExpired } =
+  createAccessStore({
+    accessFile: ACCESS_FILE,
+    peopleFile: PEOPLE_FILE,
+    stateDir: STATE_DIR,
+    isStatic: STATIC,
+  })
 
 /**
  * Boot-time-only person-name directory (see resolve-person.ts module doc).
@@ -1673,34 +1598,6 @@ function readPeopleFile(): RawPersonEntry[] {
  */
 let PERSON_DIRECTORY: PersonDirectory = { byTelegramKey: {} }
 
-function assertAllowedChat(chat_id: string | number): void {
-  const id = String(chat_id)
-  const access = loadAccess()
-  if (access.allowFrom.includes(id)) return
-  if (id in access.groups) return
-  throw new Error(`chat ${id} is not allowlisted — add via /telegram:access`)
-}
-
-function saveAccess(a: Access): void {
-  if (STATIC) return
-  mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 })
-  const tmp = ACCESS_FILE + '.tmp'
-  writeFileSync(tmp, JSON.stringify(a, null, 2) + '\n', { mode: 0o600 })
-  renameSync(tmp, ACCESS_FILE)
-}
-
-function pruneExpired(a: Access): boolean {
-  const now = Date.now()
-  let changed = false
-  for (const [code, p] of Object.entries(a.pending)) {
-    if (p.expiresAt < now) {
-      delete a.pending[code]
-      changed = true
-    }
-  }
-  return changed
-}
-
 // ─── History ──────────────────────────────────────────────────────────────
 const HISTORY_ACCESS = loadAccess()
 const HISTORY_ENABLED = HISTORY_ACCESS.historyEnabled !== false
@@ -10181,7 +10078,7 @@ if (isGatewayMain && !STATIC && OBLIGATION_LEDGER_ENABLED) {
 // --continue suppression, resume-window dedup, budget) lives in
 // boot-briefing-wiring.ts / boot-briefing-builder.ts; never throws.
 if (isGatewayMain && HISTORY_ENABLED) {
-  maybeQueueBootBriefing({
+  await maybeQueueBootBriefing({
     env: process.env,
     stateDir: STATE_DIR,
     resumeMsg: bootResumeInbound?.msg ?? null,
@@ -15182,17 +15079,39 @@ export async function handleInbound(
 
   // Reply-to + forward-origin context — moved to buildReplyForwardContext
   // (#2996 P7 PR-10, pure builder).
+  const replyForwardCtx = buildReplyForwardContext({
+    ctx,
+    coalescedForwardOrigins,
+    replyToTextMax: REPLY_TO_TEXT_MAX,
+  })
   const {
     replyToMessageId,
-    replyToText,
-    replyToTextEscaped,
     forwardOrigins,
     forwardOriginMeta,
     primaryForwardOrigin,
-  } = buildReplyForwardContext({
-    ctx,
-    coalescedForwardOrigins,
+  } = 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
+  // 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
+  // empty; degrades silently when history is off / the row is missing.
+  const {
+    replyToText,
+    replyToTextEscaped,
+    replyToRole,
+  } = resolveReplyToFromBuffer({
+    replyToMessageId,
+    replyToText: replyForwardCtx.replyToText,
+    replyToTextEscaped: replyForwardCtx.replyToTextEscaped,
+    historyEnabled: HISTORY_ENABLED,
     replyToTextMax: REPLY_TO_TEXT_MAX,
+    lookup: (messageId) => lookupMessageRoleAndText(chat_id, messageId),
   })
 
   if (HISTORY_ENABLED) {
@@ -15269,6 +15188,7 @@ export async function handleInbound(
     priorAssistantPreview,
     replyToMessageId,
     replyToTextEscaped,
+    replyToRole,
     forwardOriginMeta,
     topicFramingEnabled: TOPIC_FRAMING_ENABLED,
     personDirectory: PERSON_DIRECTORY,

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

@@ -151,9 +151,20 @@ export function buildReplyForwardContext(p: ReplyForwardContextParams): {
   // (for channel meta).
   const replyToMsg = p.ctx.message?.reply_to_message
   const replyToMessageId = replyToMsg?.message_id
-  const replyToTextRaw = replyToMsg
-    ? (replyToMsg.text ?? replyToMsg.caption ?? undefined)
-    : undefined
+  // Native partial-quote preference (Bot API 7.0+ `message.quote`, issue #119
+  // follow-up). When the user long-presses a message and drag-selects a
+  // substring before choosing Reply, Telegram delivers only that quoted span
+  // on `message.quote.text` — the user is pointing at that exact slice, so it
+  // is a stronger antecedent than the full parent message. Prefer it over the
+  // parent `.text`/`.caption`, and over the history-buffer fallback the
+  // gateway runs when neither is present. Accessed defensively in case the
+  // installed grammy/@grammyjs/types predate `TextQuote`.
+  const quoteText = p.ctx.message?.quote?.text
+  const replyToTextRaw = (quoteText != null && quoteText.length > 0)
+    ? quoteText
+    : replyToMsg
+      ? (replyToMsg.text ?? replyToMsg.caption ?? undefined)
+      : undefined
   const replyToText = replyToTextRaw != null
     ? (replyToTextRaw.length > p.replyToTextMax
         ? replyToTextRaw.slice(0, p.replyToTextMax - 1) + '…'
@@ -183,6 +194,73 @@ export function buildReplyForwardContext(p: ReplyForwardContextParams): {
   }
 }
 
+/** Inputs for {@link resolveReplyToFromBuffer}. */
+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). */
+  replyToText: string | undefined
+  /** XML-escaped reply text for the channel meta; empty in the same case. */
+  replyToTextEscaped: string | undefined
+  /** HISTORY_ENABLED — the DB is only present when history is on. */
+  historyEnabled: boolean
+  /** REPLY_TO_TEXT_MAX. */
+  replyToTextMax: number
+  /** `lookupMessageRoleAndText` bound to the chat, or any equivalent. May
+   *  throw (e.g. requireDb when history disabled mid-run) — this is caught. */
+  lookup: (messageId: number) => { role: 'user' | 'assistant'; text: string } | null
+}
+
+/**
+ * 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.
+ *
+ * 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.
+ */
+export function resolveReplyToFromBuffer(p: ReplyToBufferFallbackParams): {
+  replyToText: string | undefined
+  replyToTextEscaped: string | undefined
+  replyToRole: 'user' | 'assistant' | undefined
+} {
+  let replyToText = p.replyToText
+  let replyToTextEscaped = p.replyToTextEscaped
+  let replyToRole: 'user' | 'assistant' | undefined
+  const liveTextEmpty = replyToTextEscaped == null || replyToTextEscaped.length === 0
+  if (p.historyEnabled && p.replyToMessageId != null && liveTextEmpty) {
+    try {
+      const recovered = p.lookup(p.replyToMessageId)
+      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.
+        replyToRole = recovered.role
+      }
+    } catch {
+      // History disabled mid-run / requireDb throws / row missing — degrade
+      // silently to the id-only inputs (current behavior).
+    }
+  }
+  return { replyToText, replyToTextEscaped, replyToRole }
+}
+
 /** Inputs for {@link buildInboundEnvelope} — every field is an at-call
  * captured value (steering meta, at-receipt snapshots, resolved attachments),
  * never a live getter. */
@@ -206,6 +284,11 @@ export interface EnvelopeBuildParams {
   priorAssistantPreview: string | undefined
   replyToMessageId: number | undefined
   replyToTextEscaped: string | undefined
+  /** Authorship of the replied-to message ('assistant' = the bot's own
+   * message, 'user' = a person's), when known — recovered from the history
+   * buffer by handleInbound's reply-to fallback. Undefined when the role
+   * can't be determined (e.g. text came live off the update, not the DB). */
+  replyToRole: 'user' | 'assistant' | undefined
   forwardOriginMeta: Record<string, string>
   /** TOPIC_FRAMING_ENABLED — fixed constant. */
   topicFramingEnabled: boolean
@@ -300,6 +383,13 @@ export function buildInboundEnvelope(p: EnvelopeBuildParams): InboundMessage {
       // Use the XML-escaped form for the meta — the raw form is in the
       // SQLite buffer for verbatim retrieval via get_recent_messages.
       ...(p.replyToTextEscaped != null && p.replyToTextEscaped.length > 0 ? { reply_to_text: p.replyToTextEscaped } : {}),
+      // Authorship of the replied-to message. Disambiguates "you are replying
+      // to the BOT's own message" (assistant) from "…to a person's message"
+      // (user) — the incident where a native reply to one of the bot's own
+      // messages ("is this added as a calendar invite yet?") left the agent
+      // guessing the antecedent. Free: the history-buffer lookup that recovers
+      // reply_to_text already returns the role. Emitted only when known.
+      ...(p.replyToRole != null ? { reply_to_role: p.replyToRole } : {}),
       // Forwarded-message origin (server-stamped, attrs-only — see above).
       // forwarded_from / forwarded_from_type / forwarded_from_id /
       // forwarded_date, plus numbered _2.. siblings for a multi-origin