switchroom 0.19.5 → 0.19.7

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.19.5", COMMIT_SHA = "c5feaef8";
+var VERSION = "0.19.7", COMMIT_SHA = "2ddec4ae";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";

package/dist/host-control/main.js

@@ -26663,7 +26663,7 @@ import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:f
 import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.19.5";
+var VERSION = "0.19.7";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

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.19.5",
+  "version": "0.19.7",
   "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": {

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

@@ -40426,7 +40426,7 @@ function decideSupersede(record, args) {
   if (!sameTurn) {
     return { supersede: false, deleteMessageIds: [], reason: "different-turn" };
   }
-  if (args.replyText != null && !flushedAnswerMatchesReply(record.text, args.replyText)) {
+  if (!args.positiveAttribution && args.replyText != null && !flushedAnswerMatchesReply(record.text, args.replyText)) {
     return { supersede: false, deleteMessageIds: [], reason: "new-content", recordText: record.text };
   }
   return {
@@ -40469,6 +40469,7 @@ class FlushedTurnSupersedeRegistry {
     return decideSupersede(rec, {
       liveTurnId: args.liveTurnId,
       replyText: args.replyText,
+      positiveAttribution: args.positiveAttribution,
       now: args.now,
       ttlMs: this.ttlMs
     });
@@ -73954,7 +73955,7 @@ function decideSupersede2(record, args) {
   if (!sameTurn) {
     return { supersede: false, deleteMessageIds: [], reason: "different-turn" };
   }
-  if (args.replyText != null && !flushedAnswerMatchesReply2(record.text, args.replyText)) {
+  if (!args.positiveAttribution && args.replyText != null && !flushedAnswerMatchesReply2(record.text, args.replyText)) {
     return { supersede: false, deleteMessageIds: [], reason: "new-content", recordText: record.text };
   }
   return {
@@ -74004,6 +74005,7 @@ class FlushedTurnSupersedeRegistry2 {
     return decideSupersede2(rec, {
       liveTurnId: args.liveTurnId,
       replyText: args.replyText,
+      positiveAttribution: args.positiveAttribution,
       now: args.now,
       ttlMs: this.ttlMs
     });
@@ -74583,6 +74585,7 @@ async function sendReply(deps, req) {
     resolveAnswerThreadWithLog,
     resolveThreadId,
     getLatestInboundMessageId: getLatestInboundMessageId2,
+    getLastSubagentHandbackAt,
     recordOutbound: recordOutbound2,
     emissionAuthorityFor,
     clearActivitySummary,
@@ -74656,9 +74659,15 @@ async function sendReply(deps, req) {
   let supersedeFlushIds = [];
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
-    const ownerTurn = resolveReplyOwnerTurn(turn, chat_id, args);
+    const { turn: ownerTurn, tier: ownerTier } = resolveReplyOwnerTurn(turn, chat_id, args);
     const resolvedTurnId = ownerTurn?.turnId ?? null;
-    const decision = flushedTurnSupersede.take(chat_id, replyThreadId, { liveTurnId: resolvedTurnId, replyText: text4, now: Date.now() });
+    const ownerEndedAt = ownerTurn?.endedAt ?? null;
+    const gateThreadId = ownerTurn?.sessionThreadId ?? replyThreadId;
+    const handbackAt = getLastSubagentHandbackAt(chat_id);
+    const now = Date.now();
+    const handbackCouldOwnReply = handbackAt != null && ownerEndedAt != null && handbackAt > ownerEndedAt && now - handbackAt <= DEFAULT_SUPERSEDE_TTL_MS2;
+    const replyIsOwnAnswer = ownerTier === "live" || ownerTier === "latest-ended" && !handbackCouldOwnReply;
+    const decision = flushedTurnSupersede.take(chat_id, gateThreadId, { liveTurnId: resolvedTurnId, replyText: text4, positiveAttribution: replyIsOwnAnswer, now });
     if (decision.supersede) {
       process.stderr.write(`telegram gateway: reply: superseding flushed turn message(s) ` + `chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}
 `);
@@ -78142,8 +78151,61 @@ function latestEndedAccepted(candidates) {
     return true;
   return age <= ttl;
 }
+function resolveReplyOwnerTier(candidates) {
+  if (candidates.liveTurnId != null)
+    return "live";
+  if (candidates.originTurnId != null)
+    return "origin";
+  if (candidates.quotedTurnId != null)
+    return "quoted";
+  if (latestEndedAccepted(candidates))
+    return "latest-ended";
+  return "none";
+}
 function resolveReplyOwnerTurnId(candidates) {
-  return candidates.liveTurnId ?? candidates.originTurnId ?? candidates.quotedTurnId ?? (latestEndedAccepted(candidates) ? candidates.latestEndedTurnId : null) ?? null;
+  switch (resolveReplyOwnerTier(candidates)) {
+    case "live":
+      return candidates.liveTurnId;
+    case "origin":
+      return candidates.originTurnId;
+    case "quoted":
+      return candidates.quotedTurnId;
+    case "latest-ended":
+      return candidates.latestEndedTurnId;
+    case "none":
+      return null;
+  }
+}
+
+// gateway/subagent-handback-marker.ts
+var MAIN_THREAD_KEY = "<main>";
+
+class SubagentHandbackMarker {
+  byChat = new Map;
+  threadKey(threadId) {
+    return threadId == null ? MAIN_THREAD_KEY : String(threadId);
+  }
+  record(chatId, threadId, now) {
+    let inner = this.byChat.get(chatId);
+    if (inner == null) {
+      inner = new Map;
+      this.byChat.set(chatId, inner);
+    }
+    inner.set(this.threadKey(threadId), now);
+  }
+  lastAt(chatId, threadId) {
+    return this.byChat.get(chatId)?.get(this.threadKey(threadId)) ?? null;
+  }
+  lastAtInChat(chatId) {
+    const inner = this.byChat.get(chatId);
+    if (inner == null || inner.size === 0)
+      return null;
+    let max = -Infinity;
+    for (const ts of inner.values())
+      if (ts > max)
+        max = ts;
+    return max === -Infinity ? null : max;
+  }
 }
 
 // answer-ready-flush.ts
@@ -84622,6 +84684,76 @@ function buildDiffPreviewCard(input) {
   return { text: text4, reply_markup: kb };
 }
 
+// gateway/subagent-handback-marker.ts
+var INBOUND_SOURCE_CLASSIFICATION = {
+  subagent_handback: { decoupledCompletion: true },
+  cron: { decoupledCompletion: false },
+  reaction: { decoupledCompletion: false },
+  subagent_progress: { decoupledCompletion: false },
+  resume_interrupted: { decoupledCompletion: false },
+  resume_deferred: { decoupledCompletion: false },
+  resume_watchdog_timeout: { decoupledCompletion: false },
+  vault_grant_approved: { decoupledCompletion: false },
+  vault_grant_denied: { decoupledCompletion: false },
+  vault_grant_timeout: { decoupledCompletion: false },
+  vault_save_completed: { decoupledCompletion: false },
+  vault_save_discarded: { decoupledCompletion: false },
+  vault_save_failed: { decoupledCompletion: false },
+  vault_save_timeout: { decoupledCompletion: false },
+  secret_provided: { decoupledCompletion: false },
+  secret_declined: { decoupledCompletion: false },
+  secret_provide_failed: { decoupledCompletion: false },
+  secret_request_timeout: { decoupledCompletion: false },
+  mental_model_propose_timeout: { decoupledCompletion: false },
+  bridge_dead_restart: { decoupledCompletion: false },
+  obligation_represent: { decoupledCompletion: false },
+  missed_approval_retry: { decoupledCompletion: false },
+  skill_proposal_apply: { decoupledCompletion: false },
+  warmup: { decoupledCompletion: false },
+  mental_model_proposal_applied: { decoupledCompletion: false },
+  mental_model_proposal_denied: { decoupledCompletion: false },
+  mental_model_proposal_failed: { decoupledCompletion: false },
+  webhook: { decoupledCompletion: false },
+  linear: { decoupledCompletion: false }
+};
+function stampsHandbackMarker(source) {
+  if (source == null)
+    return false;
+  const known = INBOUND_SOURCE_CLASSIFICATION[source];
+  if (known == null)
+    return true;
+  return known.decoupledCompletion;
+}
+var MAIN_THREAD_KEY2 = "<main>";
+
+class SubagentHandbackMarker2 {
+  byChat = new Map;
+  threadKey(threadId) {
+    return threadId == null ? MAIN_THREAD_KEY2 : String(threadId);
+  }
+  record(chatId, threadId, now) {
+    let inner = this.byChat.get(chatId);
+    if (inner == null) {
+      inner = new Map;
+      this.byChat.set(chatId, inner);
+    }
+    inner.set(this.threadKey(threadId), now);
+  }
+  lastAt(chatId, threadId) {
+    return this.byChat.get(chatId)?.get(this.threadKey(threadId)) ?? null;
+  }
+  lastAtInChat(chatId) {
+    const inner = this.byChat.get(chatId);
+    if (inner == null || inner.size === 0)
+      return null;
+    let max = -Infinity;
+    for (const ts of inner.values())
+      if (ts > max)
+        max = ts;
+    return max === -Infinity ? null : max;
+  }
+}
+
 // gateway/pending-inbound-buffer.ts
 var DEFAULT_PENDING_INBOUND_CAP = 32;
 function redeliverBufferedInbound(buffer, agent, send, spool, onDelivered) {
@@ -84736,6 +84868,11 @@ function createPendingInboundBuffer(opts = {}) {
         }
       }
       q.push(msg);
+      if (stampsHandbackMarker(msg.meta?.source) && opts.onHandbackEnqueue != null) {
+        try {
+          opts.onHandbackEnqueue(msg.chatId, msg.threadId, msg.ts);
+        } catch {}
+      }
       spool?.put(agent, msg);
       log(`pending-inbound-buffer: agent=${agent} buffered source=${msg.meta?.source ?? "-"} ` + `depth_after=${q.length} evicted=${evicted}
 `);
@@ -93414,10 +93551,10 @@ function startGatewayHeartbeat(stateDir, intervalMs = GATEWAY_HEARTBEAT_INTERVAL
 }
 
 // ../src/build-info.ts
-var VERSION = "0.19.5";
-var COMMIT_SHA = "c5feaef8";
-var COMMIT_DATE = "2026-07-20T10:20:34Z";
-var LATEST_PR = 3474;
+var VERSION = "0.19.7";
+var COMMIT_SHA = "2ddec4ae";
+var COMMIT_DATE = "2026-07-20T19:59:43Z";
+var LATEST_PR = 3478;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -96335,6 +96472,8 @@ function cardDrainGate(turn, ea, run4) {
 var RECENT_TURNS_MAX = 32;
 var recentTurnsById = new Map;
 var recentTurnIdBySourceMessageId = new Map;
+var subagentHandbackMarker = new SubagentHandbackMarker;
+var getLastSubagentHandbackAt = (chatId) => subagentHandbackMarker.lastAtInChat(chatId);
 function rememberRecentTurn(turn) {
   recentTurnsById.set(turn.turnId, turn);
   if (turn.sourceMessageId != null) {
@@ -96401,15 +96540,17 @@ function resolveReplyOwnerTurn(liveTurn, chatId, args) {
       byId.set(t.turnId, t);
   }
   const latestEndedAgeMs = latestEnded?.endedAt != null ? Date.now() - latestEnded.endedAt : null;
-  const winnerId = resolveReplyOwnerTurnId({
+  const candidates = {
     liveTurnId: liveTurn?.turnId ?? null,
     originTurnId: origin?.turnId ?? null,
     quotedTurnId: quoted?.turnId ?? null,
     latestEndedTurnId: latestEnded?.turnId ?? null,
     latestEndedAgeMs,
     latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS
-  });
-  return winnerId != null ? byId.get(winnerId) ?? null : null;
+  };
+  const tier = resolveReplyOwnerTier(candidates);
+  const winnerId = resolveReplyOwnerTurnId(candidates);
+  return { turn: winnerId != null ? byId.get(winnerId) ?? null : null, tier };
 }
 function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, originVia, liveTurn, surface) {
   const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestEndedTurnForChat(chatId) : null;
@@ -99121,7 +99262,8 @@ var pendingInboundBuffer = createPendingInboundBuffer({
     evictNoticeByChat.set(key, nowMs3);
     const threadOpts = evThread != null ? { message_thread_id: evThread } : {};
     swallowingApiCall(() => bot.api.sendMessage(chat, "\u23F3 Messages are arriving faster than I can process them. Your messages are saved and will be handled once I finish the current turn \u2014 if any can't be picked up, I'll ask you to resend it.", { ...threadOpts }), { chat_id: chat, verb: "inbound-buffer-eviction" });
-  }
+  },
+  onHandbackEnqueue: (chatId, threadId, ts) => subagentHandbackMarker.record(chatId, threadId, ts)
 });
 function agentHasInFlightBackgroundWork(now) {
   if (countRunningWorkers() > 0)
@@ -100499,6 +100641,7 @@ function gatewaySendReplyDeps() {
     resolveAnswerThreadWithLog,
     resolveThreadId,
     getLatestInboundMessageId,
+    getLastSubagentHandbackAt,
     recordOutbound,
     emissionAuthorityFor,
     clearActivitySummary,

package/telegram-plugin/flushed-turn-supersede.ts

@@ -181,7 +181,13 @@ export function flushedAnswerMatchesReply(flushedText: string, replyText: string
  */
 export function decideSupersede(
   record: FlushedTurnRecord | undefined,
-  args: { liveTurnId: string | null; replyText?: string | null; now: number; ttlMs?: number },
+  args: {
+    liveTurnId: string | null
+    replyText?: string | null
+    positiveAttribution?: boolean
+    now: number
+    ttlMs?: number
+  },
 ): SupersedeDecision {
   const ttlMs = args.ttlMs ?? DEFAULT_SUPERSEDE_TTL_MS
   if (record == null) return { supersede: false, deleteMessageIds: [], reason: 'no-record' }
@@ -195,10 +201,29 @@ export function decideSupersede(
   if (!sameTurn) {
     return { supersede: false, deleteMessageIds: [], reason: 'different-turn' }
   }
-  // #3429 — same turn identity, but genuinely different content: an async
-  // handback attributed to the flush-delivered ended turn, not the turn's own
-  // answer landing late. Never edit/delete the flushed message for it.
-  if (args.replyText != null && !flushedAnswerMatchesReply(record.text, args.replyText)) {
+  // #3429 content gate — but ONLY when the caller is UNSURE the reply is this
+  // turn's own answer. `positiveAttribution === true` means the gateway
+  // established the reply IS this turn's OWN late answer — either by a positive
+  // owner-resolution tier (live atom / `origin_turn_id` echo / quoted message
+  // id) OR because no background `subagent_handback` could own it (none enqueued
+  // for the chat after the flushed turn ended within the supersede TTL; see
+  // outbound-send-path). Then supersede the flushed provisional draft REGARDLESS
+  // of text, so a model that RE-WORDED the answer between the narration that
+  // flushed and the `reply` tool call still collapses to ONE message (the
+  // duplicate-reply regression #3429 introduced on the reworded same-turn path).
+  //
+  // The content gate remains when `positiveAttribution` is falsey — the
+  // ambiguous residual (latest-ended tier AND a handback in flight) where
+  // identity alone cannot tell the turn's own late reply from a background
+  // sub-agent handback that resolved this flush-delivered ended turn as its
+  // owner. There, genuinely different content is a handback and must send FRESH
+  // (both messages surface), never edit/delete the flushed answer. Legacy
+  // identity-only callers (no `replyText`) keep the pre-#3429 behaviour.
+  if (
+    !args.positiveAttribution &&
+    args.replyText != null &&
+    !flushedAnswerMatchesReply(record.text, args.replyText)
+  ) {
     return { supersede: false, deleteMessageIds: [], reason: 'new-content', recordText: record.text }
   }
   return {
@@ -326,12 +351,18 @@ export class FlushedTurnSupersedeRegistry {
   peek(
     chatId: string,
     threadId: number | undefined,
-    args: { liveTurnId: string | null; replyText?: string | null; now: number },
+    args: {
+      liveTurnId: string | null
+      replyText?: string | null
+      positiveAttribution?: boolean
+      now: number
+    },
   ): SupersedeDecision {
     const rec = this.entries.get(makeKey(chatId, threadId))?.get(turnKey(args.liveTurnId))
     return decideSupersede(rec, {
       liveTurnId: args.liveTurnId,
       replyText: args.replyText,
+      positiveAttribution: args.positiveAttribution,
       now: args.now,
       ttlMs: this.ttlMs,
     })
@@ -345,7 +376,12 @@ export class FlushedTurnSupersedeRegistry {
   take(
     chatId: string,
     threadId: number | undefined,
-    args: { liveTurnId: string | null; replyText?: string | null; now: number },
+    args: {
+      liveTurnId: string | null
+      replyText?: string | null
+      positiveAttribution?: boolean
+      now: number
+    },
   ): SupersedeDecision {
     const lane = makeKey(chatId, threadId)
     const decision = this.peek(chatId, threadId, args)

package/telegram-plugin/gateway/gateway.ts

@@ -485,8 +485,11 @@ import {
 } from '../turn-flush-safety.js'
 import {
   resolveReplyOwnerTurnId,
+  resolveReplyOwnerTier,
+  type ReplyOwnerTier,
   type AnswerDeliveredLatch,
 } from '../reply-owner-resolve.js'
+import { SubagentHandbackMarker } from './subagent-handback-marker.js'
 // PR A — deterministic answer-ready quiescence flush (late-delivery fix).
 import {
   AnswerReadyFlushController,
@@ -3885,6 +3888,19 @@ const recentTurnsById = new Map<string, CurrentTurn>()
 // real message_id the framework stamped, never a model-asserted thread.
 // Evicted in lock-step with recentTurnsById so it can't outgrow it.
 const recentTurnIdBySourceMessageId = new Map<number, string>()
+
+// fix/backstop-duplicate-reply — per-chat/thread marker of the most recent
+// gateway-synthesized `subagent_handback` enqueue (logic in
+// subagent-handback-marker.ts; extracted per the gateway anti-inflation ratchet).
+// The record is thread-resolved (retains the originating topic), but the
+// content-gate READ is CHAT-WIDE (dup-audit MUST-FIX 2): the latest-ended owner
+// tier is chat-wide, so a thread-specific gate read was steerable by the reply's
+// own `message_thread_id` → silent edit-over. `lastAtInChat` makes the gate
+// un-steerable (any in-window handback in the chat keeps the content gate).
+const subagentHandbackMarker = new SubagentHandbackMarker()
+const getLastSubagentHandbackAt = (chatId: string): number | null =>
+  subagentHandbackMarker.lastAtInChat(chatId)
+
 function rememberRecentTurn(turn: CurrentTurn): void {
   recentTurnsById.set(turn.turnId, turn)
   if (turn.sourceMessageId != null) {
@@ -4009,7 +4025,7 @@ function resolveReplyOwnerTurn(
   liveTurn: CurrentTurn | null,
   chatId: string,
   args: Record<string, unknown>,
-): CurrentTurn | null {
+): { turn: CurrentTurn | null; tier: ReplyOwnerTier } {
   const origin = findTurnByOriginId(args.origin_turn_id as string | undefined)
   const quoted = findTurnByQuotedMessageId(chatId, args.reply_to)
   const latestEnded = findLatestEndedTurnForChat(chatId)
@@ -4026,15 +4042,23 @@ function resolveReplyOwnerTurn(
   // fabricate one.
   const latestEndedAgeMs =
     latestEnded?.endedAt != null ? Date.now() - latestEnded.endedAt : null
-  const winnerId = resolveReplyOwnerTurnId({
+  const candidates = {
     liveTurnId: liveTurn?.turnId ?? null,
     originTurnId: origin?.turnId ?? null,
     quotedTurnId: quoted?.turnId ?? null,
     latestEndedTurnId: latestEnded?.turnId ?? null,
     latestEndedAgeMs,
     latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
-  })
-  return winnerId != null ? (byId.get(winnerId) ?? null) : null
+  }
+  // #3429 — the WINNING tier travels with the turn. A positive tier
+  // (live/origin/quoted) means the reply is this turn's own answer and the
+  // supersede fires regardless of text; the ambiguous `latest-ended` fallback
+  // keeps the content gate (it cannot tell a late own-reply from an async
+  // sub-agent handback). Both derive from the SAME candidates, so the id and the
+  // tier can never disagree.
+  const tier = resolveReplyOwnerTier(candidates)
+  const winnerId = resolveReplyOwnerTurnId(candidates)
+  return { turn: winnerId != null ? (byId.get(winnerId) ?? null) : null, tier }
 }
 
 /**
@@ -9962,6 +9986,10 @@ const pendingInboundBuffer = createPendingInboundBuffer({
       { chat_id: chat, verb: 'inbound-buffer-eviction' },
     )
   },
+  // fix/backstop-duplicate-reply MUST-FIX 2 — stamp the handback marker at the
+  // enqueue chokepoint so a boot-replayed handback (not just the live synthesis
+  // push) populates it. Every `subagent_handback` push funnels through here.
+  onHandbackEnqueue: (chatId, threadId, ts) => subagentHandbackMarker.record(chatId, threadId, ts),
 })
 
 // PR2 obligation-ledger idle sweep. Re-present an OPEN obligation only at a
@@ -12567,6 +12595,7 @@ function gatewaySendReplyDeps(): SendReplyGatewayDeps {
     resolveAnswerThreadWithLog,
     resolveThreadId,
     getLatestInboundMessageId,
+    getLastSubagentHandbackAt,
     recordOutbound,
     emissionAuthorityFor,
     clearActivitySummary,
@@ -24458,6 +24487,9 @@ async function startGateway(): Promise<void> {  // #2996 P0c: the boot IIFE, now
                 // The drain only releases at an idle prompt (no active
                 // turn), so the handback always lands as a clean fresh
                 // turn and never races a turn-in-flight composer (#1556).
+                // The handback marker is stamped inside pendingInboundBuffer.push
+                // (the enqueue chokepoint) so BOTH this live synthesis push and
+                // the boot-replay re-push populate it — see MUST-FIX 2.
                 pendingInboundBuffer.push(process.env.SWITCHROOM_AGENT_NAME ?? '', decision.inbound)
                 process.stderr.write(
                   `telegram gateway: subagent-handback queued agent=${agentId} outcome=${outcome} chat=${decision.chatId} resultChars=${resultText.length}\n`,

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

@@ -56,9 +56,10 @@ import { decideSilentReplyAnchor } from '../silent-reply-anchor.js'
 import {
   decideSupersedeCorrection,
   flushedAnswerMatchesReply,
+  DEFAULT_SUPERSEDE_TTL_MS,
   type FlushedTurnSupersedeRegistry,
 } from '../flushed-turn-supersede.js'
-import { decideAnswerLatchSuppression } from '../reply-owner-resolve.js'
+import { decideAnswerLatchSuppression, type ReplyOwnerTier } from '../reply-owner-resolve.js'
 import { deriveTelegraphTitle } from '../telegraph.js'
 import {
   mintVoiceOnDemandToken,
@@ -658,7 +659,7 @@ export interface SendReplyGatewayDeps {
   assertSendable(f: string): void
   statusKey(chatId: string, threadId?: number | null): string
   streamKey(chatId: string, threadId?: number | null): string
-  resolveReplyOwnerTurn(liveTurn: CurrentTurn | null, chatId: string, args: Record<string, unknown>): CurrentTurn | null
+  resolveReplyOwnerTurn(liveTurn: CurrentTurn | null, chatId: string, args: Record<string, unknown>): { turn: CurrentTurn | null; tier: ReplyOwnerTier }
   findTurnByOriginId(originTurnId: string | null | undefined): CurrentTurn | null
   findTurnByQuotedMessageId(chatId: string, replyTo: unknown): CurrentTurn | null
   resolveAnswerThreadWithLog(
@@ -671,6 +672,7 @@ export interface SendReplyGatewayDeps {
   ): number | undefined
   resolveThreadId(chatId: string, explicit?: string | number | null): number | undefined
   getLatestInboundMessageId(chatId: string, threadId: number | null): number | null | undefined
+  getLastSubagentHandbackAt(chatId: string): number | null
   recordOutbound(rec: {
     chat_id: string
     thread_id: number | null
@@ -735,7 +737,7 @@ export async function sendReply(
     statusKey, streamKey,
     resolveReplyOwnerTurn, findTurnByOriginId, findTurnByQuotedMessageId,
     resolveAnswerThreadWithLog, resolveThreadId,
-    getLatestInboundMessageId, recordOutbound,
+    getLatestInboundMessageId, getLastSubagentHandbackAt, recordOutbound,
     emissionAuthorityFor, clearActivitySummary,
     startTypingLoop, stopTypingLoop, logOutbound,
     closeObligationOnSubstantiveReply, finalizeStatusReaction,
@@ -874,18 +876,95 @@ export async function sendReply(
     // double-send). The quoted / latest-ended recoveries are precisely what the
     // router already did for the same reply, so unifying here makes the two
     // resolvers agree and the late-reply supersede fires by identity.
-    const ownerTurn = resolveReplyOwnerTurn(turn, chat_id, args)
+    const { turn: ownerTurn, tier: ownerTier } = resolveReplyOwnerTurn(turn, chat_id, args)
     const resolvedTurnId = ownerTurn?.turnId ?? null
-    // #3429 — pass the (normalized) reply text so the registry can apply the
-    // new-content gate: identity match + TTL alone also fits an async handback
-    // that merely resolved this flush-delivered ENDED turn as its owner via
-    // the latest-ended tier. Editing the flushed message in place with that
-    // handback's text does not re-notify client-side (Telegram edits never
-    // push) — the observed silent non-surfacing of msgs 10482/10486.
+    // #3429 — pass the (normalized) reply text so the registry CAN apply the
+    // new-content gate: identity match + TTL alone also fits a background
+    // sub-agent handback that merely resolved this flush-delivered ENDED turn as
+    // its owner via the latest-ended tier. Editing/deleting the flushed message
+    // for that handback's unrelated text is the #3429 silent client-side drop
+    // (msgs 10482/10486). But that gate ALSO declines the turn's OWN reworded
+    // late reply (model narrated → flushed → fired `reply` with a paraphrase),
+    // which is the dominant real duplicate (agent:marko 2026-07-20: 11/11
+    // declines were own-replies, turns #1177/#1182/#1201 double-sent). So we
+    // BYPASS the content gate ONLY when the reply is confidently the flushed
+    // turn's OWN answer. The primary, deterministic signal is the absence of a
+    // background sub-agent handback that could own this reply: the gateway
+    // records when it synthesizes a `subagent_handback` inbound per chat, and if
+    // NONE was enqueued for this chat AFTER the flushed turn ended within the
+    // supersede TTL, the reply is that turn's own answer → supersede regardless
+    // of a model rewording (closes the DM default-reply duplicate, where every
+    // own-reply resolves via the latest-ended tier).
+    //
+    // MUST-FIX 1 (silent-data-loss): the owner-resolution `quoted` / `origin`
+    // tiers are derived from MODEL-SUPPLIED args (`args.reply_to` /
+    // `args.origin_turn_id`), so a reply can STEER itself — pass
+    // `reply_to = <another ended turn's source msg>` and it resolves THAT turn via
+    // `quoted`. Marker-absence proves "own answer" ONLY for the framework-derived
+    // `latest-ended` tier; a model-steered `quoted`/`origin` attribution with no
+    // marker is NOT evidence of ownership, so bypassing the content gate there
+    // silently edits over a different ended turn's delivered answer (the #3429
+    // double-loss, executed by Fable 2026-07-21). The `replyIsOwnAnswer`
+    // computation below therefore restricts the bypass to `live` + `latest-ended`;
+    // `quoted`/`origin` ALWAYS traverse the content gate. See that comment.
+    //
+    // The content gate is therefore kept whenever a decoupled completion WAS
+    // enqueued in the window (on the latest-ended tier) OR the reply resolved via
+    // a model-steerable tier: the late reply might carry foreign content, so it
+    // sends fresh (two messages, #3429 preserved). Concurrency note: a case-A own
+    // reply coinciding with an unrelated background handback in the same ≤TTL
+    // window degrades to two messages — safe (never a silent drop/edit).
+    const ownerEndedAt = ownerTurn?.endedAt ?? null
+    // MUST-FIX 2 (dup-audit / Fable 2026-07-21) — key BOTH the supersede lane and
+    // the marker-gate read on the FRAMEWORK-resolved thread (the owner turn's
+    // `sessionThreadId` — the lane the flush recorded on), NOT the raw model arg
+    // `args.message_thread_id` (`replyThreadId`). The flush records on
+    // `turn.sessionThreadId`; the owner turn resolved here IS that turn, so its
+    // thread is where its record and its handback marker live. Reading the gate on
+    // the raw arg let a reply carry `message_thread_id=<other topic>` to dodge a
+    // handback marker stamped on the real topic → silent edit-over (the regression
+    // F2's raw-arg keying introduced). The owner turn's thread is not model-
+    // derived, so it cannot be steered. Falls back to the raw arg only when no
+    // owner turn resolved (no record to clobber on the collapse path).
+    const gateThreadId = ownerTurn?.sessionThreadId ?? replyThreadId
+    // MUST-FIX 2 (dup-audit / Fable) — the content-gate READ is CHAT-WIDE, not
+    // lane-specific: `findLatestEndedTurnForChat` resolves owners chat-wide, so a
+    // handback in topic A can supersede topic B's ended turn; a thread-keyed gate
+    // read (the F2 regression) let a reply dodge that handback by carrying a
+    // different `message_thread_id`. Chat-wide makes the gate un-steerable — any
+    // in-window handback in the chat keeps the content gate (accepting the F2
+    // visible-dup in the overlap window; a self-healing dup beats a silent loss).
+    // The supersede `take()` LANE below stays thread-resolved (`gateThreadId` =
+    // the owner turn's framework thread, not the raw arg), so a handback's
+    // correction only ever touches ITS OWN topic's record.
+    const handbackAt = getLastSubagentHandbackAt(chat_id)
+    const now = Date.now()
+    const handbackCouldOwnReply =
+      handbackAt != null &&
+      ownerEndedAt != null &&
+      handbackAt > ownerEndedAt &&
+      now - handbackAt <= DEFAULT_SUPERSEDE_TTL_MS
+    // MUST-FIX 1 (silent-data-loss, PROVEN by Fable 2026-07-21) — restrict the
+    // content-gate BYPASS to the tiers whose attribution is NOT model-steerable:
+    //   - `live`   — the framework-owned live `currentTurn` (not model-derived,
+    //                and `decideSupersede`'s same-turnId check bars it from an
+    //                ended turn's record). Bypasses even a handback window.
+    //   - `latest-ended` — the ambiguous DM/late-reply fallback the marko fix
+    //                actually needs; bypass ONLY when no decoupled completion is
+    //                in the window (marker-absence ⇒ own answer).
+    // The `quoted` / `origin` tiers resolve from MODEL-SUPPLIED args
+    // (`args.reply_to` / `args.origin_turn_id`), so a reply can steer ITSELF onto
+    // a DIFFERENT ended turn's record — with marker-absence they used to bypass
+    // the content gate and silently edit-over that turn's delivered answer (the
+    // #3429 double-loss, executed by Fable). Those tiers therefore NEVER bypass:
+    // they always go through the content gate, so foreign content sends fresh and
+    // only a genuine same-answer reply collapses.
+    const replyIsOwnAnswer =
+      ownerTier === 'live' || (ownerTier === 'latest-ended' && !handbackCouldOwnReply)
     const decision = flushedTurnSupersede.take(
       chat_id,
-      replyThreadId,
-      { liveTurnId: resolvedTurnId, replyText: text, now: Date.now() },
+      gateThreadId,
+      { liveTurnId: resolvedTurnId, replyText: text, positiveAttribution: replyIsOwnAnswer, now },
     )
     if (decision.supersede) {
       process.stderr.write(