switchroom 0.19.23 → 0.19.24

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

@@ -21042,17 +21042,19 @@ var init_schema = __esm(() => {
     model: exports_external.string().min(1).optional().describe("Per-op model (upstream `HINDSIGHT_API_<OP>_LLM_MODEL`). Absent \u2192 " + "inherit the global `hindsight.llm.model`."),
     provider: exports_external.string().min(1).optional().describe("Per-op provider (upstream `HINDSIGHT_API_<OP>_LLM_PROVIDER`). " + "Absent \u2192 inherit the global `hindsight.llm.provider`."),
     base_url: exports_external.string().min(1).optional().describe("Per-op base URL (upstream `HINDSIGHT_API_<OP>_LLM_BASE_URL`). " + "Optional passthrough; absent \u2192 inherit the global."),
-    api_key: exports_external.string().min(1).optional().describe("Per-op API key (upstream `HINDSIGHT_API_<OP>_LLM_API_KEY`). Literal " + "or `vault:` reference. Optional passthrough; absent \u2192 inherit global.")
+    api_key: exports_external.string().min(1).optional().describe("Per-op API key (upstream `HINDSIGHT_API_<OP>_LLM_API_KEY`). Literal " + "or `vault:` reference. Optional passthrough; absent \u2192 inherit global."),
+    context_window: exports_external.number().int().positive().optional().describe("Context window (tokens) of the backend serving THIS op. NOT an " + "upstream env var \u2014 switchroom derives the op's token budget " + "(consolidation batch size / max-completion caps / reflect " + "max-context cap) from it so a single call can never overflow the " + "window. Absent \u2192 inherit " + "`hindsight.llm.context_window`, else a per-provider default " + "(conservative for non-`claude-code` providers, which usually mean " + "a local llama.cpp/Ollama slot; a self-hosted `base_url` \u2014 loopback, " + "RFC1918, `.local`/`.internal` \u2014 forces the conservative default too, " + "regardless of the provider NAME, since the endpoint is where the " + "traffic actually terminates). All three lanes (`retain`, " + "`reflect`, `consolidation`) are budgeted independently.")
   }).describe("Per-operation LLM override. Every field optional; an unset field (or " + "an omitted op block) inherits the global `hindsight.llm.*`, which is " + "already the engine's fallback \u2014 switchroom emits only the vars set.");
   HindsightConfigSchema = exports_external.object({
     llm: exports_external.object({
       provider: exports_external.string().min(1).optional().describe("Hindsight LLM provider (upstream `HINDSIGHT_API_LLM_PROVIDER`). " + "Defaults to `claude-code` (subscription-honest, broker-fed OAuth). " + "Any litellm-routable provider the upstream image supports is valid. " + "Serves as the GLOBAL default for every op absent a per-op override."),
       model: exports_external.string().min(1).optional().describe("Hindsight LLM model (upstream `HINDSIGHT_API_LLM_MODEL`). Defaults " + "to HINDSIGHT_DEFAULT_MODEL. Any model your LiteLLM proxy can route " + "is valid, e.g. `openrouter/z-ai/glm-5.2` when routing through the " + "fleet proxy. With provider=claude-code this value is ALSO exported " + "as `ANTHROPIC_MODEL` to the claude subprocess. Serves as the GLOBAL " + "default for every op absent a per-op override."),
+      context_window: exports_external.number().int().positive().optional().describe("GLOBAL context window (tokens) of the backend serving hindsight's " + "LLM ops \u2014 the declared size switchroom derives every token budget " + "from. Set this to the real window of whatever you point " + "`hindsight.llm` at (e.g. 32768 for a llama.cpp slot launched with " + "`-c 65536 -np 2`, 131072 for a large-window OpenRouter model). " + "Absent \u2192 a per-provider default: 200000 for `claude-code`, a " + "conservative 32768 for everything else. Overflowing a local " + "backend's window does NOT error \u2014 llama.cpp context-shift silently " + "drops the system prompt and the model answers conversationally " + "with HTTP 200 \u2014 so this value is what makes the failure " + "detectable at setup time instead of never."),
       retain: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `retain` LLM op (memory ingestion). Emits " + "`HINDSIGHT_API_RETAIN_LLM_*`. Absent \u2192 uses the global model/provider."),
       reflect: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `reflect` LLM op (synthesis / mental-model " + "refresh). Emits `HINDSIGHT_API_REFLECT_LLM_*`. Absent \u2192 uses global."),
       consolidation: HindsightPerOpLlmSchema.optional().describe("Per-op override for the `consolidation` LLM op (background memory " + "merge). Emits `HINDSIGHT_API_CONSOLIDATION_LLM_*`. Absent \u2192 global.")
     }).optional().describe("LLM knob for the hindsight container. The flat `provider`/`model` set " + "the global default (backward-compatible); optional `retain`/`reflect`/" + "`consolidation` blocks override individual ops. All fields optional; " + "unset fields fall back to the hard-coded defaults."),
-    env: exports_external.record(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional().describe("Operator overrides for switchroom's capability-gated Hindsight " + "performance defaults. Only the keys switchroom actually manages are " + "honoured (`HINDSIGHT_PERF_ENV_KEYS` in " + "src/setup/hindsight-perf-defaults.ts: RERANKER_LOCAL_FP16, " + "LLM_MAX_CONCURRENT, RETAIN/CONSOLIDATION_LLM_MAX_CONCURRENT, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT), plus the " + "embedded-PostgreSQL (pg0) sizing keys switchroom manages in " + "src/setup/hindsight-pg-defaults.ts (`HINDSIGHT_PG_ENV_KEYS`: " + "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE, " + "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS \u2014 a postgres size string such " + "as `4GB`, or the sentinel `off` to leave pg0's own default for that " + "one knob). A value set here " + "REPLACES switchroom's default and is emitted even when the gating " + "capability is absent, so an operator can always force a knob. Other " + "`HINDSIGHT_API_*` keys are deliberately IGNORED \u2014 a blanket " + "passthrough would collide with the vars startHindsight() derives " + "itself (HINDSIGHT_API_PORT, the retain token/deadline budget).")
+    env: exports_external.record(exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean()])).optional().describe("Operator overrides for switchroom's capability-gated Hindsight " + "performance defaults. Only the keys switchroom actually manages are " + "honoured (`HINDSIGHT_PERF_ENV_KEYS` in " + "src/setup/hindsight-perf-defaults.ts: RERANKER_LOCAL_FP16, " + "RERANKER_LOCAL_BATCH_SIZE, LLM_MAX_CONCURRENT, " + "RETAIN/CONSOLIDATION_LLM_MAX_CONCURRENT, LLM_STRICT_SCHEMA, " + "LLM_MAX_RETRIES, CONSOLIDATION_LLM_PARALLELISM, " + "RECALL_MAX_CANDIDATES_PER_SOURCE, LINK_EXPANSION_PER_ENTITY_LIMIT, " + "LINK_EXPANSION_TIMEOUT, LLM_REASONING_EFFORT), the override-only keys " + "switchroom manages but ships NO default for " + "(`HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS`: " + "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY \u2014 a per-deployment " + "`bank-pattern:priority,...` map; unset means upstream's flat " + "created_at FIFO across banks), plus the " + "embedded-PostgreSQL (pg0) sizing keys switchroom manages in " + "src/setup/hindsight-pg-defaults.ts (`HINDSIGHT_PG_ENV_KEYS`: " + "SWITCHROOM_HINDSIGHT_PG_EFFECTIVE_CACHE_SIZE, " + "SWITCHROOM_HINDSIGHT_PG_SHARED_BUFFERS \u2014 a postgres size string such " + "as `4GB`, or the sentinel `off` to leave pg0's own default for that " + "one knob). A value set here " + "REPLACES switchroom's default and is emitted even when the gating " + "capability is absent, so an operator can always force a knob. Other " + "`HINDSIGHT_API_*` keys are deliberately IGNORED \u2014 a blanket " + "passthrough would collide with the vars startHindsight() derives " + "itself (HINDSIGHT_API_PORT, the retain token/deadline budget).")
   });
   MicrosoftWorkspaceConfigSchema = exports_external.object({
     microsoft_client_id: exports_external.string().min(1).optional().describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id'). OPTIONAL \u2014 omit it to use " + "switchroom's shipped default Microsoft app (zero-config). " + "Set it only to bring your own Entra app (BYO)."),
@@ -63265,7 +63267,8 @@ function createSendGate(config) {
         pending: null,
         running: false,
         suppressedUntilMs: 0,
-        editWindowTs: []
+        editWindowTs: [],
+        criticalWake: null
       };
       perMessage.set(key, state);
     }
@@ -63351,9 +63354,11 @@ function createSendGate(config) {
       }
     }
   }
-  async function admitLoop(buckets, deadline) {
+  async function admitLoop(buckets, deadline, interrupt) {
     let counted = false;
     for (;; ) {
+      if (interrupt?.fired)
+        return false;
       const now = clock.now();
       let wait = 0;
       for (const b of buckets)
@@ -63369,11 +63374,12 @@ function createSendGate(config) {
         counters.queued++;
         counted = true;
       }
-      await clock.sleep(deadline !== undefined ? Math.min(wait, deadline - now) : wait);
+      const nap = clock.sleep(deadline !== undefined ? Math.min(wait, deadline - now) : wait);
+      await (interrupt ? Promise.race([nap, interrupt.promise]) : nap);
     }
   }
-  function admit(buckets) {
-    return admitLoop(buckets);
+  function admit(buckets, interrupt) {
+    return admitLoop(buckets, undefined, interrupt);
   }
   let criticalTail = Promise.resolve();
   function criticalSerialize(job) {
@@ -63391,6 +63397,24 @@ function createSendGate(config) {
       }
     })();
   }
+  function makeInterrupt() {
+    let resolve6;
+    const interrupt = {
+      fired: false,
+      promise: new Promise((r) => {
+        resolve6 = r;
+      })
+    };
+    return {
+      interrupt,
+      fire: () => {
+        if (interrupt.fired)
+          return;
+        interrupt.fired = true;
+        resolve6();
+      }
+    };
+  }
   async function admitPriority(buckets, priority) {
     const now = clock.now();
     if (priority === "cosmetic") {
@@ -63488,7 +63512,18 @@ function createSendGate(config) {
             continue;
           }
         } else {
-          await admit(bucketsFor(opts));
+          const { interrupt, fire } = makeInterrupt();
+          state.criticalWake = fire;
+          let admitted;
+          try {
+            admitted = await admit(bucketsFor(opts), interrupt);
+          } finally {
+            state.criticalWake = null;
+          }
+          if (!admitted) {
+            supersede(state, p);
+            continue;
+          }
         }
         state.lastSentMs = clock.now();
         if (perMessageEditMaxPerWindow > 0 && p.priorityClass === "cosmetic") {
@@ -63513,6 +63548,31 @@ function createSendGate(config) {
       state.running = false;
     }
   }
+  function supersede(state, p) {
+    const next = state.pending;
+    if (!next) {
+      state.pending = p;
+      return;
+    }
+    next.priorityClass = maxPriority(next.priorityClass, p.priorityClass);
+    next.promise.then(p.resolve, p.reject);
+  }
+  function editUnderPressure(state, opts, now) {
+    if (state.suppressedUntilMs > now)
+      return true;
+    for (const b of bucketsFor(opts)) {
+      if (b.msUntilAvailable(now) > 0)
+        return true;
+    }
+    return false;
+  }
+  function settleForCaller(state, pending, opts, priority, now) {
+    if (priority !== "cosmetic" || !editUnderPressure(state, opts, now)) {
+      return pending.promise;
+    }
+    pending.promise.catch(() => {});
+    return Promise.resolve(undefined);
+  }
   function handleEdit(fn, opts) {
     const messageId = opts.messageId;
     const key = messageKey(opts.chat_id, messageId);
@@ -63521,16 +63581,6 @@ function createSendGate(config) {
     const existing = perMessage.get(key);
     maybeEvict(now, existing === undefined);
     const state = existing ?? messageState(key);
-    if ((opts.priorityClass ?? "useful") === "cosmetic") {
-      let wait = 0;
-      for (const b of bucketsFor(opts))
-        wait = Math.max(wait, b.msUntilAvailable(now));
-      const msgWait = state.suppressedUntilMs > now ? state.suppressedUntilMs - now : 0;
-      if (wait > 0 || msgWait > 0) {
-        counters.shed++;
-        return Promise.resolve(SEND_GATE_SHED2);
-      }
-    }
     if (state.pending) {
       state.pending.priorityClass = maxPriority(state.pending.priorityClass, opts.priorityClass ?? "useful");
       if (state.pending.hash !== hash) {
@@ -63538,7 +63588,9 @@ function createSendGate(config) {
         state.pending.hash = hash;
         state.pending.fn = fn;
       }
-      return state.pending.promise;
+      if (state.pending.priorityClass === "critical")
+        state.criticalWake?.();
+      return settleForCaller(state, state.pending, opts, opts.priorityClass ?? "useful", now);
     }
     if (hash === state.lastHash) {
       counters.dropped++;
@@ -63559,9 +63611,13 @@ function createSendGate(config) {
       priorityClass: opts.priorityClass ?? "useful"
     };
     state.pending = pending;
-    if (!state.running)
+    if (state.running) {
+      if (pending.priorityClass === "critical")
+        state.criticalWake?.();
+    } else {
       drive(state, opts);
-    return promise;
+    }
+    return settleForCaller(state, pending, opts, pending.priorityClass, now);
   }
   async function gate(fn, opts) {
     if (!enabled2)
@@ -75869,6 +75925,30 @@ function makeKey3(chatId, threadId) {
 }
 
 // reply-owner-resolve.ts
+function latestEndedAccepted(candidates) {
+  if (candidates.latestEndedTurnId == null)
+    return false;
+  const age = candidates.latestEndedAgeMs;
+  const ttl = candidates.latestEndedTtlMs;
+  if (age === null)
+    return false;
+  if (age === undefined || ttl == null)
+    return true;
+  return age <= ttl;
+}
+function decideContentGateBypass(input) {
+  if (input.tier === "live")
+    return true;
+  if (input.tier === "none")
+    return false;
+  if (input.handbackCouldOwnReply)
+    return false;
+  if (input.candidates == null)
+    return false;
+  if (!latestEndedAccepted(input.candidates))
+    return false;
+  return input.resolvedTurnId != null && input.resolvedTurnId === input.candidates.latestEndedTurnId;
+}
 function decideAnswerLatchSuppression(input) {
   if (input.superseded)
     return false;
@@ -76500,14 +76580,23 @@ async function sendReply(deps, req) {
   let supersedeFlushIds = [];
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
-    const { turn: ownerTurn, tier: ownerTier } = resolveReplyOwnerTurn(turn, chat_id, args);
+    const {
+      turn: ownerTurn,
+      tier: ownerTier,
+      candidates: ownerCandidates
+    } = resolveReplyOwnerTurn(turn, chat_id, args);
     const resolvedTurnId = ownerTurn?.turnId ?? null;
     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 replyIsOwnAnswer = decideContentGateBypass({
+      tier: ownerTier,
+      resolvedTurnId,
+      candidates: ownerCandidates,
+      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)}
@@ -76532,7 +76621,7 @@ async function sendReply(deps, req) {
         replyMatchesFlushedAnswer
       });
       if (decision.reason === "new-content") {
-        process.stderr.write(`telegram gateway: reply: flush supersede declined \u2014 new content (#3429) ` + `chatId=${chat_id} ownerTurnId=${JSON.stringify(resolvedTurnId)}; sending fresh
+        process.stderr.write(`telegram gateway: reply: flush supersede declined \u2014 new content (#3429) ` + `chatId=${chat_id} ownerTurnId=${JSON.stringify(resolvedTurnId)} ` + `tier=${ownerTier} latestEnded=${JSON.stringify(ownerCandidates.latestEndedTurnId)} ` + `handbackInWindow=${handbackCouldOwnReply}; sending fresh
 `);
       }
       if (suppressByLatch) {
@@ -80062,12 +80151,14 @@ function isTurnFlushSafetyEnabled(env = process.env) {
 }
 
 // reply-owner-resolve.ts
-function latestEndedAccepted(candidates) {
+function latestEndedAccepted2(candidates) {
   if (candidates.latestEndedTurnId == null)
     return false;
   const age = candidates.latestEndedAgeMs;
   const ttl = candidates.latestEndedTtlMs;
-  if (age == null || ttl == null)
+  if (age === null)
+    return false;
+  if (age === undefined || ttl == null)
     return true;
   return age <= ttl;
 }
@@ -80078,7 +80169,7 @@ function resolveReplyOwnerTier(candidates) {
     return "origin";
   if (candidates.quotedTurnId != null)
     return "quoted";
-  if (latestEndedAccepted(candidates))
+  if (latestEndedAccepted2(candidates))
     return "latest-ended";
   return "none";
 }
@@ -83038,6 +83129,10 @@ var HINDSIGHT_DEFAULT_LLM_MAX_CONCURRENT = 4;
 var HINDSIGHT_DEFAULT_RETAIN_LLM_MAX_CONCURRENT = 1;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_MAX_CONCURRENT = 1;
 var HINDSIGHT_DEFAULT_RERANKER_LOCAL_FP16 = "true";
+var HINDSIGHT_DEFAULT_RERANKER_LOCAL_BATCH_SIZE = 128;
+var HINDSIGHT_DEFAULT_LLM_STRICT_SCHEMA = "true";
+var HINDSIGHT_DEFAULT_LLM_MAX_RETRIES = 2;
+var HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM = 2;
 var HINDSIGHT_PERF_DEFAULTS_UNGATED = [
   [
     "HINDSIGHT_API_RECALL_MAX_CANDIDATES_PER_SOURCE",
@@ -83051,10 +83146,18 @@ var HINDSIGHT_PERF_DEFAULTS_UNGATED = [
     "HINDSIGHT_API_LINK_EXPANSION_TIMEOUT",
     String(HINDSIGHT_DEFAULT_LINK_EXPANSION_TIMEOUT_S)
   ],
-  ["HINDSIGHT_API_LLM_REASONING_EFFORT", HINDSIGHT_DEFAULT_LLM_REASONING_EFFORT]
+  ["HINDSIGHT_API_LLM_REASONING_EFFORT", HINDSIGHT_DEFAULT_LLM_REASONING_EFFORT],
+  [
+    "HINDSIGHT_API_CONSOLIDATION_LLM_PARALLELISM",
+    String(HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_PARALLELISM)
+  ]
 ];
 var HINDSIGHT_PERF_DEFAULTS_GPU = [
-  ["HINDSIGHT_API_RERANKER_LOCAL_FP16", HINDSIGHT_DEFAULT_RERANKER_LOCAL_FP16]
+  ["HINDSIGHT_API_RERANKER_LOCAL_FP16", HINDSIGHT_DEFAULT_RERANKER_LOCAL_FP16],
+  [
+    "HINDSIGHT_API_RERANKER_LOCAL_BATCH_SIZE",
+    String(HINDSIGHT_DEFAULT_RERANKER_LOCAL_BATCH_SIZE)
+  ]
 ];
 var HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM = [
   ["HINDSIGHT_API_LLM_MAX_CONCURRENT", String(HINDSIGHT_DEFAULT_LLM_MAX_CONCURRENT)],
@@ -83065,13 +83168,21 @@ var HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM = [
   [
     "HINDSIGHT_API_CONSOLIDATION_LLM_MAX_CONCURRENT",
     String(HINDSIGHT_DEFAULT_CONSOLIDATION_LLM_MAX_CONCURRENT)
-  ]
+  ],
+  ["HINDSIGHT_API_LLM_STRICT_SCHEMA", HINDSIGHT_DEFAULT_LLM_STRICT_SCHEMA],
+  ["HINDSIGHT_API_LLM_MAX_RETRIES", String(HINDSIGHT_DEFAULT_LLM_MAX_RETRIES)]
 ];
+var HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS = new Set([
+  "HINDSIGHT_API_WORKER_CONSOLIDATION_BANK_PRIORITY"
+]);
 var HINDSIGHT_PERF_ENV_KEYS = new Set([
-  ...HINDSIGHT_PERF_DEFAULTS_UNGATED,
-  ...HINDSIGHT_PERF_DEFAULTS_GPU,
-  ...HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM
-].map(([k]) => k));
+  ...[
+    ...HINDSIGHT_PERF_DEFAULTS_UNGATED,
+    ...HINDSIGHT_PERF_DEFAULTS_GPU,
+    ...HINDSIGHT_PERF_DEFAULTS_LOCAL_LLM
+  ].map(([k]) => k),
+  ...HINDSIGHT_PERF_OVERRIDE_ONLY_KEYS
+]);
 
 // ../src/setup/hindsight-pg-defaults.ts
 var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 8 * 1024;
@@ -83094,6 +83205,10 @@ var HINDSIGHT_PG_DEFAULTS = [
 ];
 var HINDSIGHT_PG_ENV_KEYS = new Set(HINDSIGHT_PG_DEFAULTS.map(([k]) => k));
 
+// ../src/setup/hindsight-context-budget.ts
+var HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE = 3000;
+var HINDSIGHT_RETAIN_MAX_COMPLETION_FLOOR = HINDSIGHT_UPSTREAM_RETAIN_CHUNK_SIZE + 72;
+
 // ../src/setup/hindsight.ts
 var HINDSIGHT_DEFAULT_API_PORT = 18888;
 var HINDSIGHT_DEFAULT_MCP_URL = `http://127.0.0.1:${HINDSIGHT_DEFAULT_API_PORT}/mcp/`;
@@ -88540,6 +88655,19 @@ function resolveAnswerThreadId(input) {
   return input.liveThreadId;
 }
 
+// gateway/latest-turn-lookup.ts
+function latestTurnForChat(turns, chatId, opts) {
+  let latest = null;
+  for (const t of turns) {
+    if (t.sessionChatId !== chatId)
+      continue;
+    if (opts.endedOnly && t.endedAt == null)
+      continue;
+    latest = t;
+  }
+  return latest;
+}
+
 // gateway/turns-jsonl-rotate.ts
 var TURNS_JSONL_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_AGENT_STATE_DIR = "/state/agent";
@@ -96421,10 +96549,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.23";
-var COMMIT_SHA = "56e3c01e";
-var COMMIT_DATE = "2026-07-26T13:24:39Z";
-var LATEST_PR = 3711;
+var VERSION2 = "0.19.24";
+var COMMIT_SHA = "0fa8ffb8";
+var COMMIT_DATE = "2026-07-27T05:19:34Z";
+var LATEST_PR = 3744;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -99395,18 +99523,13 @@ function findTurnByOriginId(originTurnId) {
   return recentTurnsById.get(originTurnId) ?? null;
 }
 var LATE_REPLY_TOPIC_RECOVERY_ENABLED = process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== "0";
-function findLatestEndedTurnForChat(chatId) {
-  let latest = null;
-  for (const t of recentTurnsById.values()) {
-    if (t.sessionChatId === chatId)
-      latest = t;
-  }
-  return latest;
+function findLatestTurnForChat(chatId, opts) {
+  return latestTurnForChat(recentTurnsById.values(), chatId, opts);
 }
 function resolveReplyOwnerTurn(liveTurn, chatId, args) {
   const origin = findTurnByOriginId(args.origin_turn_id);
   const quoted = findTurnByQuotedMessageId(chatId, args.reply_to);
-  const latestEnded = findLatestEndedTurnForChat(chatId);
+  const latestEnded = findLatestTurnForChat(chatId, { endedOnly: true });
   const byId = new Map;
   for (const t of [latestEnded, quoted, origin, liveTurn]) {
     if (t != null)
@@ -99423,10 +99546,10 @@ function resolveReplyOwnerTurn(liveTurn, chatId, args) {
   };
   const tier = resolveReplyOwnerTier(candidates);
   const winnerId = resolveReplyOwnerTurnId(candidates);
-  return { turn: winnerId != null ? byId.get(winnerId) ?? null : null, tier };
+  return { turn: winnerId != null ? byId.get(winnerId) ?? null : null, tier, candidates };
 }
 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 recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestTurnForChat(chatId, { endedOnly: false }) : null;
   const threadId = resolveAnswerThreadId({
     explicitThreadId,
     originResolved: originTurn != null,

package/telegram-plugin/gateway/gateway.ts

@@ -489,7 +489,7 @@ import {
 import {
   resolveReplyOwnerTurnId,
   resolveReplyOwnerTier,
-  type ReplyOwnerTier,
+  type ReplyOwnerTier, type ReplyOwnerCandidates,
   type AnswerDeliveredLatch,
 } from '../reply-owner-resolve.js'
 import { SubagentHandbackMarker } from './subagent-handback-marker.js'
@@ -717,6 +717,7 @@ import {
 } from './emission-authority.js'
 import { CurrentTurnMap } from './current-turn-map.js'
 import { resolveAnswerThreadId } from './answer-thread-resolve.js'
+import { latestTurnForChat } from './latest-turn-lookup.js'
 import { decideObligationTurnEnd } from './obligation-turn-end.js'
 import { maybeRotate, resolveAgentStateDir, resolveTurnsJsonlPath } from './turns-jsonl-rotate.js'
 import {
@@ -3484,12 +3485,14 @@ export type CurrentTurn = {
   flushedAnswerText: string | null
   // 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 —
+  // The `latest-ended` supersede tier carries DESTRUCTIVE authority (it drives
+  // message deletion), so `resolveReplyOwnerTurn` only honours a latest-ended
+  // turn whose `endedAt` is non-null (#3725 — the registry is populated at turn
+  // START, so the tail entry may still be RUNNING) AND 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.
+  // a NEWER turn at the registry tail and delete that turn's legit answer. The
+  // unbounded ROUTING use (`endedOnly: false`) is unaffected: it only picks a
+  // topic to deliver into and deletes nothing.
   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
@@ -3999,21 +4002,18 @@ const LATE_REPLY_TOPIC_RECOVERY_ENABLED =
   process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== '0'
 
 /**
- * The most-recently-started turn for a chat from the bounded recently-ended
- * registry — the deterministic fallback for a LATE answer reply when the model
- * echoed no `origin_turn_id` and `currentTurn` has already cleared. Iterates in
- * insertion order so the last match is the most recent turn for that chat.
- * Returns null when the chat has no remembered turn (so the caller keeps the
- * legacy result). NB: this is the chat's own most-recent TURN, not the
- * `chatThreadMap` last-seen-any-message heuristic that caused the wrong-topic
- * bug — a late reply almost always belongs to the turn that just ended.
+ * The most recent turn for a chat from the bounded recent-turn registry — the
+ * deterministic fallback for a LATE answer reply when the model echoed no
+ * `origin_turn_id` and `currentTurn` has already cleared. Returns null when the
+ * chat has no matching turn (so the caller keeps the legacy result). NB: this is
+ * the chat's own most-recent TURN, not the `chatThreadMap` last-seen-any-message
+ * heuristic that caused the wrong-topic bug. `endedOnly` selects the consumer's
+ * semantics — routing takes the tail entry even when that turn is still RUNNING;
+ * the destructive `latest-ended` owner tier takes only a genuinely ENDED turn,
+ * because the registry is populated at turn START (#3725; see the module).
  */
-function findLatestEndedTurnForChat(chatId: string): CurrentTurn | null {
-  let latest: CurrentTurn | null = null
-  for (const t of recentTurnsById.values()) {
-    if (t.sessionChatId === chatId) latest = t
-  }
-  return latest
+function findLatestTurnForChat(chatId: string, opts: { endedOnly: boolean }): CurrentTurn | null {
+  return latestTurnForChat(recentTurnsById.values(), chatId, opts)
 }
 
 /**
@@ -4029,7 +4029,7 @@ function findLatestEndedTurnForChat(chatId: string): CurrentTurn | null {
  *   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.
+ *   4. `findLatestTurnForChat(chat_id, {endedOnly:true})` — last ENDED turn.
  * Returns the CurrentTurn for the winning id (so callers can read its
  * `answerDelivered` latch), or null when every lookup missed.
  */
@@ -4037,10 +4037,10 @@ function resolveReplyOwnerTurn(
   liveTurn: CurrentTurn | null,
   chatId: string,
   args: Record<string, unknown>,
-): { turn: CurrentTurn | null; tier: ReplyOwnerTier } {
+): { turn: CurrentTurn | null; tier: ReplyOwnerTier; candidates: ReplyOwnerCandidates } {
   const origin = findTurnByOriginId(args.origin_turn_id as string | undefined)
   const quoted = findTurnByQuotedMessageId(chatId, args.reply_to)
-  const latestEnded = findLatestEndedTurnForChat(chatId)
+  const latestEnded = findLatestTurnForChat(chatId, { endedOnly: true })
   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).
@@ -4049,12 +4049,12 @@ function resolveReplyOwnerTurn(
   }
   // 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.
+  // record. #3725: the lookup above is `endedOnly`, so `endedAt` is non-null here
+  // and the age is ALWAYS a real number — a not-yet-ended turn is no longer a
+  // candidate at all, and an explicit null age now fails CLOSED downstream.
   const latestEndedAgeMs =
     latestEnded?.endedAt != null ? Date.now() - latestEnded.endedAt : null
-  const candidates = {
+  const candidates: ReplyOwnerCandidates = {
     liveTurnId: liveTurn?.turnId ?? null,
     originTurnId: origin?.turnId ?? null,
     quotedTurnId: quoted?.turnId ?? null,
@@ -4062,15 +4062,14 @@ function resolveReplyOwnerTurn(
     latestEndedAgeMs,
     latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
   }
-  // #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.
+  // #3429 — the winning tier AND the candidate set it came from travel with the
+  // turn. Tier alone no longer decides the content-gate bypass: the
+  // model-steerable `origin`/`quoted` tiers must be CORROBORATED against the
+  // framework-derived `latestEndedTurnId` (`decideContentGateBypass`). All three
+  // derive from these SAME candidates, so they can never disagree.
   const tier = resolveReplyOwnerTier(candidates)
   const winnerId = resolveReplyOwnerTurnId(candidates)
-  return { turn: winnerId != null ? (byId.get(winnerId) ?? null) : null, tier }
+  return { turn: winnerId != null ? (byId.get(winnerId) ?? null) : null, tier, candidates }
 }
 
 /**
@@ -4115,7 +4114,7 @@ function resolveAnswerThreadWithLog(
     explicitThreadId == null &&
     originTurn == null &&
     liveTurn == null
-      ? findLatestEndedTurnForChat(chatId)
+      ? findLatestTurnForChat(chatId, { endedOnly: false })
       : null
   const threadId = resolveAnswerThreadId({
     explicitThreadId,

package/telegram-plugin/gateway/latest-turn-lookup.ts

@@ -0,0 +1,60 @@
+/**
+ * The recently-seen-turn registry scan, extracted from `gateway.ts` as a pure
+ * function so its ENDED-ness contract is unit-testable (#3725; gateway.ts is not
+ * importable in tests — the repo's `decideTurnFlush` / `resolveReplyOwnerTurnId`
+ * pattern).
+ *
+ * ## Why `endedOnly` exists (#3725)
+ *
+ * `recentTurnsById` is populated at turn **start** (`rememberRecentTurn` fires
+ * from the `enqueue` lifecycle event in `stream-render.ts`), and the atom is
+ * built with `endedAt: null`; `endedAt` is stamped later, in `turn-end.ts`. So
+ * the registry's tail entry for a chat is the most-recently-STARTED turn, which
+ * may still be RUNNING. The registry is also chat-wide and thread-agnostic, so
+ * on a forum a turn running in ANOTHER topic sits at the tail.
+ *
+ * That distinction is load-bearing because the two consumers want different
+ * things:
+ *
+ *   - **Routing** (`resolveAnswerThreadWithLog`) wants the chat's most recent
+ *     turn whether or not it has ended — it only picks a topic to deliver into,
+ *     and a still-running turn's topic is a perfectly good (indeed better)
+ *     answer than falling back to General. `endedOnly: false`.
+ *   - **Owner resolution** (`resolveReplyOwnerTurn` → the `latest-ended`
+ *     supersede tier) wants a genuinely ENDED turn: that tier carries
+ *     DESTRUCTIVE authority (it drives message deletion) and is bounded by the
+ *     supersede TTL measured from `endedAt`. A turn with `endedAt == null` has
+ *     no age, so it could not be TTL-bounded at all — it was an unbounded
+ *     anchor for the corroborated content-gate bypass (#3725). A still-running
+ *     turn must be resolved by the `live` tier, never by this fallback.
+ *     `endedOnly: true`.
+ */
+
+/** The registry-atom shape this scan needs (structural — `CurrentTurn` in the
+ *  gateway satisfies it without importing the gateway's type). */
+export interface LatestTurnLookupAtom {
+  /** The chat the turn belongs to. */
+  sessionChatId: string
+  /** Wall-clock ms the turn ENDED, or null while it is still running. */
+  endedAt: number | null
+}
+
+/**
+ * The last turn for `chatId` in registry insertion order — i.e. the most recent
+ * one. With `endedOnly: true` the scan skips turns that have not ended yet, so
+ * the result is the most-recently-ended turn (which may NOT be the tail entry).
+ * Returns null when the chat has no matching turn.
+ */
+export function latestTurnForChat<T extends LatestTurnLookupAtom>(
+  turns: Iterable<T>,
+  chatId: string,
+  opts: { endedOnly: boolean },
+): T | null {
+  let latest: T | null = null
+  for (const t of turns) {
+    if (t.sessionChatId !== chatId) continue
+    if (opts.endedOnly && t.endedAt == null) continue
+    latest = t
+  }
+  return latest
+}