switchroom 0.14.68 → 0.14.70

package/dist/cli/switchroom.js

@@ -49601,8 +49601,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.68";
-var COMMIT_SHA = "4f371b79";
+var VERSION = "0.14.70";
+var COMMIT_SHA = "fdaeb2c4";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.68",
+  "version": "0.14.70",
   "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/answer-stream-flag.ts

@@ -35,3 +35,72 @@ export function parseDraftLaneRetiredEnabled(raw: string | undefined): boolean {
   const v = raw.trim().toLowerCase()
   return !(v === '0' || v === 'false' || v === 'off' || v === 'no')
 }
+
+/**
+ * `minInitialChars` sentinel meaning "never open a visible chat-timeline
+ * preview" — mirrors the `Number.MAX_SAFE_INTEGER` gate the createAnswerStream
+ * call site uses so the lane stays silent.
+ */
+export const ANSWER_LANE_NEVER_OPENS = Number.MAX_SAFE_INTEGER
+
+export type AnswerLaneState = 'visible' | 'draft' | 'dormant'
+
+export interface AnswerLaneConfig {
+  /** `minInitialChars` for createAnswerStream: `1` opens a visible preview on
+   *  the first text chunk; `ANSWER_LANE_NEVER_OPENS` suppresses it. */
+  minInitialChars: number
+  /** Whether the lane streams to the invisible compose-box draft transport. */
+  usesDraftTransport: boolean
+  /** Whether a USER-VISIBLE chat-timeline preview opens — i.e. the surface that
+   *  flashed (raw preview → formatted reply → preview deleted). This is THE
+   *  regression invariant: it must equal `visibleEnabled`, never depend on the
+   *  draft flag. */
+  opensVisiblePreview: boolean
+  /** Label for the boot log. */
+  state: AnswerLaneState
+}
+
+/**
+ * Resolve the answer-lane config from the two INDEPENDENT inputs.
+ *
+ * The visible PREVIEW (the flash surface) is gated on `visibleEnabled` ALONE;
+ * draft retirement controls only the TRANSPORT (whether `sendMessageDraft` is
+ * available). Conflating them was the v0.14.68 regression: retiring the draft
+ * (the default) forced a visible preview that flashed on every streaming turn,
+ * re-opening the flash v0.14.52 had removed. The load-bearing invariant —
+ * `opensVisiblePreview === visibleEnabled` for EVERY `draftFnAvailable` — is
+ * what this function exists to make total-enumerable (the gateway IIFE is not).
+ *
+ *   visibleEnabled                       → 'visible'  (preview opens, minChars 1)
+ *   !visible, draft transport available  → 'draft'    (no preview; draft renders)
+ *   !visible, no draft transport         → 'dormant'  (no preview, no draft:
+ *                                                       the reply tool is the
+ *                                                       only message — the default)
+ */
+export function resolveAnswerLaneConfig(input: {
+  visibleEnabled: boolean
+  draftFnAvailable: boolean
+}): AnswerLaneConfig {
+  if (input.visibleEnabled) {
+    return {
+      minInitialChars: 1,
+      usesDraftTransport: false,
+      opensVisiblePreview: true,
+      state: 'visible',
+    }
+  }
+  if (input.draftFnAvailable) {
+    return {
+      minInitialChars: ANSWER_LANE_NEVER_OPENS,
+      usesDraftTransport: true,
+      opensVisiblePreview: false,
+      state: 'draft',
+    }
+  }
+  return {
+    minInitialChars: ANSWER_LANE_NEVER_OPENS,
+    usesDraftTransport: false,
+    opensVisiblePreview: false,
+    state: 'dormant',
+  }
+}

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

@@ -39767,6 +39767,31 @@ function parseDraftLaneRetiredEnabled(raw) {
   const v = raw.trim().toLowerCase();
   return !(v === "0" || v === "false" || v === "off" || v === "no");
 }
+var ANSWER_LANE_NEVER_OPENS = Number.MAX_SAFE_INTEGER;
+function resolveAnswerLaneConfig(input) {
+  if (input.visibleEnabled) {
+    return {
+      minInitialChars: 1,
+      usesDraftTransport: false,
+      opensVisiblePreview: true,
+      state: "visible"
+    };
+  }
+  if (input.draftFnAvailable) {
+    return {
+      minInitialChars: ANSWER_LANE_NEVER_OPENS,
+      usesDraftTransport: true,
+      opensVisiblePreview: false,
+      state: "draft"
+    };
+  }
+  return {
+    minInitialChars: ANSWER_LANE_NEVER_OPENS,
+    usesDraftTransport: false,
+    opensVisiblePreview: false,
+    state: "dormant"
+  };
+}
 
 // pty-tail.ts
 var import_headless = __toESM(require_xterm_headless(), 1);
@@ -52776,11 +52801,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.68";
-var COMMIT_SHA = "4f371b79";
-var COMMIT_DATE = "2026-06-05T10:24:42Z";
-var LATEST_PR = 2174;
-var COMMITS_AHEAD_OF_TAG = 3;
+var VERSION = "0.14.70";
+var COMMIT_SHA = "fdaeb2c4";
+var COMMIT_DATE = "2026-06-05T23:46:18+10:00";
+var LATEST_PR = null;
+var COMMITS_AHEAD_OF_TAG = 2;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -54026,6 +54051,7 @@ var _noReplyDrainRaw = process.env.SWITCHROOM_SERIALIZE_NOREPLY_DRAIN_MS;
 var _noReplyDrainParsed = _noReplyDrainRaw != null && _noReplyDrainRaw !== "" ? Number(_noReplyDrainRaw) : 2500;
 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 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";
@@ -54058,15 +54084,39 @@ var progressUpdateTurnCount = new Map;
 var currentTurn = null;
 var RECENT_TURNS_MAX = 32;
 var recentTurnsById = new Map;
+var recentTurnIdBySourceMessageId = new Map;
 function rememberRecentTurn(turn) {
   recentTurnsById.set(turn.turnId, turn);
+  if (turn.sourceMessageId != null) {
+    recentTurnIdBySourceMessageId.set(turn.sourceMessageId, turn.turnId);
+  }
   while (recentTurnsById.size > RECENT_TURNS_MAX) {
     const oldest = recentTurnsById.keys().next().value;
     if (oldest === undefined)
       break;
+    const evicted = recentTurnsById.get(oldest);
     recentTurnsById.delete(oldest);
+    if (evicted?.sourceMessageId != null && recentTurnIdBySourceMessageId.get(evicted.sourceMessageId) === oldest) {
+      recentTurnIdBySourceMessageId.delete(evicted.sourceMessageId);
+    }
   }
 }
+function findTurnByQuotedMessageId(chatId, replyTo) {
+  if (!FRAMEWORK_ORIGIN_ROUTING_ENABLED)
+    return null;
+  if (replyTo == null)
+    return null;
+  const mid = Number(replyTo);
+  if (!Number.isFinite(mid))
+    return null;
+  const owner = recentTurnIdBySourceMessageId.get(mid);
+  if (owner == null)
+    return null;
+  const turn = recentTurnsById.get(owner) ?? null;
+  if (turn == null || turn.sessionChatId !== chatId)
+    return null;
+  return turn;
+}
 function deriveTurnId(chatId, threadId, messageId) {
   if (messageId == null || messageId === "" || String(messageId) === "0")
     return null;
@@ -54088,7 +54138,7 @@ function findLatestEndedTurnForChat(chatId) {
   }
   return latest;
 }
-function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, liveTurn, surface) {
+function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, originVia, liveTurn, surface) {
   const recovered = LATE_REPLY_TOPIC_RECOVERY_ENABLED && explicitThreadId == null && originTurn == null && liveTurn == null ? findLatestEndedTurnForChat(chatId) : null;
   const threadId = resolveAnswerThreadId({
     explicitThreadId,
@@ -54098,14 +54148,23 @@ function resolveAnswerThreadWithLog(chatId, explicitThreadId, originTurn, liveTu
     lastEndedResolvedForChat: recovered != null,
     lastEndedThreadIdForChat: recovered?.sessionThreadId
   });
-  const via = explicitThreadId != null ? "explicit" : originTurn != null ? "origin" : liveTurn?.sessionThreadId != null ? "live" : recovered != null ? "recovered" : "none";
+  const via = explicitThreadId != null ? "explicit" : originTurn != null ? originVia === "quoted" ? "quoted" : "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)" : "") + `
+  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)" : "") + `
 `);
   return threadId;
 }
+function hasDifferentThreadedRecentTurn(chatId, liveThreadId) {
+  const live = liveThreadId ?? null;
+  for (const t of recentTurnsById.values()) {
+    if (t.sessionChatId === chatId && (t.sessionThreadId ?? null) !== live)
+      return true;
+  }
+  return false;
+}
 function closeObligationOnSubstantiveReply(args, liveTurn) {
   if (!OBLIGATION_LEDGER_ENABLED)
     return;
@@ -55179,6 +55238,10 @@ var STREAM_THROTTLE_MS_OVERRIDE = (() => {
 })();
 var TURN_FLUSH_SAFETY_ENABLED = isTurnFlushSafetyEnabled();
 var ANSWER_STREAM_VISIBLE_ENABLED = parseVisibleAnswerStreamEnabled(process.env.SWITCHROOM_VISIBLE_ANSWER_STREAM);
+var ANSWER_LANE = resolveAnswerLaneConfig({
+  visibleEnabled: ANSWER_STREAM_VISIBLE_ENABLED,
+  draftFnAvailable: sendMessageDraftFn != null
+});
 var CLEAR_STATUS_ON_COMPLETION = (() => {
   const raw = process.env.SWITCHROOM_TG_CLEAR_STATUS_ON_COMPLETION;
   if (raw == null)
@@ -56339,8 +56402,10 @@ ${url}`;
   let threadId;
   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 = resolveAnswerThreadWithLog(chat_id, Number.isFinite(explicit) ? explicit : undefined, originTurn, turn, "reply");
+    const echoedTurn = findTurnByOriginId(args.origin_turn_id);
+    const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(chat_id, args.reply_to) : null;
+    const originTurn = echoedTurn ?? quotedTurn;
+    threadId = resolveAnswerThreadWithLog(chat_id, Number.isFinite(explicit) ? explicit : undefined, originTurn, originTurn == null ? null : echoedTurn != null ? "echo" : "quoted", turn, "reply");
   } else {
     threadId = resolveThreadId(chat_id, args.message_thread_id ?? (turn?.sessionThreadId != null ? turn.sessionThreadId : undefined));
   }
@@ -56699,8 +56764,10 @@ async function executeStreamReply(args) {
   if (args.message_thread_id == null) {
     let injected;
     if (TURN_ORIGIN_ROUTING_ENABLED) {
-      const originTurn = findTurnByOriginId(args.origin_turn_id);
-      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, originTurn, turn, "stream_reply");
+      const echoedTurn = findTurnByOriginId(args.origin_turn_id);
+      const quotedTurn = echoedTurn == null ? findTurnByQuotedMessageId(String(args.chat_id), args.reply_to) : null;
+      const originTurn = echoedTurn ?? quotedTurn;
+      injected = resolveAnswerThreadWithLog(String(args.chat_id), undefined, originTurn, originTurn == null ? null : echoedTurn != null ? "echo" : "quoted", turn, "stream_reply");
     } else {
       injected = turn?.sessionThreadId;
     }
@@ -58113,7 +58180,7 @@ function handleSessionEvent(ev) {
             chatId: turn.sessionChatId,
             isPrivateChat: turn.isDm,
             threadId: turn.sessionThreadId,
-            ...ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED ? { minInitialChars: 1 } : { sendMessageDraft: sendMessageDraftFn, minInitialChars: Number.MAX_SAFE_INTEGER },
+            ...ANSWER_LANE.usesDraftTransport ? { sendMessageDraft: sendMessageDraftFn, minInitialChars: ANSWER_LANE.minInitialChars } : { minInitialChars: ANSWER_LANE.minInitialChars },
             sendMessage: async (chatId, text, params) => {
               const tid = params?.message_thread_id;
               const silent = params?.purpose !== "materialize";
@@ -58245,7 +58312,7 @@ function handleSessionEvent(ev) {
         const stream = turn.answerStream;
         const streamedMsgId = stream.messageId();
         const streamedFinalText = turn.capturedText.join("").trim();
-        if ((ANSWER_STREAM_VISIBLE_ENABLED || DRAFT_ANSWER_LANE_RETIRED) && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
+        if (ANSWER_LANE.opensVisiblePreview && !turn.replyCalled && streamedMsgId != null && streamedFinalText.length > 0) {
           turn.answerStream = null;
           streamFinalizedAsAnswer = true;
           turn.finalAnswerDelivered = true;
@@ -64581,7 +64648,7 @@ var didOneTimeSetup = false;
           }
         }
       }
-      process.stderr.write(`telegram gateway: answer-stream lane=${DRAFT_ANSWER_LANE_RETIRED ? "visible(draft-retired)" : ANSWER_STREAM_VISIBLE_ENABLED ? "visible" : "draft"} draftFn=${sendMessageDraftFn != null ? "available" : "off"} grammy=${GRAMMY_VERSION}
+      process.stderr.write(`telegram gateway: answer-stream lane=${ANSWER_LANE.state} draftFn=${sendMessageDraftFn != null ? "available" : "off"} visible=${ANSWER_STREAM_VISIBLE_ENABLED} draftRetired=${DRAFT_ANSWER_LANE_RETIRED} grammy=${GRAMMY_VERSION}
 `);
       process.stderr.write(`telegram gateway: starting bot polling pid=${process.pid} agent=${process.env.SWITCHROOM_AGENT_NAME ?? "-"} stateDir=${STATE_DIR} historyEnabled=${HISTORY_ENABLED} streamMode=${process.env.SWITCHROOM_TG_STREAM_MODE ?? "checklist"}
 `);

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { resolveAnswerThreadId } from './answer-thread-resolve.js'
+import { resolveAnswerThreadId, type AnswerThreadInput } from './answer-thread-resolve.js'
 
 describe('resolveAnswerThreadId — precedence', () => {
   it('(1) explicit model thread wins over everything', () => {
@@ -83,3 +83,137 @@ describe('resolveAnswerThreadId — precedence', () => {
     expect(resolveAnswerThreadId({ originResolved: false })).toBeUndefined()
   })
 })
+
+// ── 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[] {
+  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
+}
+
+// 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)
+}
+
+describe('resolveAnswerThreadId — total-enumeration determinism proof (all 64 inputs)', () => {
+  const ROWS = allInputs()
+
+  it('the input space is exactly 64 rows (2^6)', () => {
+    expect(ROWS.length).toBe(64)
+  })
+
+  it('TOTAL: every input returns without throwing', () => {
+    for (const i of ROWS) {
+      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('NO FABRICATION: every output is undefined or one of the four input thread fields', () => {
+    for (const i of ROWS) {
+      const out = resolveAnswerThreadId(i)
+      const provenance = new Set([
+        undefined,
+        i.explicitThreadId,
+        i.originThreadId,
+        i.liveThreadId,
+        i.lastEndedThreadIdForChat,
+      ])
+      expect(provenance.has(out)).toBe(true)
+    }
+  })
+
+  it('PRECEDENCE: matches the documented spec on all 64 inputs', () => {
+    for (const i of ROWS) {
+      expect(resolveAnswerThreadId(i)).toBe(specExpected(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('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)
+      }
+    }
+  })
+
+  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-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()
+        expect(i.originResolved).toBe(false)
+      }
+    }
+  })
+})