switchroom 0.14.65 → 0.14.66

package/dist/cli/switchroom.js

@@ -49452,8 +49452,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.65";
-var COMMIT_SHA = "ff6f75c4";
+var VERSION = "0.14.66";
+var COMMIT_SHA = "0f4f029d";
 
 // src/cli/agent.ts
 init_source();
@@ -52027,7 +52027,7 @@ function buildSettingsHooksBlock(p) {
 
 ` + 'Do NOT send a trailing confirmation after your answer \u2014 no "Done.", ' + '"Sent.", "Hope that helps." as a separate message once you have ' + "already replied. Your answer is the last thing the user should " + `see; a follow-up "Done." is dead-air clutter (and the user's ` + `device already pinged on the answer). Stop after the answer.
 
-` + 'CRITICAL: "answer" means a call to the reply tool ' + "(mcp__switchroom-telegram__reply, or stream_reply with done=true). " + "Your terminal/transcript text is NEVER delivered to Telegram \u2014 the " + "user sees only what you send through the reply tool. After a long " + "tool sequence (scheduling, multi-step research, sub-agent handback), " + "do not let your closing narration stand as the answer: end the turn " + "by passing that narration to the reply tool. No reply tool call = the " + "user got nothing, however much text you wrote.</turn-pacing>";
+` + 'CRITICAL: "answer" means a call to the reply tool ' + "(mcp__switchroom-telegram__reply, or stream_reply with done=true). " + "Your terminal/transcript text is NEVER delivered to Telegram \u2014 the " + "user sees only what you send through the reply tool. After a long " + "tool sequence (scheduling, multi-step research, sub-agent handback), " + "do not let your closing narration stand as the answer: end the turn " + "by passing that narration to the reply tool. No reply tool call = the " + "user got nothing, however much text you wrote. Call the reply tool as " + "your FIRST action when you have the answer \u2014 do not write it out as " + "transcript text first and call reply afterward: a framework backstop " + "flushes unsent text after a delay and then your real reply lands late " + "and out of order.</turn-pacing>";
   const switchroomUserPromptSubmit = [
     ...useHotReloadStable ? [
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.65",
+  "version": "0.14.66",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

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

@@ -47936,6 +47936,10 @@ function resolveAnswerThreadId(input) {
     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;
 }
 
@@ -52759,11 +52763,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.65";
-var COMMIT_SHA = "ff6f75c4";
-var COMMIT_DATE = "2026-06-05T04:09:09Z";
-var LATEST_PR = 2165;
-var COMMITS_AHEAD_OF_TAG = 0;
+var VERSION = "0.14.66";
+var COMMIT_SHA = "0f4f029d";
+var COMMIT_DATE = "2026-06-05T07:05:45Z";
+var LATEST_PR = 2167;
+var COMMITS_AHEAD_OF_TAG = 2;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -54061,6 +54065,33 @@ function findTurnByOriginId(originTurnId) {
     return currentTurn;
   return recentTurnsById.get(originTurnId) ?? null;
 }
+var LATE_REPLY_TOPIC_RECOVERY_ENABLED = process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== "0";
+function findLatestEndedTurnForChat(chatId) {
+  let latest = null;
+  for (const t of recentTurnsById.values()) {
+    if (t.sessionChatId === chatId)
+      latest = t;
+  }
+  return latest;
+}
+function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, liveTurn, surface) {
+  const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn?.sessionThreadId == null ? findLatestEndedTurnForChat(chatId) : null;
+  const threadId = resolveAnswerThreadId({
+    explicitThreadId,
+    originResolved: originTurn != null,
+    originThreadId: originTurn?.sessionThreadId,
+    liveThreadId: liveTurn?.sessionThreadId,
+    lastEndedResolvedForChat: recovered != null,
+    lastEndedThreadIdForChat: recovered?.sessionThreadId
+  });
+  const via = explicitThreadId != null ? "explicit" : originTurn != null ? "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
+  const ownerTurn = originTurn ?? recovered ?? liveTurn;
+  const isSupergroup = chatId.startsWith("-100");
+  const unrouted = isSupergroup && threadId == null;
+  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" : "") + (unrouted ? " UNROUTED(supergroup\u2192no-topic)" : "") + `
+`);
+  return threadId;
+}
 function closeObligationOnSubstantiveReply(args, liveTurn) {
   if (!OBLIGATION_LEDGER_ENABLED)
     return;
@@ -56291,12 +56322,7 @@ ${url}`;
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const originTurn = findTurnByOriginId(args.origin_turn_id);
-    threadId = resolveAnswerThreadId({
-      explicitThreadId: Number.isFinite(explicit) ? explicit : undefined,
-      originResolved: originTurn != null,
-      originThreadId: originTurn?.sessionThreadId,
-      liveThreadId: turn?.sessionThreadId
-    });
+    threadId = resolveAnswerThreadWithLog(chat_id, Number.isFinite(explicit) ? explicit : undefined, originTurn, turn, "reply");
   } else {
     threadId = resolveThreadId(chat_id, args.message_thread_id ?? (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined));
   }
@@ -56656,12 +56682,7 @@ async function executeStreamReply(args) {
     let injected;
     if (TURN_ORIGIN_ROUTING_ENABLED) {
       const originTurn = findTurnByOriginId(args.origin_turn_id);
-      injected = resolveAnswerThreadId({
-        explicitThreadId: undefined,
-        originResolved: originTurn != null,
-        originThreadId: originTurn?.sessionThreadId,
-        liveThreadId: turn?.sessionThreadId
-      });
+      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, originTurn, turn, "stream_reply");
     } else {
       injected = turn?.sessionThreadId;
     }

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

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest'
+import { resolveAnswerThreadId } from './answer-thread-resolve.js'
+
+describe('resolveAnswerThreadId — precedence', () => {
+  it('(1) explicit model thread wins over everything', () => {
+    expect(
+      resolveAnswerThreadId({
+        explicitThreadId: 7,
+        originResolved: true,
+        originThreadId: 3,
+        liveThreadId: 4,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 9,
+      }),
+    ).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()
+  })
+
+  it('(3) no origin → falls back to the live turn thread (legacy #1664)', () => {
+    expect(
+      resolveAnswerThreadId({ originResolved: false, liveThreadId: 4 }),
+    ).toBe(4)
+  })
+
+  // ── 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.
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 3,
+      }),
+    ).toBe(3)
+  })
+
+  it('(4) a recovered DM turn (ended, thread undefined) stays threadless', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: undefined,
+      }),
+    ).toBeUndefined()
+  })
+
+  it('(4) recovery does NOT override a live turn — live thread still wins at tier 3', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: 4,
+        lastEndedResolvedForChat: true,
+        lastEndedThreadIdForChat: 3,
+      }),
+    ).toBe(4)
+  })
+
+  it('(4) no recovery candidate → legacy result (undefined), unchanged', () => {
+    expect(
+      resolveAnswerThreadId({
+        originResolved: false,
+        liveThreadId: undefined,
+        lastEndedResolvedForChat: false,
+      }),
+    ).toBeUndefined()
+  })
+
+  it('pure DM (every tier undefined) → undefined', () => {
+    expect(resolveAnswerThreadId({ originResolved: false })).toBeUndefined()
+  })
+})

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

@@ -26,10 +26,14 @@
  *   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 (origin resolved AND it differs from the live turn) we pin to
- *      the origin thread and explicitly DO NOT fall through to the chat's
- *      last-seen `chatThreadMap` thread. For answer surfaces the chat
- *      last-seen heuristic is exactly what produced the wrong-topic bug.
+ *   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 `chatThreadMap` last-seen fallback is preserved for NON-answer
  * surfaces (`send_typing`, `forward_message`, `progress_update`) by NOT
@@ -53,6 +57,20 @@ export interface AnswerThreadInput {
    *  (no live turn, or a DM live turn). The legacy (#1664) fallback when
    *  no origin turn is resolvable. */
   liveThreadId?: number | undefined
+  /**
+   * Late-reply topic recovery (2026-06-05). Thread of the most-recently-ended
+   * turn for THIS chat (from `recentTurnsById`), used as a deterministic
+   * fallback when the model echoed no `origin_turn_id` AND there is no live
+   * 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.
+   */
+  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
 }
 
 /**
@@ -75,5 +93,13 @@ export function resolveAnswerThreadId(input: AnswerThreadInput): number | undefi
   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.
+  if (input.lastEndedResolvedForChat) return input.lastEndedThreadIdForChat
   return input.liveThreadId
 }

package/telegram-plugin/gateway/gateway.ts

@@ -1888,6 +1888,83 @@ function findTurnByOriginId(originTurnId: string | null | undefined): CurrentTur
   return recentTurnsById.get(originTurnId) ?? null
 }
 
+// Late-reply topic recovery (2026-06-05 marko triage). Default ON; kill switch
+// SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY=0 restores the legacy behaviour (a late
+// reply with no echoed origin and no live turn defaults to General).
+const LATE_REPLY_TOPIC_RECOVERY_ENABLED =
+  process.env.SWITCHROOM_LATE_REPLY_TOPIC_RECOVERY !== '0'
+
+/**
+ * The most-recently-started turn for a chat from the bounded recently-ended
+ * registry — the deterministic fallback for a LATE answer reply when the model
+ * echoed no `origin_turn_id` and `currentTurn` has already cleared. Iterates in
+ * insertion order so the last match is the most recent turn for that chat.
+ * Returns null when the chat has no remembered turn (so the caller keeps the
+ * legacy result). NB: this is the chat's own most-recent TURN, not the
+ * `chatThreadMap` last-seen-any-message heuristic that caused the wrong-topic
+ * bug — a late reply almost always belongs to the turn that just ended.
+ */
+function findLatestEndedTurnForChat(chatId: string): CurrentTurn | null {
+  let latest: CurrentTurn | null = null
+  for (const t of recentTurnsById.values()) {
+    if (t.sessionChatId === chatId) latest = t
+  }
+  return latest
+}
+
+/**
+ * Resolve the answer-reply thread AND emit `reply-route` telemetry. The
+ * 2026-06-05 triage showed reply routing was the blind spot: `reply: invoked`
+ * logged only chat + char count, so a late reply landing in the wrong topic was
+ * invisible without hand-correlating raw tg-post threads against turn-lifecycle
+ * timestamps. This wrapper logs, per reply: which precedence tier won (`via`),
+ * the resolved thread, the origin turn + its thread, and whether the reply was
+ * late (turn already ended). `via=recovered` marks a late reply this fix saved
+ * from General; `UNROUTED` flags a supergroup reply that still resolved to no
+ * topic (the residual gap to watch).
+ */
+function resolveAnswerThreadWithLog(
+  chatId: string,
+  explicitThreadId: number | undefined,
+  originTurn: CurrentTurn | null,
+  liveTurn: CurrentTurn | null,
+  surface: 'reply' | 'stream_reply',
+): number | undefined {
+  const recovered =
+    LATE_REPLY_TOPIC_RECOVERY_ENABLED &&
+    explicitThreadId == null &&
+    originTurn == null &&
+    liveTurn?.sessionThreadId == null
+      ? findLatestEndedTurnForChat(chatId)
+      : null
+  const threadId = resolveAnswerThreadId({
+    explicitThreadId,
+    originResolved: originTurn != null,
+    originThreadId: originTurn?.sessionThreadId,
+    liveThreadId: liveTurn?.sessionThreadId,
+    lastEndedResolvedForChat: recovered != null,
+    lastEndedThreadIdForChat: recovered?.sessionThreadId,
+  })
+  const via =
+    explicitThreadId != null ? 'explicit'
+    : originTurn != null ? 'origin'
+    : liveTurn?.sessionThreadId != null ? 'live'
+    : recovered != null ? 'recovered'
+    : 'none'
+  const ownerTurn = originTurn ?? recovered ?? liveTurn
+  const isSupergroup = chatId.startsWith('-100')
+  const unrouted = isSupergroup && threadId == null
+  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' : '') +
+      (unrouted ? ' UNROUTED(supergroup→no-topic)' : '') +
+      '\n',
+  )
+  return threadId
+}
+
 /**
  * PR2 obligation-ledger CLOSE. Called when a SUBSTANTIVE final answer lands
  * (not a bare interim ack — using finalAnswerSubstantive, the #2141 signal): the
@@ -6522,12 +6599,13 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   if (TURN_ORIGIN_ROUTING_ENABLED) {
     const explicit = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     const originTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-    threadId = resolveAnswerThreadId({
-      explicitThreadId: Number.isFinite(explicit as number) ? (explicit as number) : undefined,
-      originResolved: originTurn != null,
-      originThreadId: originTurn?.sessionThreadId,
-      liveThreadId: turn?.sessionThreadId,
-    })
+    threadId = resolveAnswerThreadWithLog(
+      chat_id,
+      Number.isFinite(explicit as number) ? (explicit as number) : undefined,
+      originTurn,
+      turn,
+      'reply',
+    )
   } else {
     threadId = resolveThreadId(
       chat_id,
@@ -7178,12 +7256,13 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     let injected: number | undefined
     if (TURN_ORIGIN_ROUTING_ENABLED) {
       const originTurn = findTurnByOriginId(args.origin_turn_id as string | undefined)
-      injected = resolveAnswerThreadId({
-        explicitThreadId: undefined,
-        originResolved: originTurn != null,
-        originThreadId: originTurn?.sessionThreadId,
-        liveThreadId: turn?.sessionThreadId,
-      })
+      injected = resolveAnswerThreadWithLog(
+        String(args.chat_id),
+        undefined,
+        originTurn,
+        turn,
+        'stream_reply',
+      )
     } else {
       injected = turn?.sessionThreadId
     }

package/telegram-plugin/tests/multitopic-routing-wiring.test.ts

@@ -45,13 +45,15 @@ describe('component 3 — turn-origin reply routing', () => {
     const fn = gatewaySrc.split('async function executeReply')[1]?.split('\nasync function ')[0] ?? ''
     expect(fn).toMatch(/TURN_ORIGIN_ROUTING_ENABLED/)
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
-    expect(fn).toMatch(/resolveAnswerThreadId\(/)
+    // The resolution + reply-route telemetry go through resolveAnswerThreadWithLog,
+    // which calls the pure resolveAnswerThreadId internally (incl. tier-4 recovery).
+    expect(fn).toMatch(/resolveAnswerThread\w*\(/)
   })
 
   it('executeStreamReply resolves the answer thread via the origin turn too', () => {
     const fn = gatewaySrc.split('async function executeStreamReply')[1]?.split('\nasync function ')[0] ?? ''
     expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
-    expect(fn).toMatch(/resolveAnswerThreadId\(/)
+    expect(fn).toMatch(/resolveAnswerThread\w*\(/)
   })
 
   it('the reply + stream_reply tool schemas expose origin_turn_id to the model', () => {