switchroom 0.18.23 → 0.18.24

package/dist/cli/switchroom.js

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

package/dist/host-control/main.js

@@ -26605,7 +26605,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.18.23";
+var VERSION = "0.18.24";
 
 // 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.18.23",
+  "version": "0.18.24",
   "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

@@ -40569,6 +40569,7 @@ function createWorkerActivityFeed(opts) {
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000;
   const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8));
   const staleWorkerTtlMs = Math.max(1, Math.floor(opts.staleWorkerTtlMs ?? 50 * 60000));
+  const absoluteRowLifetimeCapMs = Math.max(1, Math.floor(opts.absoluteRowLifetimeCapMs ?? 6 * 60 * 60000));
   const reconcilePinFn = opts.reconcilePin ?? (() => {});
   const setIntervalFn = opts.setInterval ?? ((cb, ms) => {
     const t = setInterval(cb, ms);
@@ -40850,22 +40851,36 @@ function createWorkerActivityFeed(opts) {
     const staleFinished = [];
     for (const g of groups.values()) {
       for (const row of g.workers.values()) {
-        if (now - row.lastUpdateAt >= staleWorkerTtlMs) {
-          if (row.finished)
-            staleFinished.push({ g, agentId: row.agentId });
-          else
-            staleAgentIds.push(row.agentId);
-        }
+        const silent = now - row.lastUpdateAt >= staleWorkerTtlMs;
+        const tooOld = now - row.createdAtMs >= absoluteRowLifetimeCapMs;
+        if (!silent && !tooOld)
+          continue;
+        const reason = silent ? "silence" : "absolute";
+        if (row.finished)
+          staleFinished.push({ g, agentId: row.agentId, reason });
+        else
+          staleAgentIds.push({ agentId: row.agentId, reason });
       }
     }
-    for (const { g, agentId } of staleFinished) {
-      log(`worker-feed: TTL GC finished row agent=${agentId} feed=${g.feedKey} \u2014 reaping leaked finished row`);
+    for (const { g, agentId, reason } of staleFinished) {
+      if (reason === "absolute") {
+        const age = Math.floor((now - (g.workers.get(agentId)?.createdAtMs ?? now)) / 1000);
+        log(`worker-feed: ABSOLUTE cap GC finished row agent=${agentId} feed=${g.feedKey} \u2014 age ${age}s (>= ${Math.floor(absoluteRowLifetimeCapMs / 1000)}s); reaping immortal finished row`);
+      } else {
+        log(`worker-feed: TTL GC finished row agent=${agentId} feed=${g.feedKey} \u2014 reaping leaked finished row`);
+      }
       g.pendingFinalize.delete(agentId);
       removeWorker(g, agentId);
       syncPin(g);
     }
-    for (const agentId of staleAgentIds) {
-      log(`worker-feed: TTL reap agent=${agentId} \u2014 no update in ${Math.floor((now - (groupOfAgent(agentId)?.workers.get(agentId)?.lastUpdateAt ?? now)) / 1000)}s (>= ${Math.floor(staleWorkerTtlMs / 1000)}s); force-terminating leaked row`);
+    for (const { agentId, reason } of staleAgentIds) {
+      const row = groupOfAgent(agentId)?.workers.get(agentId);
+      if (reason === "absolute") {
+        const age = Math.floor((now - (row?.createdAtMs ?? now)) / 1000);
+        log(`worker-feed: ABSOLUTE cap reap agent=${agentId} \u2014 row age ${age}s (>= ${Math.floor(absoluteRowLifetimeCapMs / 1000)}s); force-terminating immortal row (survives lastUpdateAt reset)`);
+      } else {
+        log(`worker-feed: TTL reap agent=${agentId} \u2014 no update in ${Math.floor((now - (row?.lastUpdateAt ?? now)) / 1000)}s (>= ${Math.floor(staleWorkerTtlMs / 1000)}s); force-terminating leaked row`);
+      }
       terminateWorker(agentId);
     }
     for (const g of [...groups.values()]) {
@@ -40962,6 +40977,7 @@ function createWorkerActivityFeed(opts) {
           state: "running",
           finished: false,
           lastUpdateAt: nowFn(),
+          createdAtMs: nowFn(),
           dispatchAtMs: null,
           stepStartedAtMs: null
         };
@@ -41018,6 +41034,21 @@ function createWorkerActivityFeed(opts) {
         log(`worker-feed: resurrect agent=${agentId} \u2014 cleared finalized gate; card will repaint on next running cue`);
       }
     },
+    purgeAllOnBoot() {
+      for (const g of [...groups.values()]) {
+        if (g.messageId != null) {
+          reconcilePinFn({ feedKey: g.feedKey, chatId: g.chatId, threadId: g.threadId, messageId: null });
+        }
+        for (const agentId of [...g.workers.keys()]) {
+          markFinalized(agentId);
+          agentIndex.delete(agentId);
+        }
+        g.workers.clear();
+        g.pendingFinalize.clear();
+        groups.delete(g.feedKey);
+      }
+      log("worker-feed: purgeAllOnBoot \u2014 reconciled feed to empty and released all group pins");
+    },
     heartbeatTick,
     stop() {
       if (heartbeatTimer != null) {
@@ -68165,6 +68196,7 @@ function endsWithSilentMarker2(text4) {
     return false;
   return isSilentFlushMarker2(lines[lines.length - 1]);
 }
+var FLUSH_SUBSTANTIVE_MIN_CHARS = 200;
 function selectFlushDeliveryText2(blocks) {
   const candidates = blocks.map((b) => b.trim()).filter((b) => b.length > 0);
   if (candidates.length === 0)
@@ -68213,6 +68245,29 @@ function isTurnFlushSafetyEnabled(env = process.env) {
   return true;
 }
 
+// reply-owner-resolve.ts
+function latestEndedAccepted(candidates) {
+  if (candidates.latestEndedTurnId == null)
+    return false;
+  const age = candidates.latestEndedAgeMs;
+  const ttl = candidates.latestEndedTtlMs;
+  if (age == null || ttl == null)
+    return true;
+  return age <= ttl;
+}
+function resolveReplyOwnerTurnId(candidates) {
+  return candidates.liveTurnId ?? candidates.originTurnId ?? candidates.quotedTurnId ?? (latestEndedAccepted(candidates) ? candidates.latestEndedTurnId : null) ?? null;
+}
+function decideAnswerLatchSuppression(input) {
+  if (input.superseded)
+    return false;
+  if (!input.replySubstantive)
+    return false;
+  if (!input.isLateReply)
+    return false;
+  return input.ownerAnswerDelivered;
+}
+
 // answer-ready-flush.ts
 var ANSWER_READY_FLUSH_MS = 1000;
 function resolveAnswerReadyFlushMs(env) {
@@ -82910,10 +82965,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.23";
-var COMMIT_SHA = "a90cf518";
-var COMMIT_DATE = "2026-07-14T09:32:46+10:00";
-var LATEST_PR = 3238;
+var VERSION = "0.18.24";
+var COMMIT_SHA = "f641363e";
+var COMMIT_DATE = "2026-07-14T15:55:33+10:00";
+var LATEST_PR = 3240;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -85340,6 +85395,7 @@ function resolveSubagentOriginChat(agentId) {
 }
 var WORKER_FEED_FALLBACK_LOG_CAP = 256;
 var WORKER_FEED_STALE_TTL_MARGIN_MS = 300000;
+var WORKER_FEED_ABSOLUTE_ROW_LIFETIME_CAP_MULTIPLE = 4;
 var workerFeedOwnerDmFallbackLogged = new Set;
 function resolveWorkerFeedChat(agentId, fleetChatId) {
   const origin = resolveSubagentOriginChat(agentId);
@@ -85748,6 +85804,26 @@ function findLatestEndedTurnForChat(chatId) {
   }
   return latest;
 }
+function resolveReplyOwnerTurn(liveTurn, chatId, args) {
+  const origin = findTurnByOriginId(args.origin_turn_id);
+  const quoted = findTurnByQuotedMessageId(chatId, args.reply_to);
+  const latestEnded = findLatestEndedTurnForChat(chatId);
+  const byId = new Map;
+  for (const t of [latestEnded, quoted, origin, liveTurn]) {
+    if (t != null)
+      byId.set(t.turnId, t);
+  }
+  const latestEndedAgeMs = latestEnded?.endedAt != null ? Date.now() - latestEnded.endedAt : null;
+  const winnerId = resolveReplyOwnerTurnId({
+    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;
+}
 function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, originVia, liveTurn, surface) {
   const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestEndedTurnForChat(chatId) : null;
   const threadId = resolveAnswerThreadId({
@@ -86268,6 +86344,7 @@ function endCurrentTurnAtomic(turn, opts) {
   clearAnswerReadyFlushTimeout(turn);
   endCurrentTurnForKey(turn, key);
   const turnEndedAt = Date.now();
+  turn.endedAt = turnEndedAt;
   process.stderr.write(`telegram gateway: ${formatTurnLifecycle("clear", "turn_end", turn, turnEndedAt)}
 `);
   if (opts?.deferRecord !== true) {
@@ -90044,7 +90121,8 @@ async function executeReply(args) {
   }
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
-    const resolvedTurnId = turn?.turnId ?? findTurnByOriginId(args.origin_turn_id)?.turnId ?? null;
+    const ownerTurn = resolveReplyOwnerTurn(turn, chat_id, args);
+    const resolvedTurnId = ownerTurn?.turnId ?? null;
     const decision = flushedTurnSupersede.take(chat_id, replyThreadId, { liveTurnId: resolvedTurnId, now: Date.now() });
     if (decision.supersede) {
       process.stderr.write(`telegram gateway: reply: superseding flushed turn message(s) chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}
@@ -90052,6 +90130,25 @@ async function executeReply(args) {
       for (const id of decision.deleteMessageIds) {
         await swallowingApiCall(() => lockedBot.api.deleteMessage(chat_id, id), { chat_id, verb: "reply.supersedeFlushed" });
       }
+    } else {
+      const replySubstantive = isSubstantiveFinalReply({
+        text: rawText,
+        disableNotification: args.disable_notification === true
+      });
+      const suppressByLatch = decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive,
+        isLateReply: turn == null,
+        ownerAnswerDelivered: ownerTurn?.answerDelivered ?? false
+      });
+      if (suppressByLatch) {
+        process.stderr.write(`telegram gateway: reply: suppressed by answer-delivered latch (flush already delivered this turn's answer) chatId=${chat_id} ownerTurnId=${JSON.stringify(resolvedTurnId)}
+`);
+        return { content: [{ type: "text", text: "sent (deduped \u2014 answer already delivered via turn-flush)" }] };
+      }
+      if (replySubstantive && ownerTurn != null) {
+        ownerTurn.answerDelivered = true;
+      }
     }
   }
   const files = args.files ?? [];
@@ -92201,6 +92298,8 @@ function handleSessionEvent(ev) {
           finalAnswerDelivered: false,
           finalAnswerSubstantive: false,
           finalAnswerEverDelivered: false,
+          answerDelivered: false,
+          endedAt: null,
           firstPingAt: null,
           firstPingWasSubstantive: false,
           silentAnchorMessageId: null,
@@ -92677,6 +92776,9 @@ function handleSessionEvent(ev) {
           }
           turn.finalAnswerDelivered = true;
           turn.finalAnswerSubstantive = true;
+          if (capturedText.trim().length >= FLUSH_SUBSTANTIVE_MIN_CHARS) {
+            turn.answerDelivered = true;
+          }
           const cardTakeover = progressDriver?.takeOverCard({
             chatId: backstopChatId,
             threadId: backstopThreadId != null ? String(backstopThreadId) : undefined
@@ -92789,6 +92891,7 @@ function handleSessionEvent(ev) {
               sendThrew = true;
               process.stderr.write(`telegram gateway: turn-flush send failed: ${err.message}
 `);
+              turn.answerDelivered = false;
               if (backstopCtrl)
                 backstopCtrl.finalize("error");
             } finally {
@@ -99338,7 +99441,10 @@ var didOneTimeSetup = false;
             })();
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== "0";
             const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS);
-            workerActivityFeed?.stop();
+            if (workerActivityFeed != null) {
+              workerActivityFeed.purgeAllOnBoot();
+              workerActivityFeed.stop();
+            }
             workerActivityFeed = createWorkerActivityFeed({
               bot: {
                 sendMessage: async (cid, text5, sendOpts) => {
@@ -99356,6 +99462,7 @@ var didOneTimeSetup = false;
               floodWaitRemainingMs: probeFloodWaitRemainingMs,
               maxRows: workerFeedMaxRows,
               staleWorkerTtlMs: resolveInflightTerminalCapMs() + WORKER_FEED_STALE_TTL_MARGIN_MS,
+              absoluteRowLifetimeCapMs: resolveInflightTerminalCapMs() * WORKER_FEED_ABSOLUTE_ROW_LIFETIME_CAP_MULTIPLE,
               reconcilePin: ({ feedKey, chatId, messageId }) => {
                 if (!PIN_STATUS_WHILE_WORKING)
                   return;

package/telegram-plugin/gateway/gateway.ts

@@ -88,7 +88,7 @@ import {
   type TelegraphAccount,
 } from '../telegraph.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
-import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
+import { FlushedTurnSupersedeRegistry, DEFAULT_SUPERSEDE_TTL_MS } from '../flushed-turn-supersede.js'
 import { createInboundCoalescer, inboundCoalesceKey } from './inbound-coalesce.js'
 import {
   splitCoalescedAttachments,
@@ -400,7 +400,12 @@ import {
 import {
   decideTurnFlush,
   isTurnFlushSafetyEnabled,
+  FLUSH_SUBSTANTIVE_MIN_CHARS,
 } from '../turn-flush-safety.js'
+import {
+  resolveReplyOwnerTurnId,
+  decideAnswerLatchSuppression,
+} from '../reply-owner-resolve.js'
 // PR A — deterministic answer-ready quiescence flush (late-delivery fix).
 import {
   AnswerReadyFlushController,
@@ -2036,6 +2041,28 @@ const WORKER_FEED_FALLBACK_LOG_CAP = 256
  * slot, never a live-but-quiet worker. 5 min.
  */
 const WORKER_FEED_STALE_TTL_MARGIN_MS = 5 * 60_000
+/**
+ * Multiple of the watcher's in-flight terminal cap used to derive the worker-
+ * feed ABSOLUTE row-lifetime cap (`absoluteRowLifetimeCapMs`). Unlike the
+ * silence-keyed `staleWorkerTtlMs` backstop, the absolute cap is anchored to a
+ * row's immutable creation time, so it reaps an immortal card even when the row
+ * keeps receiving `update()` cues that reset `lastUpdateAt` every heartbeat
+ * (the Carrie 5h zombie-pin leak, re-edited 3000+ times, that the silence sweep
+ * could never match). At the 45-min default cap this yields a 3-hour absolute
+ * ceiling — comfortably above any legitimate single worker's lifetime, so it
+ * can only ever bite a genuine leak, while bounding a ghost card well UNDER the
+ * ~5h symptom Ken hit (the initial 8x/6h was too loose). Derived from the same
+ * base as `staleWorkerTtlMs` — the watcher's effective in-flight terminal cap
+ * (`resolveInflightTerminalCapMs()`: the `SWITCHROOM_SUBAGENT_INFLIGHT_TERMINAL_
+ * CAP_MS` env override, else the 45-min default) — never a bare magic number, so
+ * it tracks the env-level terminal-cap override in lockstep with the silence
+ * backstop. (Both this and `staleWorkerTtlMs` call `resolveInflightTerminalCapMs()`
+ * with NO arg, matching the watcher's OWN effective value here: the gateway does
+ * not pass a config-file `inflightTerminalCapMs` to `startSubagentWatcher`, so
+ * there is no config-file override to thread through — env + default is the
+ * complete override surface on this path.)
+ */
+const WORKER_FEED_ABSOLUTE_ROW_LIFETIME_CAP_MULTIPLE = 4
 const workerFeedOwnerDmFallbackLogged = new Set<string>()
 
 /**
@@ -3104,6 +3131,27 @@ type CurrentTurn = {
   // false ONLY at turn start, mirroring `activityEverOpened`'s sticky-true
   // contract.
   finalAnswerEverDelivered: boolean
+  // 2026-07 double-reply-on-DM fix (Part 2 — race backstop). Set true
+  // SYNCHRONOUSLY at turn-flush FIRE time (before the ~500 ms async send and
+  // before `flushedTurnSupersede.record`) when the flush delivers a SUBSTANTIVE
+  // (≥`FLUSH_SUBSTANTIVE_MIN_CHARS`) terminal answer, and also set when a
+  // substantive `reply` sends. It persists on the ended turn in
+  // `recentTurnsById`, so a LATE reply landing in the flush's post-fire
+  // pre-record race window (where `flushedTurnSupersede` finds no record to
+  // delete yet) resolves this turn via the unified owner resolver, sees the
+  // latch already set, and suppresses itself — closing the residual window Part
+  // 1's supersede cannot reach. Scoped to the substantive floor so an interim
+  // sub-floor ack NEITHER sets nor trips it. Reset false at turn start.
+  answerDelivered: boolean
+  // 2026-07 double-reply-on-DM fix (F2 — recency bound). Wall-clock ms the turn
+  // ENDED (stamped once by `endCurrentTurnAtomic`), or null while still live.
+  // The `findLatestEndedTurnForChat` supersede tier carries DESTRUCTIVE
+  // authority (it drives message deletion), so `resolveReplyOwnerTurn` only
+  // honours a latest-ended turn whose `endedAt` is within the supersede TTL —
+  // otherwise a late reply belonging to an OLDER turn could resolve its owner to
+  // a NEWER turn sitting at the registry tail and delete that newer turn's legit
+  // answer. Unbounded routing use of `findLatestEndedTurnForChat` is unaffected.
+  endedAt: number | null
   // #1675 (over-ping safety net): wall-clock ms of the first reply
   // this turn that landed with `disable_notification: false` (a real
   // device ping). The conversational-pacing contract
@@ -3608,6 +3656,55 @@ function findLatestEndedTurnForChat(chatId: string): CurrentTurn | null {
   return latest
 }
 
+/**
+ * 2026-07 double-reply-on-DM fix (Part 1). Resolve the turn that OWNS a landing
+ * reply using the SAME full chain the thread-router uses, so the supersede
+ * resolver can never again diverge from routing (the exact bug: supersede
+ * omitted the quoted-message and latest-ended recoveries, so a DM late reply —
+ * no live turn, no `origin_turn_id` — resolved to a null owner and its flush
+ * message was never superseded → duplicate).
+ *
+ * Precedence (first non-null wins), delegated to the pure
+ * `resolveReplyOwnerTurnId` so the exact precedence is unit-tested:
+ *   1. the live `currentTurn` passed in (null once the flush nulled the atom);
+ *   2. `findTurnByOriginId(origin_turn_id)` — the model echo;
+ *   3. `findTurnByQuotedMessageId(chat_id, reply_to)` — framework-owned quote;
+ *   4. `findLatestEndedTurnForChat(chat_id)` — the chat's last-ended turn.
+ * Returns the CurrentTurn for the winning id (so callers can read its
+ * `answerDelivered` latch), or null when every lookup missed.
+ */
+function resolveReplyOwnerTurn(
+  liveTurn: CurrentTurn | null,
+  chatId: string,
+  args: Record<string, unknown>,
+): CurrentTurn | null {
+  const origin = findTurnByOriginId(args.origin_turn_id as string | undefined)
+  const quoted = findTurnByQuotedMessageId(chatId, args.reply_to)
+  const latestEnded = findLatestEndedTurnForChat(chatId)
+  const byId = new Map<string, CurrentTurn>()
+  // Populate lowest-precedence first so a higher tier's turn wins the id slot
+  // when two lookups resolve the same turn (they carry the same turnId anyway).
+  for (const t of [latestEnded, quoted, origin, liveTurn]) {
+    if (t != null) byId.set(t.turnId, t)
+  }
+  // F2 — bound the DESTRUCTIVE latest-ended tier to the supersede TTL so a stale
+  // latest-ended turn can't inherit deletion authority over a newer turn's flush
+  // record. `endedAt` is null only for a turn still resolvable but not yet ended
+  // (not a supersede risk); leave the age unset then (unbounded) rather than
+  // fabricate one.
+  const latestEndedAgeMs =
+    latestEnded?.endedAt != null ? Date.now() - latestEnded.endedAt : null
+  const winnerId = resolveReplyOwnerTurnId({
+    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
+}
+
 /**
  * Resolve the answer-reply thread AND emit `reply-route` telemetry. The
  * 2026-06-05 triage showed reply routing was the blind spot: `reply: invoked`
@@ -4842,6 +4939,12 @@ function endCurrentTurnAtomic(
   // the turn got), plus a DEGRADED warning when the turn did tool work but the
   // live feed never opened because its sends failed (the resume-400 signature).
   const turnEndedAt = Date.now()
+  // 2026-07 double-reply-on-DM fix (F2) — stamp the turn's end time so the
+  // `findLatestEndedTurnForChat` supersede tier can be recency-bounded to the
+  // supersede TTL (a stale latest-ended turn must not inherit deletion
+  // authority over a newer turn's flush record). Set once; idempotent on the
+  // deferRecord flush path (which calls this synchronously before its send).
+  turn.endedAt = turnEndedAt
   process.stderr.write(
     `telegram gateway: ${formatTurnLifecycle('clear', 'turn_end', turn, turnEndedAt)}\n`,
   )
@@ -12925,17 +13028,21 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // so a fresh turn's answer is never clobbered.
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
-    // Resolve the turnId this reply belongs to by IDENTITY, not just the live
-    // `currentTurn`. A late reply lands with `currentTurn == null` (silence poke
-    // cleared it — Bug D) or with a transiently-cleared currentTurn while its own
-    // turn is really still the owner (LOW-1); in both cases the turn is still
-    // resolvable from the `origin_turn_id` nonce the model echoes back (Tier 2 —
-    // the same last-known-turn resolver the chat-routing / obligation code uses).
-    // Passing this resolved turnId means supersede matches the flushed record by
-    // identity instead of falling back to a null-liveTurnId branch that would
-    // otherwise be free to delete a DIFFERENT turn's legitimate message.
-    const resolvedTurnId =
-      turn?.turnId ?? findTurnByOriginId(args.origin_turn_id as string | undefined)?.turnId ?? null
+    // 2026-07 double-reply-on-DM fix (Part 1) — resolve the turn this reply
+    // belongs to by IDENTITY, via the SAME full chain the thread-router uses
+    // (`resolveReplyOwnerTurn`): live `currentTurn`, then the model-echoed
+    // `origin_turn_id`, then the framework-owned quoted message id, then the
+    // chat's most-recently-ended turn. The prior chain stopped at
+    // `currentTurn ?? findTurnByOriginId`, so a DM late reply — `currentTurn`
+    // nulled by the flush's synthetic turn_end AND no `origin_turn_id` (a
+    // supergroup-only field) — resolved to a null owner. `decideSupersede`
+    // deliberately never lets a null live turn supersede a turnId-bearing flush
+    // record, so message A survived AND the reply shipped message B (the exact
+    // 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 resolvedTurnId = ownerTurn?.turnId ?? null
     const decision = flushedTurnSupersede.take(
       chat_id,
       replyThreadId,
@@ -12952,6 +13059,46 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
           { chat_id, verb: 'reply.supersedeFlushed' },
         )
       }
+    } else {
+      // 2026-07 double-reply-on-DM fix (Part 2) — answer-delivered race latch.
+      // Supersede found no record. Either there was no flush (normal reply), or
+      // the flush FIRED but has not yet recorded its message ids (the residual
+      // pre-record race Part 1's supersede cannot reach). The flush sets
+      // `answerDelivered = true` synchronously at fire time (before its async
+      // send AND before `record`), and it persists on the ended turn — so when
+      // this LATE, substantive reply resolves its owner turn and sees the latch
+      // already set, the flush's message A is already on its way out and this
+      // reply would ship a duplicate. Suppress it. Scoped to the substantive
+      // ≥`FLUSH_SUBSTANTIVE_MIN_CHARS` floor and the late-reply case so an
+      // interim sub-floor ack, a chunked multi-part answer, or a legitimate
+      // second in-turn substantive reply (live `currentTurn`) is never
+      // suppressed. `isSubstantiveFinalReply` reduces to the ≥200-char test on
+      // the `reply` path (no `done`); pass the model's original notification
+      // intent to mirror the #2533 decoupling call shape.
+      const replySubstantive = isSubstantiveFinalReply({
+        text: rawText,
+        disableNotification: args.disable_notification === true,
+      })
+      const suppressByLatch = decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive,
+        isLateReply: turn == null,
+        ownerAnswerDelivered: ownerTurn?.answerDelivered ?? false,
+      })
+      if (suppressByLatch) {
+        process.stderr.write(
+          `telegram gateway: reply: suppressed by answer-delivered latch ` +
+          `(flush already delivered this turn's answer) chatId=${chat_id} ` +
+          `ownerTurnId=${JSON.stringify(resolvedTurnId)}\n`,
+        )
+        return { content: [{ type: 'text', text: 'sent (deduped — answer already delivered via turn-flush)' }] }
+      }
+      // A substantive answer is going out via this reply — set the latch on its
+      // owner turn so a later bridge-replayed / reworded duplicate of the same
+      // answer is caught by the branch above.
+      if (replySubstantive && ownerTurn != null) {
+        ownerTurn.answerDelivered = true
+      }
     }
   }
 
@@ -16880,6 +17027,11 @@ function handleSessionEvent(ev: SessionEvent): void {
           finalAnswerSubstantive: false,
           // Sticky latch — reset ONLY here (turn start), never by reopen.
           finalAnswerEverDelivered: false,
+          // 2026-07 double-reply-on-DM fix (Part 2) — answer-delivered race
+          // latch, reset at turn start alongside the other answer flags.
+          answerDelivered: false,
+          // 2026-07 double-reply-on-DM fix (F2) — stamped at turn end.
+          endedAt: null,
           firstPingAt: null,
           // Notification ownership (R8 / PR-2): no slot claimed yet, so the
           // "claimer was substantive" flag starts false. Set atomically with
@@ -18113,6 +18265,20 @@ function handleSessionEvent(ev: SessionEvent): void {
         // the silent-end re-prompt. (Belt-and-braces, like the set above —
         // this branch returns before any further tool_label can arrive.)
         turn.finalAnswerSubstantive = true
+        // 2026-07 double-reply-on-DM fix (Part 2) — arm the answer-delivered
+        // race latch NOW, synchronously, BEFORE the ~500 ms async send below and
+        // BEFORE `flushedTurnSupersede.record`. A late reply that lands in the
+        // post-fire pre-record window resolves this turn (via the unified owner
+        // resolver, reading the atom preserved in `recentTurnsById`) and
+        // suppresses itself against this latch — closing the residual race Part
+        // 1's supersede cannot reach. Scoped to a SUBSTANTIVE terminal answer
+        // (the same ≥`FLUSH_SUBSTANTIVE_MIN_CHARS` floor the codebase uses to
+        // recognise a real answer) so a short flush never latches against a
+        // legitimate substantive reply. `capturedText` here is the selected,
+        // normalized flush delivery text.
+        if (capturedText.trim().length >= FLUSH_SUBSTANTIVE_MIN_CHARS) {
+          turn.answerDelivered = true
+        }
 
         // #654 deterministic double-message fix. Hand off the pinned
         // progress card BEFORE state reset so the driver doesn't keep
@@ -18352,6 +18518,22 @@ function handleSessionEvent(ev: SessionEvent): void {
           } catch (err) {
             sendThrew = true
             process.stderr.write(`telegram gateway: turn-flush send failed: ${(err as Error).message}\n`)
+            // 2026-07 double-reply-on-DM fix (F1) — the flush armed
+            // `answerDelivered` synchronously at FIRE time, but the send just
+            // FAILED. When nothing was delivered the supersede record was NOT
+            // written (gated on `sentIds.length > 0` above), so Part 1 can never
+            // fire for this turn — leaving the latch armed would make a genuine
+            // late reply suppress itself and the user would get ZERO messages
+            // (silent answer loss; on main that path still delivers the reply).
+            // Reset the latch so the late reply is NOT suppressed. On a PARTIAL
+            // send (sentIds > 0) the record WAS written, so Part 1's supersede
+            // deletes the partial message A and the reply delivers cleanly —
+            // resetting here is harmless in that case too.
+            // FOLLOW-UP (coordinator to file an issue): a reply suppressed
+            // synchronously DURING the in-flight send that then fails is not
+            // fully closable with a boolean latch — a residual micro-window the
+            // supersede+latch pair cannot eliminate. Not addressed in this PR.
+            turn.answerDelivered = false
             // #1713: backstop send failed — finalize as error so the
             // turn ends cleanly with 😱 rather than leaving it open.
             if (backstopCtrl) backstopCtrl.finalize('error')
@@ -30102,7 +30284,16 @@ void (async () => {
             // or the turn ended while it kept running — extended autonomous
             // work) is surfaced via the worker feed instead of vanishing.
             const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS)
-            workerActivityFeed?.stop()
+            // Boot/reconnect purge (Ken, PR #3239 review): every row in the
+            // OUTGOING feed is a dead child sub-agent, and its `wk:group:` pins
+            // would otherwise be orphaned — the replacement feed is empty and
+            // never knew those groups, so it can never unpin them, and no full-
+            // boot pin sweep runs on a bare bridge reconnect. Reconcile the old
+            // feed to empty and release all its group pins BEFORE stopping it.
+            if (workerActivityFeed != null) {
+              workerActivityFeed.purgeAllOnBoot()
+              workerActivityFeed.stop()
+            }
             workerActivityFeed = createWorkerActivityFeed({
               // #2669: worker-feed body is raw GFM markdown — send via rich.
               bot: {
@@ -30167,6 +30358,12 @@ void (async () => {
               // force-collapsing a row the terminal signals somehow never
               // removed.
               staleWorkerTtlMs: resolveInflightTerminalCapMs() + WORKER_FEED_STALE_TTL_MARGIN_MS,
+              // ABSOLUTE row-lifetime cap — anchored to a row's creation, immune
+              // to the `lastUpdateAt` reset that lets an immortal-but-updating
+              // row dodge `staleWorkerTtlMs` forever (Carrie 5h zombie pin).
+              // Derived from the same terminal cap so it tracks operator
+              // overrides; 4× → ~3h at the 45-min default.
+              absoluteRowLifetimeCapMs: resolveInflightTerminalCapMs() * WORKER_FEED_ABSOLUTE_ROW_LIFETIME_CAP_MULTIPLE,
               // #3207 review: GROUP-level status pin. Workers now coalesce into
               // ONE shared message, so the pin must follow the GROUP lifecycle,
               // not a single worker's — otherwise a sibling's finish unpins a