switchroom 0.14.89 → 0.14.90

package/dist/cli/switchroom.js

@@ -49815,8 +49815,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.89";
-var COMMIT_SHA = "125cbcc5";
+var VERSION = "0.14.90";
+var COMMIT_SHA = "6386ff19";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.89",
+  "version": "0.14.90",
   "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/bridge/bridge.ts

@@ -78,7 +78,7 @@ const mcp = new Server(
       '',
       'reply accepts file paths (files: ["/abs/path.png"]) for attachments. Use react to add emoji reactions, edit_message for interim progress updates, and delete_message when you need to truly remove a message (prefer edit_message if you just want to change text — delete is for retraction). Edits don\'t trigger push notifications — when a long task completes, send a new reply so the user\'s device pings. Use send_typing to show a typing indicator during long operations. Use pin_message to pin important outputs. Use forward_message to quote/resurface earlier messages.',
       '',
-      'If a message includes message_thread_id, it came from a forum topic. The reply tool will automatically route replies back to the same topic — no need to pass message_thread_id manually unless you want to override. Each <channel> message is the current topic — answer ONLY this message\'s question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.',
+      'If a message includes message_thread_id, it came from a forum topic. The reply tool automatically routes a reply back to the topic the question came from — the framework owns the answer\'s topic, so do NOT pass message_thread_id on a reply; a reply always lands where it was asked. Each <channel> message is the current topic — answer ONLY this message\'s question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.',
       '',
       'The default format is "html" — write natural markdown and it is auto-converted to Telegram HTML (bold, italic, code, links, code blocks). Use format: "markdownv2" for MarkdownV2 with auto-escaping, or "text" for plain text.',
       '',

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

@@ -24571,7 +24571,7 @@ var mcp = new Server({ name: "telegram", version: "1.0.0" }, {
     "",
     `reply accepts file paths (files: ["/abs/path.png"]) for attachments. Use react to add emoji reactions, edit_message for interim progress updates, and delete_message when you need to truly remove a message (prefer edit_message if you just want to change text \u2014 delete is for retraction). Edits don't trigger push notifications \u2014 when a long task completes, send a new reply so the user's device pings. Use send_typing to show a typing indicator during long operations. Use pin_message to pin important outputs. Use forward_message to quote/resurface earlier messages.`,
     "",
-    "If a message includes message_thread_id, it came from a forum topic. The reply tool will automatically route replies back to the same topic \u2014 no need to pass message_thread_id manually unless you want to override. Each <channel> message is the current topic \u2014 answer ONLY this message's question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.",
+    "If a message includes message_thread_id, it came from a forum topic. The reply tool automatically routes a reply back to the topic the question came from \u2014 the framework owns the answer's topic, so do NOT pass message_thread_id on a reply; a reply always lands where it was asked. Each <channel> message is the current topic \u2014 answer ONLY this message's question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.",
     "",
     'The default format is "html" \u2014 write natural markdown and it is auto-converted to Telegram HTML (bold, italic, code, links, code blocks). Use format: "markdownv2" for MarkdownV2 with auto-escaping, or "text" for plain text.',
     "",

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

@@ -48000,12 +48000,23 @@ function decideFeedReopen(input) {
 
 // gateway/answer-thread-resolve.ts
 function resolveAnswerThreadId(input) {
-  if (input.explicitThreadId != null)
-    return input.explicitThreadId;
+  if (input.frameworkTopicAuthority === false) {
+    if (input.explicitThreadId != null)
+      return input.explicitThreadId;
+    if (input.originResolved)
+      return input.originThreadId;
+    if (input.liveThreadId != null)
+      return input.liveThreadId;
+    if (input.lastEndedResolvedForChat)
+      return input.lastEndedThreadIdForChat;
+    return input.liveThreadId;
+  }
   if (input.originResolved)
     return input.originThreadId;
-  if (input.liveThreadId != null)
+  if (input.liveTurnPresent)
     return input.liveThreadId;
+  if (input.explicitThreadId != null)
+    return input.explicitThreadId;
   if (input.lastEndedResolvedForChat)
     return input.lastEndedThreadIdForChat;
   return input.liveThreadId;
@@ -52889,11 +52900,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.89";
-var COMMIT_SHA = "125cbcc5";
-var COMMIT_DATE = "2026-06-08T07:42:50+10:00";
-var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 2;
+var VERSION = "0.14.90";
+var COMMIT_SHA = "6386ff19";
+var COMMIT_DATE = "2026-06-08T00:05:33Z";
+var LATEST_PR = 2235;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -54140,6 +54151,7 @@ var _noReplyDrainParsed = _noReplyDrainRaw != null && _noReplyDrainRaw !== "" ?
 var SERIALIZE_NOREPLY_DRAIN_MS = Number.isFinite(_noReplyDrainParsed) && _noReplyDrainParsed > 0 ? _noReplyDrainParsed : 2500;
 var TURN_ORIGIN_ROUTING_ENABLED = process.env.SWITCHROOM_TURN_ORIGIN_ROUTING !== "0";
 var FRAMEWORK_ORIGIN_ROUTING_ENABLED = process.env.SWITCHROOM_FRAMEWORK_ORIGIN_ROUTING !== "0";
+var REPLY_TOPIC_AUTHORITY_ENABLED = process.env.SWITCHROOM_REPLY_TOPIC_AUTHORITY !== "0";
 var TOPIC_FRAMING_ENABLED = process.env.SWITCHROOM_TOPIC_FRAMING !== "0";
 var QUEUED_STATUS_UX_ENABLED = process.env.SWITCHROOM_QUEUED_STATUS_UX !== "0";
 var FEED_REOPEN_AFTER_ACK_ENABLED = process.env.SWITCHROOM_FEED_REOPEN_AFTER_ACK !== "0";
@@ -54233,15 +54245,18 @@ function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, origin
     originResolved: originTurn != null,
     originThreadId: originTurn?.sessionThreadId,
     liveThreadId: liveTurn?.sessionThreadId,
+    liveTurnPresent: liveTurn != null,
     lastEndedResolvedForChat: recovered != null,
-    lastEndedThreadIdForChat: recovered?.sessionThreadId
+    lastEndedThreadIdForChat: recovered?.sessionThreadId,
+    frameworkTopicAuthority: REPLY_TOPIC_AUTHORITY_ENABLED
   });
-  const via = explicitThreadId != null ? "explicit" : originTurn != null ? originVia === "quoted" ? "quoted" : "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
+  const via = REPLY_TOPIC_AUTHORITY_ENABLED ? originTurn != null ? originVia === "quoted" ? "quoted" : "origin" : liveTurn != null ? "live" : explicitThreadId != null ? "explicit" : recovered != null ? "recovered" : "none" : explicitThreadId != null ? "explicit" : originTurn != null ? originVia === "quoted" ? "quoted" : "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
+  const explicitOverridden = REPLY_TOPIC_AUTHORITY_ENABLED && explicitThreadId != null && (originTurn != null || liveTurn != null) && threadId !== explicitThreadId;
   const ownerTurn = originTurn ?? recovered ?? liveTurn;
   const isSupergroup = chatId.startsWith("-100");
   const unrouted = isSupergroup && threadId == null && ownerTurn == null;
   const misrouteRisk = isSupergroup && via === "live" && hasDifferentThreadedRecentTurn(chatId, liveTurn?.sessionThreadId);
-  process.stderr.write(`telegram gateway: reply-route surface=${surface} chat=${chatId} resolved_thread=${threadId ?? "-"} via=${via} late=${liveTurn == null} originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (via === "quoted" ? " QUOTED(framework-origin)" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + (misrouteRisk ? " MISROUTE_RISK(no-echo\u2192live-successor)" : "") + `
+  process.stderr.write(`telegram gateway: reply-route surface=${surface} chat=${chatId} resolved_thread=${threadId ?? "-"} via=${via} late=${liveTurn == null} originTurn=${ownerTurn?.turnId ?? "-"} origin_thread=${ownerTurn?.sessionThreadId ?? "-"}` + (via === "recovered" ? " RECOVERED" : "") + (via === "quoted" ? " QUOTED(framework-origin)" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + (misrouteRisk ? " MISROUTE_RISK(no-echo\u2192live-successor)" : "") + (explicitOverridden ? ` EXPLICIT_OVERRIDDEN(model\u2192${explicitThreadId},routed\u2192${threadId ?? "-"})` : "") + `
 `);
   return threadId;
 }

package/telegram-plugin/dist/server.js

@@ -24268,7 +24268,7 @@ var init_bridge = __esm(async () => {
       "",
       `reply accepts file paths (files: ["/abs/path.png"]) for attachments. Use react to add emoji reactions, edit_message for interim progress updates, and delete_message when you need to truly remove a message (prefer edit_message if you just want to change text \u2014 delete is for retraction). Edits don't trigger push notifications \u2014 when a long task completes, send a new reply so the user's device pings. Use send_typing to show a typing indicator during long operations. Use pin_message to pin important outputs. Use forward_message to quote/resurface earlier messages.`,
       "",
-      "If a message includes message_thread_id, it came from a forum topic. The reply tool will automatically route replies back to the same topic \u2014 no need to pass message_thread_id manually unless you want to override. Each <channel> message is the current topic \u2014 answer ONLY this message's question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.",
+      "If a message includes message_thread_id, it came from a forum topic. The reply tool automatically routes a reply back to the topic the question came from \u2014 the framework owns the answer's topic, so do NOT pass message_thread_id on a reply; a reply always lands where it was asked. Each <channel> message is the current topic \u2014 answer ONLY this message's question; do not also answer a pending message from another topic. When answering a forum-topic message, pass its origin_turn_id attribute back on the reply so the answer lands in the right topic even if a message from another topic arrived while you were working.",
       "",
       'The default format is "html" \u2014 write natural markdown and it is auto-converted to Telegram HTML (bold, italic, code, links, code blocks). Use format: "markdownv2" for MarkdownV2 with auto-escaping, or "text" for plain text.',
       "",

package/telegram-plugin/gateway/answer-thread-resolve.test.ts

@@ -1,160 +1,190 @@
 import { describe, it, expect } from 'vitest'
 import { resolveAnswerThreadId, type AnswerThreadInput } from './answer-thread-resolve.js'
 
-describe('resolveAnswerThreadId — precedence', () => {
-  it('(1) explicit model thread wins over everything', () => {
+// Distinct symbolic thread ids so an output's provenance is unambiguous (no two
+// tiers share a value): explicit=70, origin=50, live=30, lastEnded=90.
+const T = 70 // explicit
+const O = 50 // origin
+const L = 30 // live
+const E = 90 // lastEnded
+
+// ── Framework-authority (DEFAULT) — human-readable map ──────────────────────
+describe('resolveAnswerThreadId — framework authority (default)', () => {
+  it('origin turn wins over the model explicit (the General→CRM fix)', () => {
     expect(
       resolveAnswerThreadId({
-        explicitThreadId: 7,
+        explicitThreadId: T,
         originResolved: true,
-        originThreadId: 3,
-        liveThreadId: 4,
-        lastEndedResolvedForChat: true,
-        lastEndedThreadIdForChat: 9,
+        originThreadId: O,
+        liveTurnPresent: true,
+        liveThreadId: L,
       }),
-    ).toBe(7)
-  })
-
-  it('(2) origin turn thread wins over the live turn (the Brevo→Meta fix)', () => {
-    expect(
-      resolveAnswerThreadId({ originResolved: true, originThreadId: 3, liveThreadId: 4 }),
-    ).toBe(3)
-  })
-
-  it('(2) a DM origin (resolved, thread undefined) pins to undefined, not the live thread', () => {
-    expect(
-      resolveAnswerThreadId({ originResolved: true, originThreadId: undefined, liveThreadId: 4 }),
-    ).toBeUndefined()
+    ).toBe(O)
   })
 
-  it('(3) no origin → falls back to the live turn thread (legacy #1664)', () => {
+  it('THE marko case: a General-origin question (origin resolved, thread undefined) + model explicit ⇒ General, NOT the model topic', () => {
     expect(
-      resolveAnswerThreadId({ originResolved: false, liveThreadId: 4 }),
-    ).toBe(4)
+      resolveAnswerThreadId({
+        explicitThreadId: 4, // model tried to send the answer to CRM (topic 4)
+        originResolved: true,
+        originThreadId: undefined, // General origin carries no thread
+        liveTurnPresent: true,
+        liveThreadId: undefined,
+      }),
+    ).toBeUndefined() // → General, where it was asked
   })
 
-  // ── tier (4): late-reply topic recovery (2026-06-05) ──────────────────────
-  it('(4) no explicit, no origin, NO live turn → recovers the most-recent ended turn thread', () => {
-    // The marko bug: a reply that fired after the orphaned-reply backstop ended
-    // its turn. Pre-fix this returned undefined (General); now it recovers topic 3.
+  it('a live in-flight turn wins over the model explicit even with no origin echo', () => {
     expect(
       resolveAnswerThreadId({
+        explicitThreadId: T,
         originResolved: false,
-        liveThreadId: undefined,
-        lastEndedResolvedForChat: true,
-        lastEndedThreadIdForChat: 3,
+        liveTurnPresent: true,
+        liveThreadId: L,
       }),
-    ).toBe(3)
+    ).toBe(L)
   })
 
-  it('(4) a recovered DM turn (ended, thread undefined) stays threadless', () => {
+  it('a General live turn (present, thread undefined) still beats the model explicit', () => {
     expect(
       resolveAnswerThreadId({
+        explicitThreadId: T,
         originResolved: false,
+        liveTurnPresent: true,
         liveThreadId: undefined,
-        lastEndedResolvedForChat: true,
-        lastEndedThreadIdForChat: undefined,
       }),
     ).toBeUndefined()
   })
 
-  it('(4) recovery does NOT override a live turn — live thread still wins at tier 3', () => {
+  it('model explicit is honoured only when there is NO origin and NO live turn (orphaned/proactive)', () => {
     expect(
       resolveAnswerThreadId({
+        explicitThreadId: T,
         originResolved: false,
-        liveThreadId: 4,
-        lastEndedResolvedForChat: true,
-        lastEndedThreadIdForChat: 3,
+        liveTurnPresent: false,
       }),
-    ).toBe(4)
+    ).toBe(T)
   })
 
-  it('(4) no recovery candidate → legacy result (undefined), unchanged', () => {
+  it('late reply, no anchor, no explicit → recovers the last-ended topic', () => {
     expect(
       resolveAnswerThreadId({
         originResolved: false,
-        liveThreadId: undefined,
-        lastEndedResolvedForChat: false,
+        liveTurnPresent: false,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: E,
       }),
-    ).toBeUndefined()
+    ).toBe(E)
   })
 
-  it('pure DM (every tier undefined) → undefined', () => {
+  it('pure DM (no anchors) → undefined', () => {
     expect(resolveAnswerThreadId({ originResolved: false })).toBeUndefined()
   })
 })
 
+// ── Legacy precedence (kill switch SWITCHROOM_REPLY_TOPIC_AUTHORITY=0) ───────
+describe('resolveAnswerThreadId — legacy (frameworkTopicAuthority:false)', () => {
+  it('explicit wins outright (the old behaviour)', () => {
+    expect(
+      resolveAnswerThreadId({
+        frameworkTopicAuthority: false,
+        explicitThreadId: T,
+        originResolved: true,
+        originThreadId: O,
+        liveThreadId: L,
+      }),
+    ).toBe(T)
+  })
+  it('origin beats live when no explicit (unchanged)', () => {
+    expect(
+      resolveAnswerThreadId({
+        frameworkTopicAuthority: false,
+        originResolved: true,
+        originThreadId: O,
+        liveThreadId: L,
+      }),
+    ).toBe(O)
+  })
+})
+
 // ── TOTAL-ENUMERATION DETERMINISM PROOF ─────────────────────────────────────
 //
-// The operator standard (memory feedback_prove_finite_fsm_not_sample): a
-// passing sample is not a proof. `resolveAnswerThreadId` is a PURE decision
-// function over a FINITE input space — so we can prove its determinism by
-// CONSTRUCTION: enumerate every reachable input and assert totality,
-// determinism, no-fabrication, and the precedence the doc-comment promises.
-// Any future edit that perturbs the decision table on ANY of the 64 inputs
-// fails here — this block is the regression guard, the 9 examples above are
-// the human-readable map.
-//
-// Distinct symbolic thread ids so an output's provenance is unambiguous (no
-// two tiers share a value): explicit=70, origin=50, live=30, lastEnded=90.
-const T = 70 // explicit (tier 1)
-const O = 50 // origin   (tier 2)
-const L = 30 // live     (tier 3)
-const E = 90 // lastEnded(tier 4)
-
-function allInputs(): AnswerThreadInput[] {
+// The operator standard (memory feedback_prove_finite_fsm_not_sample): a passing
+// sample is not a proof. `resolveAnswerThreadId` is a PURE decision function over
+// a FINITE input space — so we prove its behaviour by CONSTRUCTION: enumerate
+// every REACHABLE input (origin/live/ended each have 3 reachable states ×
+// explicit present/absent) for BOTH precedence modes, and assert totality,
+// determinism, no-fabrication, the documented precedence, and the load-bearing
+// guarantee: under framework authority the model's explicit thread CANNOT
+// redirect a reply that has a framework anchor.
+
+// Reachable sub-states (a thread value is only present when its 'resolved' flag is).
+const ORIGIN_STATES: Array<Pick<AnswerThreadInput, 'originResolved' | 'originThreadId'>> = [
+  { originResolved: false },
+  { originResolved: true, originThreadId: undefined }, // DM/General origin
+  { originResolved: true, originThreadId: O },
+]
+const LIVE_STATES: Array<Pick<AnswerThreadInput, 'liveTurnPresent' | 'liveThreadId'>> = [
+  { liveTurnPresent: false },
+  { liveTurnPresent: true, liveThreadId: undefined }, // General live turn
+  { liveTurnPresent: true, liveThreadId: L },
+]
+const ENDED_STATES: Array<
+  Pick<AnswerThreadInput, 'lastEndedResolvedForChat' | 'lastEndedThreadIdForChat'>
+> = [
+  { lastEndedResolvedForChat: false },
+  { lastEndedResolvedForChat: true, lastEndedThreadIdForChat: undefined },
+  { lastEndedResolvedForChat: true, lastEndedThreadIdForChat: E },
+]
+
+function reachableInputs(frameworkTopicAuthority: boolean): AnswerThreadInput[] {
   const rows: AnswerThreadInput[] = []
   for (const explicitThreadId of [undefined, T])
-    for (const originResolved of [false, true])
-      for (const originThreadId of [undefined, O])
-        for (const liveThreadId of [undefined, L])
-          for (const lastEndedResolvedForChat of [false, true])
-            for (const lastEndedThreadIdForChat of [undefined, E])
-              rows.push({
-                explicitThreadId,
-                originResolved,
-                originThreadId,
-                lastEndedResolvedForChat,
-                lastEndedThreadIdForChat,
-                liveThreadId,
-              })
-  return rows
+    for (const o of ORIGIN_STATES)
+      for (const lv of LIVE_STATES)
+        for (const en of ENDED_STATES)
+          rows.push({ explicitThreadId, ...o, ...lv, ...en, frameworkTopicAuthority })
+  return rows // 2 × 3 × 3 × 3 = 54
 }
 
-// Independent reference encoding the documented precedence (the SPEC), kept
-// deliberately separate from the implementation so a regression in either
-// surfaces as a divergence rather than a silently-shared bug.
-function specExpected(i: AnswerThreadInput): number | undefined {
-  if (i.explicitThreadId != null) return i.explicitThreadId // tier 1
-  if (i.originResolved) return i.originThreadId // tier 2 (may be undefined: DM origin)
-  if (i.liveThreadId != null) return i.liveThreadId // tier 3
-  if (i.lastEndedResolvedForChat) return i.lastEndedThreadIdForChat // tier 4
-  return i.liveThreadId // catch-all (undefined here)
+// Independent SPEC encodings, kept separate from the implementation so a
+// regression in either surfaces as a divergence.
+function specFramework(i: AnswerThreadInput): number | undefined {
+  if (i.originResolved) return i.originThreadId // (1)
+  if (i.liveTurnPresent) return i.liveThreadId // (2)
+  if (i.explicitThreadId != null) return i.explicitThreadId // (3)
+  if (i.lastEndedResolvedForChat) return i.lastEndedThreadIdForChat // (4)
+  return i.liveThreadId
+}
+function specLegacy(i: AnswerThreadInput): number | undefined {
+  if (i.explicitThreadId != null) return i.explicitThreadId
+  if (i.originResolved) return i.originThreadId
+  if (i.liveThreadId != null) return i.liveThreadId
+  if (i.lastEndedResolvedForChat) return i.lastEndedThreadIdForChat
+  return i.liveThreadId
 }
 
-describe('resolveAnswerThreadId — total-enumeration determinism proof (all 64 inputs)', () => {
-  const ROWS = allInputs()
+describe('resolveAnswerThreadId — total-enumeration proof (54 reachable inputs × 2 modes)', () => {
+  const FA = reachableInputs(true)
+  const LEGACY = reachableInputs(false)
 
-  it('the input space is exactly 64 rows (2^6)', () => {
-    expect(ROWS.length).toBe(64)
+  it('the reachable input space is exactly 54 rows per mode', () => {
+    expect(FA.length).toBe(54)
+    expect(LEGACY.length).toBe(54)
   })
 
-  it('TOTAL: every input returns without throwing', () => {
-    for (const i of ROWS) {
-      expect(() => resolveAnswerThreadId(i)).not.toThrow()
-    }
+  it('TOTAL: every input returns without throwing (both modes)', () => {
+    for (const i of [...FA, ...LEGACY]) expect(() => resolveAnswerThreadId(i)).not.toThrow()
   })
 
-  it('DETERMINISTIC: each input maps to exactly one output (idempotent across repeated calls)', () => {
-    for (const i of ROWS) {
-      const a = resolveAnswerThreadId(i)
-      const b = resolveAnswerThreadId({ ...i })
-      expect(b).toBe(a)
+  it('DETERMINISTIC: each input maps to exactly one output across repeated calls', () => {
+    for (const i of [...FA, ...LEGACY]) {
+      expect(resolveAnswerThreadId({ ...i })).toBe(resolveAnswerThreadId(i))
     }
   })
 
   it('NO FABRICATION: every output is undefined or one of the four input thread fields', () => {
-    for (const i of ROWS) {
+    for (const i of [...FA, ...LEGACY]) {
       const out = resolveAnswerThreadId(i)
       const provenance = new Set([
         undefined,
@@ -167,53 +197,45 @@ describe('resolveAnswerThreadId — total-enumeration determinism proof (all 64
     }
   })
 
-  it('PRECEDENCE: matches the documented spec on all 64 inputs', () => {
-    for (const i of ROWS) {
-      expect(resolveAnswerThreadId(i)).toBe(specExpected(i))
-    }
+  it('PRECEDENCE (framework): matches the documented spec on all 54 inputs', () => {
+    for (const i of FA) expect(resolveAnswerThreadId(i)).toBe(specFramework(i))
   })
 
-  // ── By-construction invariants: the output depends ONLY on the highest
-  //    RESOLVED tier, so no lower-tier input (notably a flipped live turn)
-  //    can perturb a higher tier's decision. These are the routing guarantees
-  //    the resolver exists to provide. ─────────────────────────────────────
-
-  it('INV-1 explicit DOMINANCE: explicit set ⇒ output === explicit, independent of all other fields', () => {
-    for (const i of ROWS) {
-      if (i.explicitThreadId != null) expect(resolveAnswerThreadId(i)).toBe(i.explicitThreadId)
-    }
+  it('PRECEDENCE (legacy): matches the legacy spec on all 54 inputs', () => {
+    for (const i of LEGACY) expect(resolveAnswerThreadId(i)).toBe(specLegacy(i))
   })
 
-  it('INV-2 origin FLIP-IMMUNITY: no explicit + originResolved ⇒ output === originThreadId, for EVERY liveThreadId/lastEnded combo (the Brevo→Meta fix: a currentTurn flip cannot steal a resolved origin)', () => {
-    for (const i of ROWS) {
-      if (i.explicitThreadId == null && i.originResolved) {
-        expect(resolveAnswerThreadId(i)).toBe(i.originThreadId)
+  // ── The load-bearing guarantee ────────────────────────────────────────────
+  it('INV-ANCHOR (framework): the model explicit CANNOT redirect a reply that has a framework anchor — output is independent of explicitThreadId whenever originResolved OR liveTurnPresent', () => {
+    for (const i of FA) {
+      if (i.originResolved || i.liveTurnPresent) {
+        const withExplicit = resolveAnswerThreadId({ ...i, explicitThreadId: T })
+        const without = resolveAnswerThreadId({ ...i, explicitThreadId: undefined })
+        expect(withExplicit).toBe(without)
       }
     }
   })
 
-  it('INV-3 recovery REACHABILITY: tier-4 (lastEnded) result occurs ONLY when no explicit, no origin, no live turn', () => {
-    for (const i of ROWS) {
-      const out = resolveAnswerThreadId(i)
-      // If the result came from the lastEnded field (and that field is the
-      // only one carrying that distinct value E), the three higher tiers must
-      // all be absent.
-      if (out === E) {
-        expect(i.explicitThreadId).toBeUndefined()
-        expect(i.originResolved).toBe(false)
-        expect(i.liveThreadId).toBeUndefined()
-        expect(i.lastEndedResolvedForChat).toBe(true)
-      }
+  it('INV-ORIGIN (framework): originResolved ⇒ output === originThreadId, for EVERY explicit/live/ended combo (flip-immunity + explicit-immunity)', () => {
+    for (const i of FA) if (i.originResolved) expect(resolveAnswerThreadId(i)).toBe(i.originThreadId)
+  })
+
+  it('INV-LIVE (framework): ¬originResolved ∧ liveTurnPresent ⇒ output === liveThreadId, regardless of explicit', () => {
+    for (const i of FA) {
+      if (!i.originResolved && i.liveTurnPresent) expect(resolveAnswerThreadId(i)).toBe(i.liveThreadId)
     }
   })
 
-  it('INV-4 live-tier REACHABILITY: tier-3 (live) result occurs ONLY when no explicit and no resolved origin', () => {
-    for (const i of ROWS) {
-      const out = resolveAnswerThreadId(i)
-      if (out === L) {
-        expect(i.explicitThreadId).toBeUndefined()
+  it('INV-EXPLICIT-LAST (framework): an explicit-tier result occurs ONLY when no origin AND no live turn', () => {
+    for (const i of FA) {
+      if (resolveAnswerThreadId(i) === T) {
         expect(i.originResolved).toBe(false)
+        expect(i.liveTurnPresent).toBe(false)
       }
     }
   })
+
+  it('INV-EXPLICIT-DOMINANCE (legacy): explicit set ⇒ output === explicit, independent of all other fields', () => {
+    for (const i of LEGACY) if (i.explicitThreadId != null) expect(resolveAnswerThreadId(i)).toBe(i.explicitThreadId)
+  })
 })

package/telegram-plugin/gateway/answer-thread-resolve.ts

@@ -5,35 +5,48 @@
  * Pure decision: which forum-topic thread should an ANSWER reply
  * (`reply` / `stream_reply`) land in?
  *
- * ## The bug this closes
+ * ## The bugs this closes
  *
- * In a forum supergroup one sequential `claude` CLI owns every topic with
- * a singleton `currentTurn`. The Brevo turn's reply landed ~42s after its
- * turn-end event; by then `currentTurn` had flipped to the Meta turn.
- * `executeReply` captured `const turn = currentTurn` at execution and, when
- * the model omitted `message_thread_id`, resolved the thread from
- * `turn.sessionThreadId` (Meta's thread) — so Brevo's answer landed in
- * Meta. A successor turn stole a predecessor's late reply.
+ * **(a) currentTurn flip (2026-06-05).** In a forum supergroup one sequential
+ * `claude` CLI owns every topic with a singleton `currentTurn`. A late reply
+ * landed after `currentTurn` had flipped to a successor topic, so the answer
+ * went to the wrong topic. Fixed by pinning to the ORIGIN turn's thread (tier 1).
  *
- * ## The precedence (answer paths)
+ * **(b) model-chosen topic override (2026-06-08).** A General-topic question's
+ * answer landed in the CRM topic because the model passed an explicit
+ * `message_thread_id` and the resolver let that win OUTRIGHT over the
+ * framework's record of where the question came from. General is the trap: its
+ * messages carry no thread id, so nothing forces the reply back — and the
+ * model's explicit "post to CRM" overrode the General origin. The user, reading
+ * General, saw silence. This is a model-dependency: a reply's topic must not be
+ * the model's free choice.
  *
- *   1. An explicit `message_thread_id` the MODEL passed wins outright —
- *      the model is asserting the destination topic.
- *   2. Else the ORIGIN turn's thread: the turn matched by the reply's
- *      `origin_turn_id` (the meta field the model echoes back). This is
- *      authoritative even when `currentTurn` has flipped, because the
- *      origin turn is looked up in a recently-ended registry.
- *   3. Else the LIVE turn's thread — but ONLY when the live turn IS the
- *      origin turn (no flip happened) OR no origin turn could be resolved
- *      at all (origin id absent/unknown; legacy / pre-stamp path).
- *   4. Else (no explicit, no origin echoed, no live turn) — a LATE reply that
- *      fired after its turn already ended (the orphaned-reply backstop case) —
- *      recover the origin topic from the most-recently-ended turn for this
- *      chat. Without this, such a reply defaults to the main chat (General in a
- *      supergroup) and its answer vanishes from the topic the user is reading
- *      (the 2026-06-05 marko triage). Still NOT the `chatThreadMap` last-seen
- *      heuristic — the recovered turn is the chat's own most-recent turn, not
- *      whichever topic last received any message.
+ * ## The precedence (answer paths) — FRAMEWORK AUTHORITY (default)
+ *
+ * The topic a reply lands in is owned by the TURN it answers, not the model's
+ * `message_thread_id`. The model's explicit thread is demoted to a last resort
+ * — used only when the framework has NO turn anchor at all (a genuinely
+ * orphaned / proactive send). Precedence:
+ *
+ *   1. ORIGIN turn's thread — the turn matched by the reply's `origin_turn_id`
+ *      (echoed) or a quoted `reply_to` (framework reverse-index). Authoritative
+ *      even when `currentTurn` flipped (closes bug a). A General/DM origin
+ *      yields `undefined`, which correctly routes to the main chat / General.
+ *   2. LIVE in-flight turn's thread — keyed on the turn's PRESENCE, not its
+ *      thread value, so a General live turn (thread `undefined`) still anchors
+ *      the reply to the General conversation. The model's explicit cannot
+ *      redirect a reply that belongs to an in-flight turn (closes bug b).
+ *   3. EXPLICIT model thread — only now, when there is neither an origin nor a
+ *      live turn (a late / proactive send with no framework anchor). Here the
+ *      model's `message_thread_id` is the only signal, so honour it.
+ *   4. LATE-reply recovery — no explicit, no origin, no live turn: recover the
+ *      origin topic from the most-recently-ended turn for this chat, so an
+ *      orphaned-backstop reply lands in its topic instead of defaulting to the
+ *      main chat (General). Not the `chatThreadMap` last-seen heuristic.
+ *
+ * Setting `frameworkTopicAuthority: false` (kill switch
+ * SWITCHROOM_REPLY_TOPIC_AUTHORITY=0) restores the legacy explicit-first
+ * precedence (the model's thread wins outright).
  *
  * The `chatThreadMap` last-seen fallback is preserved for NON-answer
  * surfaces (`send_typing`, `forward_message`, `progress_update`) by NOT
@@ -50,13 +63,17 @@ export interface AnswerThreadInput {
    *  `originResolved` is true. */
   originThreadId?: number | undefined
   /** Whether an origin turn was resolved at all. Distinguishes
-   *  "origin turn exists and its thread is undefined (a DM origin)" from
+   *  "origin turn exists and its thread is undefined (a DM/General origin)" from
    *  "no origin turn" — both surface as `originThreadId === undefined`. */
   originResolved: boolean
   /** Thread of the LIVE `currentTurn` at execution time, or undefined
-   *  (no live turn, or a DM live turn). The legacy (#1664) fallback when
-   *  no origin turn is resolvable. */
+   *  (no live turn, or a DM/General live turn). */
   liveThreadId?: number | undefined
+  /** Whether a LIVE in-flight turn exists at execution time. Distinguishes a
+   *  General (thread-undefined) live turn — still a valid framework anchor —
+   *  from no live turn at all. Mirrors `originResolved`. Absent in the legacy
+   *  path (which keys off `liveThreadId != null`). */
+  liveTurnPresent?: boolean
   /**
    * Late-reply topic recovery (2026-06-05). Thread of the most-recently-ended
    * turn for THIS chat (from `recentTurnsById`), used as a deterministic
@@ -64,42 +81,52 @@ export interface AnswerThreadInput {
    * turn — the late-reply-after-turn-end case. Without it, a reply that fires
    * after the orphaned-reply backstop closed its turn defaults to the main chat
    * (General topic in a supergroup), so its answer vanishes from the topic the
-   * user is reading. Only consulted at tier (4); a DM origin yields undefined,
-   * which is correct.
+   * user is reading. A DM origin yields undefined, which is correct.
    */
   lastEndedThreadIdForChat?: number | undefined
   /** Whether a recently-ended turn exists for this chat — distinguishes
    *  "ended turn exists, DM (thread undefined)" from "no ended turn at all". */
   lastEndedResolvedForChat?: boolean
+  /**
+   * When true (default), the framework's turn anchor (origin → live) owns the
+   * reply topic and the model's `explicitThreadId` is a last resort (consulted
+   * only when no anchor exists). When false, the legacy explicit-first
+   * precedence (the model's thread wins outright). Undefined is treated as
+   * true. Kill switch SWITCHROOM_REPLY_TOPIC_AUTHORITY=0.
+   */
+  frameworkTopicAuthority?: boolean
 }
 
 /**
  * Pure. Returns the thread id to send the answer to, or undefined for the
- * main chat (DM / no thread).
+ * main chat (DM / General / no thread).
  *
- * Precedence: explicit model thread → origin turn's thread (authoritative
- * across a currentTurn flip; this is the wrong-topic fix) → live turn's
- * thread (legacy #1664 fallback when origin can't be resolved). Crucially
- * the chat last-seen `chatThreadMap` heuristic is NOT in this chain — that
- * heuristic is what produced the Brevo→Meta wrong-topic bug, so answer
- * paths never reach it.
+ * Default (framework authority): origin turn → live in-flight turn → explicit
+ * model thread → late-ended recovery. The model's `explicitThreadId` cannot
+ * override a resolved origin or a live turn — it is consulted only when neither
+ * exists. The chat last-seen `chatThreadMap` heuristic is NOT in this chain.
  */
 export function resolveAnswerThreadId(input: AnswerThreadInput): number | undefined {
-  // (1) explicit model thread wins.
-  if (input.explicitThreadId != null) return input.explicitThreadId
-  // (2) origin turn resolved → pin to its thread (authoritative even when
-  //     currentTurn has flipped to a successor). A DM origin yields
-  //     undefined, which is correct.
+  if (input.frameworkTopicAuthority === false) {
+    // ── Legacy precedence (kill switch): the model's explicit thread wins. ──
+    if (input.explicitThreadId != null) return input.explicitThreadId
+    if (input.originResolved) return input.originThreadId
+    if (input.liveThreadId != null) return input.liveThreadId
+    if (input.lastEndedResolvedForChat) return input.lastEndedThreadIdForChat
+    return input.liveThreadId
+  }
+  // ── Framework-authority precedence (default) ───────────────────────────────
+  // (1) origin turn → its thread (authoritative across a currentTurn flip; a
+  //     General/DM origin yields undefined → main chat / General).
   if (input.originResolved) return input.originThreadId
-  // (3) no origin resolved (legacy / pre-stamp / evicted) → fall back to
-  //     the live turn's thread, the existing turn-pinned behaviour (#1664).
-  if (input.liveThreadId != null) return input.liveThreadId
-  // (4) no explicit, no origin echoed, no live turn — a LATE reply that fired
-  //     after its turn already ended (the orphaned-reply backstop case).
-  //     Recover the origin topic from the most-recently-ended turn for this
-  //     chat so the answer lands in the topic it belongs to instead of
-  //     defaulting to the main chat (General). When no ended turn is known,
-  //     fall through to liveThreadId (undefined) — the legacy result.
+  // (2) a live in-flight turn → its thread. Key off PRESENCE, not the thread
+  //     value: a General live turn has an undefined thread but is still the
+  //     anchor, so the model's explicit can't pull the reply out of it.
+  if (input.liveTurnPresent) return input.liveThreadId
+  // (3) no framework anchor (genuinely orphaned / proactive) → honour the
+  //     model's explicit thread, its only signal here.
+  if (input.explicitThreadId != null) return input.explicitThreadId
+  // (4) late reply, no anchor, no explicit → recover the chat's last-ended topic.
   if (input.lastEndedResolvedForChat) return input.lastEndedThreadIdForChat
   return input.liveThreadId
 }

package/telegram-plugin/gateway/gateway.ts

@@ -1566,6 +1566,15 @@ const TURN_ORIGIN_ROUTING_ENABLED =
 // mask a misroute. Kill switch off (=0) → echo-only origin (today's behaviour).
 const FRAMEWORK_ORIGIN_ROUTING_ENABLED =
   process.env.SWITCHROOM_FRAMEWORK_ORIGIN_ROUTING !== '0'
+// Reply-topic framework authority (2026-06-08 determinism pass). The topic an
+// ANSWER lands in is owned by the TURN it answers (origin → live), NOT the
+// model's `message_thread_id`. The model's explicit thread is demoted to a
+// last resort (consulted only when there is no origin AND no live turn). Closes
+// the model-chosen-topic override that sent a General-topic question's answer
+// into the CRM topic (marko) — the model could redirect any reply. Kill switch
+// off (=0) → legacy explicit-first precedence (the model's thread wins).
+const REPLY_TOPIC_AUTHORITY_ENABLED =
+  process.env.SWITCHROOM_REPLY_TOPIC_AUTHORITY !== '0'
 // Component 4 (per-turn topic framing). Add a one-line directive to the
 // channel meta + bridge instructions telling the model to answer ONLY the
 // current message's topic. Kill switch off (=0) → no framing field.
@@ -2033,15 +2042,32 @@ function resolveAnswerThreadWithLog(
     originResolved: originTurn != null,
     originThreadId: originTurn?.sessionThreadId,
     liveThreadId: liveTurn?.sessionThreadId,
+    liveTurnPresent: liveTurn != null,
     lastEndedResolvedForChat: recovered != null,
     lastEndedThreadIdForChat: recovered?.sessionThreadId,
+    frameworkTopicAuthority: REPLY_TOPIC_AUTHORITY_ENABLED,
   })
-  const via =
-    explicitThreadId != null ? 'explicit'
-    : originTurn != null ? (originVia === 'quoted' ? 'quoted' : 'origin')
-    : liveTurn?.sessionThreadId != null ? 'live'
-    : recovered != null ? 'recovered'
-    : 'none'
+  // `via` reflects the ACTIVE precedence so telemetry matches routing.
+  const via = REPLY_TOPIC_AUTHORITY_ENABLED
+    ? (originTurn != null ? (originVia === 'quoted' ? 'quoted' : 'origin')
+      : liveTurn != null ? 'live'
+      : explicitThreadId != null ? 'explicit'
+      : recovered != null ? 'recovered'
+      : 'none')
+    : (explicitThreadId != null ? 'explicit'
+      : originTurn != null ? (originVia === 'quoted' ? 'quoted' : 'origin')
+      : liveTurn?.sessionThreadId != null ? 'live'
+      : recovered != null ? 'recovered'
+      : 'none')
+  // Observability: the model passed an explicit topic but a framework anchor
+  // (origin/live) overrode it. This is the deterministic correction that fixes
+  // the General→CRM misroute; surface it so the model's topic-grabbing is
+  // visible rather than silent.
+  const explicitOverridden =
+    REPLY_TOPIC_AUTHORITY_ENABLED &&
+    explicitThreadId != null &&
+    (originTurn != null || liveTurn != null) &&
+    threadId !== explicitThreadId
   const ownerTurn = originTurn ?? recovered ?? liveTurn
   const isSupergroup = chatId.startsWith('-100')
   // UNROUTED = a supergroup reply that resolved to NO topic with NO owner turn
@@ -2068,6 +2094,9 @@ function resolveAnswerThreadWithLog(
       (via === 'quoted' ? ' QUOTED(framework-origin)' : '') +
       (unrouted ? ' UNROUTED(supergroup→no-topic)' : '') +
       (misrouteRisk ? ' MISROUTE_RISK(no-echo→live-successor)' : '') +
+      (explicitOverridden
+        ? ` EXPLICIT_OVERRIDDEN(model→${explicitThreadId},routed→${threadId ?? '-'})`
+        : '') +
       '\n',
   )
   return threadId

package/telegram-plugin/tests/answer-thread-resolve.test.ts

@@ -16,12 +16,25 @@ describe('resolveAnswerThreadId', () => {
   const BREVO = 4
   const META = 3
 
-  it('explicit model thread wins outright', () => {
+  it('the model explicit no longer wins over a framework anchor (origin wins); kill switch restores legacy', () => {
+    // Default (framework authority): the resolved origin owns the topic — the
+    // model passing a different explicit thread cannot redirect the reply.
     expect(
       resolveAnswerThreadId({
+        explicitThreadId: BREVO, // model tried to send it to Brevo
+        originResolved: true,
+        originThreadId: META, // but the question came from Meta
+        liveTurnPresent: true,
+        liveThreadId: META,
+      }),
+    ).toBe(META)
+    // Kill switch (SWITCHROOM_REPLY_TOPIC_AUTHORITY=0): explicit wins outright.
+    expect(
+      resolveAnswerThreadId({
+        frameworkTopicAuthority: false,
         explicitThreadId: BREVO,
         originResolved: true,
-        originThreadId: META, // even if origin says otherwise
+        originThreadId: META,
         liveThreadId: META,
       }),
     ).toBe(BREVO)
@@ -86,18 +99,20 @@ describe('resolveAnswerThreadId', () => {
     ).toBeUndefined()
   })
 
-  it('precedence: explicit > origin > live (never chatThreadMap — not an input)', () => {
+  it('precedence (framework authority, default): origin > live > explicit (never chatThreadMap — not an input)', () => {
     // The chat last-seen thread is deliberately NOT a parameter: answer
     // paths can never reach it, which is what closes the wrong-topic bug.
-    // explicit beats both:
+    // The model's explicit no longer beats a framework anchor — origin wins
+    // even when the model asserted a different topic (the General→CRM fix):
     expect(
       resolveAnswerThreadId({
         explicitThreadId: 9,
         originResolved: true,
         originThreadId: BREVO,
+        liveTurnPresent: true,
         liveThreadId: META,
       }),
-    ).toBe(9)
+    ).toBe(BREVO)
     // no explicit, origin resolved → origin (not live):
     expect(
       resolveAnswerThreadId({
@@ -107,5 +122,15 @@ describe('resolveAnswerThreadId', () => {
         liveThreadId: META,
       }),
     ).toBe(BREVO)
+    // kill switch restores the legacy explicit-first precedence:
+    expect(
+      resolveAnswerThreadId({
+        frameworkTopicAuthority: false,
+        explicitThreadId: 9,
+        originResolved: true,
+        originThreadId: BREVO,
+        liveThreadId: META,
+      }),
+    ).toBe(9)
   })
 })