switchroom 0.14.89 → 0.14.91

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.91";
+var COMMIT_SHA = "e938daab";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.89",
+  "version": "0.14.91",
   "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.91";
+var COMMIT_SHA = "e938daab";
+var COMMIT_DATE = "2026-06-09T03:14:21Z";
+var LATEST_PR = 2241;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -53534,6 +53545,21 @@ function resolveWorkerFeedDispatch(sub, watcherDescription) {
   };
 }
 
+// gateway/subagent-status-surface.ts
+function resolveSubagentStatusSurface(input) {
+  if (!input.isBackground) {
+    if (input.liveTurnPresent)
+      return "nest";
+    if (!input.orphanStatusEnabled)
+      return "skip";
+    return input.workerFeedEnabled ? "worker-feed" : "skip";
+  }
+  return input.workerFeedEnabled ? "worker-feed" : "legacy-relay";
+}
+function isOrphanSubagentStatusEnabled(envVal) {
+  return envVal !== "0";
+}
+
 // gateway/resolve-calling-subagent.ts
 function resolveCallingSubagent(opts) {
   if (opts.db == null)
@@ -54140,6 +54166,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 +54260,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;
 }
@@ -64554,6 +64584,7 @@ var didOneTimeSetup = false;
           if (watcherAgentDir != null) {
             const workerFeedEnabled = isWorkerActivityFeedEnabled(process.env.SWITCHROOM_WORKER_ACTIVITY_FEED);
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== "0";
+            const orphanStatusEnabled = isOrphanSubagentStatusEnabled(process.env.SWITCHROOM_ORPHAN_SUBAGENT_STATUS);
             const workerActivityFeed = createWorkerActivityFeed({
               bot: {
                 sendMessage: async (cid, text, sendOpts) => {
@@ -64635,6 +64666,22 @@ var didOneTimeSetup = false;
                         }
                       }
                     }
+                    return;
+                  }
+                  if (resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: false,
+                    workerFeedEnabled,
+                    orphanStatusEnabled
+                  }) === "worker-feed") {
+                    workerActivityFeed.finish(agentId, {
+                      description: dispatch.feedDescription,
+                      lastTool: null,
+                      toolCount,
+                      latestSummary: resultText,
+                      elapsedMs: durationMs,
+                      state: outcome === "failed" ? "failed" : "done"
+                    });
                   }
                   return;
                 }
@@ -64701,6 +64748,26 @@ var didOneTimeSetup = false;
                 }
                 const isBackground = dispatch.isBackground;
                 if (!isBackground) {
+                  const surface = resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: currentTurn != null,
+                    workerFeedEnabled,
+                    orphanStatusEnabled
+                  });
+                  if (surface === "worker-feed") {
+                    const origin = resolveSubagentOriginChat(agentId);
+                    workerActivityFeed.update(agentId, origin?.chatId || fleetChatId || (loadAccess().allowFrom[0] ?? ""), {
+                      description: dispatch.feedDescription,
+                      lastTool,
+                      toolCount,
+                      latestSummary,
+                      elapsedMs,
+                      state: "running"
+                    }, origin?.threadId);
+                    return;
+                  }
+                  if (surface !== "nest")
+                    return;
                   const turn = currentTurn;
                   if (turn == null)
                     return;

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

@@ -471,6 +471,10 @@ import {
 } from './resume-inbound-builder.js'
 import { applySubagentsSchema, getSubagentByJsonlId } from '../registry/subagents-schema.js'
 import { resolveWorkerFeedDispatch, type WorkerFeedDispatch } from './worker-feed-dispatch.js'
+import {
+  resolveSubagentStatusSurface,
+  isOrphanSubagentStatusEnabled,
+} from './subagent-status-surface.js'
 import { formatIdleFooter } from '../idle-footer.js'
 import { resolveCallingSubagent } from './resolve-calling-subagent.js'
 
@@ -1566,6 +1570,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 +2046,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 +2098,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
@@ -20381,6 +20414,11 @@ void (async () => {
             // compose draft, so no answer-stream contention). The kill-switch
             // disables only the nesting; the parent's own feed is unaffected.
             const foregroundNestingEnabled = process.env.SWITCHROOM_FOREGROUND_SUBAGENT_NESTING !== '0'
+            // Orphaned-foreground status (2026-06-09): a FOREGROUND sub-agent
+            // with no live parent turn to nest into (dispatched outside a turn,
+            // 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)
             const workerActivityFeed = createWorkerActivityFeed({
               bot: {
                 sendMessage: async (cid, text, sendOpts) => {
@@ -20580,6 +20618,29 @@ void (async () => {
                         }
                       }
                     }
+                    return
+                  }
+                  // Not nested → an orphaned foreground sub-agent that was
+                  // surfaced via the worker feed (no live turn to nest into):
+                  // finalize its message (no-op if none was posted). A
+                  // foreground result returns inline as the Task tool result, so
+                  // there is no handback to deliver — return after.
+                  if (
+                    resolveSubagentStatusSurface({
+                      isBackground: false,
+                      liveTurnPresent: false,
+                      workerFeedEnabled,
+                      orphanStatusEnabled,
+                    }) === 'worker-feed'
+                  ) {
+                    void workerActivityFeed.finish(agentId, {
+                      description: dispatch.feedDescription,
+                      lastTool: null,
+                      toolCount,
+                      latestSummary: resultText,
+                      elapsedMs: durationMs,
+                      state: outcome === 'failed' ? 'failed' : 'done',
+                    })
                   }
                   return
                 }
@@ -20709,8 +20770,39 @@ void (async () => {
                   // activity draft rather than a separate worker message. Pure
                   // jsonl-tail → render (no model call), inside the
                   // subscription-honest boundary.
+                  //
+                  // But a foreground sub-agent with NO live turn to nest into
+                  // (dispatched outside a turn, or the turn ended while it kept
+                  // running — extended autonomous work) has nowhere to nest, and
+                  // pre-fix it silently returned here → invisible. Route through
+                  // the proven decision: an orphaned foreground sub-agent goes to
+                  // the worker feed (owner-DM fallback), not into the void.
+                  const surface = resolveSubagentStatusSurface({
+                    isBackground: false,
+                    liveTurnPresent: currentTurn != null,
+                    workerFeedEnabled,
+                    orphanStatusEnabled,
+                  })
+                  if (surface === 'worker-feed') {
+                    const origin = resolveSubagentOriginChat(agentId)
+                    void workerActivityFeed.update(
+                      agentId,
+                      origin?.chatId || fleetChatId || (loadAccess().allowFrom[0] ?? ''),
+                      {
+                        description: dispatch.feedDescription,
+                        lastTool,
+                        toolCount,
+                        latestSummary,
+                        elapsedMs,
+                        state: 'running',
+                      },
+                      origin?.threadId,
+                    )
+                    return
+                  }
+                  if (surface !== 'nest') return // 'skip' — orphan-status off
                   const turn = currentTurn
-                  if (turn == null) return
+                  if (turn == null) return // defensive: 'nest' implies a live turn
                   // Render regardless of `replyCalled` — a foreground Task
                   // blocks the parent, so any reply seen while it runs is an
                   // interim ack, never the final answer. Gating on replyCalled

package/telegram-plugin/gateway/subagent-status-surface.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest'
+import {
+  resolveSubagentStatusSurface,
+  isOrphanSubagentStatusEnabled,
+  type SubagentStatusSurface,
+  type SubagentStatusSurfaceInput,
+} from './subagent-status-surface.js'
+
+// ── Human-readable map ──────────────────────────────────────────────────────
+describe('resolveSubagentStatusSurface', () => {
+  const base: SubagentStatusSurfaceInput = {
+    isBackground: false,
+    liveTurnPresent: true,
+    workerFeedEnabled: true,
+    orphanStatusEnabled: true,
+  }
+  it('foreground + live turn → nest (unchanged default)', () => {
+    expect(resolveSubagentStatusSurface(base)).toBe('nest')
+  })
+  it('THE fix: orphaned foreground (no live turn) → worker-feed', () => {
+    expect(resolveSubagentStatusSurface({ ...base, liveTurnPresent: false })).toBe('worker-feed')
+  })
+  it('kill switch: orphaned foreground with orphanStatus OFF → skip (pre-fix invisible)', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, liveTurnPresent: false, orphanStatusEnabled: false }),
+    ).toBe('skip')
+  })
+  it('orphaned foreground but feed OFF → skip (nothing to surface through)', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, liveTurnPresent: false, workerFeedEnabled: false }),
+    ).toBe('skip')
+  })
+  it('background + feed on → worker-feed', () => {
+    expect(resolveSubagentStatusSurface({ ...base, isBackground: true, liveTurnPresent: false })).toBe('worker-feed')
+  })
+  it('background + feed off → legacy-relay', () => {
+    expect(
+      resolveSubagentStatusSurface({ ...base, isBackground: true, workerFeedEnabled: false }),
+    ).toBe('legacy-relay')
+  })
+})
+
+describe('isOrphanSubagentStatusEnabled — default ON, =0 kill switch', () => {
+  it('undefined / "1" / "" → on; "0" → off', () => {
+    expect(isOrphanSubagentStatusEnabled(undefined)).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('1')).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('')).toBe(true)
+    expect(isOrphanSubagentStatusEnabled('0')).toBe(false)
+  })
+})
+
+// ── TOTAL-ENUMERATION DETERMINISM PROOF ─────────────────────────────────────
+// 4 booleans = 16 reachable inputs. Enumerate all, assert totality, determinism,
+// the documented table (independent spec), and the load-bearing invariants.
+// (operator standard feedback_prove_finite_fsm_not_sample.)
+function allInputs(): SubagentStatusSurfaceInput[] {
+  const rows: SubagentStatusSurfaceInput[] = []
+  for (const isBackground of [false, true])
+    for (const liveTurnPresent of [false, true])
+      for (const workerFeedEnabled of [false, true])
+        for (const orphanStatusEnabled of [false, true])
+          rows.push({ isBackground, liveTurnPresent, workerFeedEnabled, orphanStatusEnabled })
+  return rows
+}
+
+// Independent spec encoding (kept separate from the impl).
+function spec(i: SubagentStatusSurfaceInput): SubagentStatusSurface {
+  if (i.isBackground) return i.workerFeedEnabled ? 'worker-feed' : 'legacy-relay'
+  if (i.liveTurnPresent) return 'nest'
+  if (!i.orphanStatusEnabled) return 'skip'
+  return i.workerFeedEnabled ? 'worker-feed' : 'skip'
+}
+
+describe('resolveSubagentStatusSurface — total enumeration (16 inputs)', () => {
+  const ROWS = allInputs()
+
+  it('exactly 16 reachable inputs (2^4)', () => {
+    expect(ROWS.length).toBe(16)
+  })
+  it('TOTAL + DETERMINISTIC: every input returns one of the four surfaces, idempotently', () => {
+    const surfaces = new Set<SubagentStatusSurface>(['nest', 'worker-feed', 'legacy-relay', 'skip'])
+    for (const i of ROWS) {
+      const a = resolveSubagentStatusSurface(i)
+      expect(surfaces.has(a)).toBe(true)
+      expect(resolveSubagentStatusSurface({ ...i })).toBe(a)
+    }
+  })
+  it('PRECEDENCE: matches the documented spec on all 16 inputs', () => {
+    for (const i of ROWS) expect(resolveSubagentStatusSurface(i)).toBe(spec(i))
+  })
+
+  it('INV-ORPHAN-VISIBLE: an orphaned foreground sub-agent is NEVER skip when orphanStatus + feed are on', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && !i.liveTurnPresent && i.orphanStatusEnabled && i.workerFeedEnabled) {
+        expect(resolveSubagentStatusSurface(i)).toBe('worker-feed')
+      }
+    }
+  })
+  it('INV-KILL-SWITCH: orphanStatus OFF ⇒ an orphaned foreground sub-agent is exactly the pre-fix behaviour (skip)', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && !i.liveTurnPresent && !i.orphanStatusEnabled) {
+        expect(resolveSubagentStatusSurface(i)).toBe('skip')
+      }
+    }
+  })
+  it('INV-NEST-UNCHANGED: a foreground sub-agent with a live turn is ALWAYS nest, independent of the other flags', () => {
+    for (const i of ROWS) {
+      if (!i.isBackground && i.liveTurnPresent) expect(resolveSubagentStatusSurface(i)).toBe('nest')
+    }
+  })
+  it('INV-BACKGROUND-UNCHANGED: background routing depends ONLY on the feed flag, never on liveTurn/orphanStatus', () => {
+    for (const i of ROWS) {
+      if (i.isBackground) {
+        expect(resolveSubagentStatusSurface(i)).toBe(i.workerFeedEnabled ? 'worker-feed' : 'legacy-relay')
+      }
+    }
+  })
+})

package/telegram-plugin/gateway/subagent-status-surface.ts

@@ -0,0 +1,69 @@
+/**
+ * Where does a sub-agent's live status go?
+ *
+ * A sub-agent's progress is surfaced on one of four "surfaces". This pure
+ * decision picks which, so the routing is provable by total enumeration rather
+ * than buried in the gateway's imperative branches.
+ *
+ *   - `nest`         — a FOREGROUND sub-agent running inside a LIVE parent turn:
+ *                      its narrative nests under the parent's activity draft
+ *                      (the progress card). The default, unchanged.
+ *   - `worker-feed`  — a BACKGROUND worker (the `🛠 Worker` edit-in-place
+ *                      message), OR a FOREGROUND sub-agent that has NO live
+ *                      parent turn to nest into (dispatched outside a turn, or
+ *                      the turn ended while it kept running). The latter is the
+ *                      2026-06-09 fix: extended autonomous work was invisible
+ *                      because foreground status was turn-scoped and a sub-agent
+ *                      with no turn silently returned. It now reuses the worker
+ *                      feed (with the same owner-DM fallback background workers
+ *                      already use), so post-turn work is always visible.
+ *   - `legacy-relay` — a BACKGROUND worker when the worker feed is OFF: fall
+ *                      back to the legacy "still working" injected-inbound relay.
+ *   - `skip`         — nothing to surface (kill-switch off for an orphaned
+ *                      foreground, or no feed to surface it through).
+ *
+ * Determinism: the input space is 4 booleans = 16 rows, enumerated and proven
+ * in subagent-status-surface.test.ts (operator standard
+ * feedback_prove_finite_fsm_not_sample). The load-bearing invariant: an
+ * orphaned foreground sub-agent (no live turn) is `worker-feed`, never `skip`,
+ * whenever the orphan-status flag and the feed are both on.
+ */
+
+export type SubagentStatusSurface = 'nest' | 'worker-feed' | 'legacy-relay' | 'skip'
+
+export interface SubagentStatusSurfaceInput {
+  /** run_in_background dispatch (registry `subagents.background`). */
+  isBackground: boolean
+  /**
+   * A LIVE parent turn exists to nest this (foreground) sub-agent into.
+   * onProgress: `currentTurn != null`. onFinish: `currentTurn != null && it was
+   * actually nested` (so a foreground sub-agent that was surfaced via the worker
+   * feed — never nested — finalizes through the feed, not a turn collapse).
+   * Ignored for background sub-agents.
+   */
+  liveTurnPresent: boolean
+  /** SWITCHROOM_WORKER_ACTIVITY_FEED on. */
+  workerFeedEnabled: boolean
+  /** SWITCHROOM_ORPHAN_SUBAGENT_STATUS on — surface no-parent-turn foreground
+   *  sub-agents via the worker feed. Off = pre-fix behaviour (invisible). */
+  orphanStatusEnabled: boolean
+}
+
+export function resolveSubagentStatusSurface(
+  input: SubagentStatusSurfaceInput,
+): SubagentStatusSurface {
+  if (!input.isBackground) {
+    // Foreground sub-agent.
+    if (input.liveTurnPresent) return 'nest'
+    // Orphaned foreground: no live turn to nest into — the invisible case.
+    if (!input.orphanStatusEnabled) return 'skip' // kill switch: pre-fix behaviour
+    return input.workerFeedEnabled ? 'worker-feed' : 'skip' // surfacing needs the feed
+  }
+  // Background worker.
+  return input.workerFeedEnabled ? 'worker-feed' : 'legacy-relay'
+}
+
+/** SWITCHROOM_ORPHAN_SUBAGENT_STATUS — default ON; `=0` restores pre-fix (invisible) behaviour. */
+export function isOrphanSubagentStatusEnabled(envVal: string | undefined): boolean {
+  return envVal !== '0'
+}

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)
   })
 })