switchroom 0.13.0 → 0.13.1

package/dist/cli/switchroom.js

@@ -47248,8 +47248,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.0";
-var COMMIT_SHA = "9b3d62f2";
+var VERSION = "0.13.1";
+var COMMIT_SHA = "b7489c5a";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "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

@@ -31221,6 +31221,7 @@ function createDraftStream(send, edit, config = {}) {
           draftId = allocateDraftId();
           currentChunkStartedAt = null;
           persistChainFires++;
+          sendFires++;
           if (process.env.SWITCHROOM_STREAM_TRACES !== "0") {
             process.stderr.write(`gw-trace stream-persist chunk_chars=${chunk.length} ` + `elapsed=${elapsed} reason=${timeElapsed ? "time" : "size"} ` + `newMsgId=${newMsgId} newDraftId=${draftId} ` + `chatId=${chatId || "-"}
 `);
@@ -31367,6 +31368,7 @@ function createDraftStream(send, edit, config = {}) {
           try {
             messageId = await send(textToMaterialize);
             persistedTextLen = fullText.length;
+            sendFires++;
             log?.(`stream \u2192 materialized tail (id: ${messageId}, ${textToMaterialize.length} chars)`);
           } catch (err) {
             warn?.(`draft-stream: materialize sendMessage failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -47677,10 +47679,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.0";
-var COMMIT_SHA = "9b3d62f2";
-var COMMIT_DATE = "2026-05-20T22:23:43Z";
-var LATEST_PR = 1600;
+var VERSION = "0.13.1";
+var COMMIT_SHA = "b7489c5a";
+var COMMIT_DATE = "2026-05-21T00:27:54Z";
+var LATEST_PR = 1609;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -48630,18 +48632,21 @@ function statusKey(chatId, threadId) {
 function streamKey3(chatId, threadId) {
   return chatKey(chatId, threadId);
 }
-function purgeReactionTracking(key, endingTurn) {
-  const outboundEmitted = endingTurn != null ? endingTurn.replyCalled === true : currentTurn?.replyCalled === true;
-  shadowEmit({ kind: "turnEnd", key, at: Date.now(), outboundEmitted });
+function clearReactionState(key) {
   const msgInfo = activeReactionMsgIds.get(key);
   activeStatusReactions.delete(key);
   activeReactionMsgIds.delete(key);
-  activeTurnStartedAt.delete(key);
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv();
     if (agentDir != null)
       removeActiveReaction(agentDir, msgInfo.chatId, msgInfo.messageId);
   }
+}
+function purgeReactionTracking(key, endingTurn, outboundEmittedOverride) {
+  const outboundEmitted = outboundEmittedOverride !== undefined ? outboundEmittedOverride : endingTurn != null ? endingTurn.replyCalled === true : currentTurn?.replyCalled === true;
+  shadowEmit({ kind: "turnEnd", key, at: Date.now(), outboundEmitted });
+  clearReactionState(key);
+  activeTurnStartedAt.delete(key);
   if (activeTurnStartedAt.size === 0) {
     const selfAgentForFlush = process.env.SWITCHROOM_AGENT_NAME ?? "";
     if (pendingInboundBuffer.depth(selfAgentForFlush) > 0) {
@@ -48791,7 +48796,7 @@ function endStatusReaction(chatId, threadId, outcome) {
     ctrl.setDone();
   else
     ctrl.setError();
-  purgeReactionTracking(key);
+  clearReactionState(key);
 }
 function resolveThreadId(chat_id, explicit) {
   if (explicit != null)
@@ -49514,8 +49519,8 @@ startTimer({
     lastPtyPreviewByChat.delete(fbKey);
     preambleSuppressor.dropNow();
     endTurn(fbKey);
-    purgeReactionTracking(fbKey);
-    const fbExtraPurge = purgeStaleTurnsForChat(fbChatId, activeTurnStartedAt.keys(), purgeReactionTracking);
+    purgeReactionTracking(fbKey, undefined, false);
+    const fbExtraPurge = purgeStaleTurnsForChat(fbChatId, activeTurnStartedAt.keys(), (k) => purgeReactionTracking(k, undefined, false));
     if (turnMatchesFallback && currentTurn === wedgedTurn)
       currentTurn = null;
     try {
@@ -51337,7 +51342,6 @@ function handleSessionEvent(ev) {
         const ctrl = activeStatusReactions.get(ceKey);
         if (ctrl)
           ctrl.setError();
-        purgeReactionTracking(ceKey);
         endTurn(ceKey);
         if (turn.answerStream != null) {
           turn.answerStream.stop();
@@ -51420,7 +51424,6 @@ function handleSessionEvent(ev) {
         unpinProgressCardForChat?.(chatId, threadId);
         if (ctrl)
           ctrl.setDone();
-        purgeReactionTracking(statusKey(chatId, threadId));
         {
           const sKey = streamKey3(chatId, threadId);
           const turnDurationMs = turn.startedAt > 0 ? Date.now() - turn.startedAt : 0;
@@ -51491,7 +51494,7 @@ function handleSessionEvent(ev) {
               if (recentCount > 0) {
                 process.stderr.write(`telegram gateway: turn-flush suppressed \u2014 reply tool sent ${recentCount} message(s) within 2s
 `);
-                purgeReactionTracking(statusKey(backstopChatId, backstopThreadId));
+                purgeReactionTracking(statusKey(backstopChatId, backstopThreadId), turn);
                 return;
               }
             } catch {}
@@ -51576,14 +51579,13 @@ function handleSessionEvent(ev) {
             if (backstopCtrl)
               backstopCtrl.setError();
           } finally {
-            purgeReactionTracking(statusKey(backstopChatId, backstopThreadId));
+            purgeReactionTracking(statusKey(backstopChatId, backstopThreadId), turn);
           }
         })();
         return;
       }
       if (ctrl)
         ctrl.setDone();
-      purgeReactionTracking(statusKey(chatId, threadId));
       {
         const sKey = streamKey3(chatId, threadId);
         const turnDurationMs = turn.startedAt > 0 ? Date.now() - turn.startedAt : 0;

package/telegram-plugin/draft-stream.ts

@@ -461,6 +461,12 @@ export function createDraftStream(
           draftId = allocateDraftId()
           currentChunkStartedAt = null
           persistChainFires++
+          // PR follow-up: persist-chain's bare send() bypasses
+          // sendViaMessage's increment, same shape as the finalize-
+          // materialize bug. Without this, streams that cross the
+          // 25s / 4000-char boundary would under-report `sends` by
+          // the chain count in stream-end.
+          sendFires++
           if (process.env.SWITCHROOM_STREAM_TRACES !== '0') {
             process.stderr.write(
               `gw-trace stream-persist chunk_chars=${chunk.length} ` +
@@ -664,6 +670,13 @@ export function createDraftStream(
           try {
             messageId = await send(textToMaterialize)
             persistedTextLen = fullText.length
+            // PR follow-up: bump sendFires so the stream-end trace
+            // reflects the finalize-materialize sendMessage call. Pre-
+            // this fix, the counter under-reported by 1 for every
+            // draft-transport stream that produced a non-empty reply:
+            // gw-trace stream-end showed `drafts=N sends=0` even
+            // though sendMessage HAD fired (visible in tg-post lines).
+            sendFires++
             log?.(`stream → materialized tail (id: ${messageId}, ${textToMaterialize.length} chars)`)
           } catch (err) {
             warn?.(`draft-stream: materialize sendMessage failed: ${err instanceof Error ? err.message : String(err)}`)

package/telegram-plugin/gateway/gateway.ts

@@ -1278,32 +1278,62 @@ function streamKey(chatId: string, threadId?: number | null): string {
   return chatKey(chatId, threadId)
 }
 
-function purgeReactionTracking(key: string, endingTurn?: CurrentTurn): void {
-  // Phase 2b: turn end. The key was registered via setTurnStarted when
-  // the inbound arrived; purge is the canonical turn-end signal.
-  //
-  // outboundEmitted: read from the explicit `endingTurn` parameter when
-  // provided (canonical path via endCurrentTurnAtomic — module-scope
-  // currentTurn is already null by the time we get here), falling back
-  // to `currentTurn?.replyCalled` for the legacy callsites that haven't
-  // been threaded yet (sibling-key purges, restart-init cleanup).
-  // Without this explicit-turn handoff the shadow trace would report
-  // outboundEmitted=false on every replied turn (the dominant happy
-  // path), producing strictly worse data than the blind `true` it
-  // replaced. Invariant #5's `lastOutboundAt` correctness depends on
-  // this signal being accurate.
-  const outboundEmitted = endingTurn != null
-    ? endingTurn.replyCalled === true
-    : currentTurn?.replyCalled === true
-  shadowEmit({ kind: 'turnEnd', key: key as _ChatKey, at: Date.now(), outboundEmitted })
+/**
+ * Reaction-state cleanup — controller + msg-id maps + active-reaction
+ * file removal. PURE reaction-cleanup, no turn-end semantics:
+ *   - does NOT emit shadow `turnEnd`
+ *   - does NOT clear `activeTurnStartedAt` (turn-active marker)
+ *   - does NOT fire the model-idle restart/flush gate
+ *
+ * Called from mid-turn signals like `endStatusReaction` (post-reply-tool,
+ * post-stream-reply-finalize) where the 👍 transition fires but the
+ * turn is still active. Per #1603 audit step 2: the reply tool was
+ * previously calling `purgeReactionTracking` here, which fired premature
+ * shadow `turnEnd` events and cleared `activeTurnStartedAt` mid-turn —
+ * the latter would trigger the model-idle restart probe and
+ * pendingInbound flush as if claude had gone idle.
+ */
+function clearReactionState(key: string): void {
   const msgInfo = activeReactionMsgIds.get(key)
   activeStatusReactions.delete(key)
   activeReactionMsgIds.delete(key)
-  activeTurnStartedAt.delete(key)
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv()
     if (agentDir != null) removeActiveReaction(agentDir, msgInfo.chatId, msgInfo.messageId)
   }
+}
+
+function purgeReactionTracking(
+  key: string,
+  endingTurn?: CurrentTurn,
+  outboundEmittedOverride?: boolean,
+): void {
+  // Phase 2b: turn end. The key was registered via setTurnStarted when
+  // the inbound arrived; purge is the canonical turn-end signal.
+  //
+  // outboundEmitted derivation, in precedence order:
+  //   1. Explicit `outboundEmittedOverride` (e.g. silence-poke
+  //      framework fallback FORCES false because the 5-min fallback
+  //      firing proves visible delivery never happened — regardless of
+  //      whatever `replyCalled` the wedged turn object carries).
+  //   2. `endingTurn.replyCalled` when the canonical caller threads
+  //      the authoritative turn (endCurrentTurnAtomic path; module-scope
+  //      currentTurn is already null by the time we get here).
+  //   3. `currentTurn?.replyCalled` fallback for the (now-vanishing)
+  //      legacy callsites. Without the explicit-turn handoff the shadow
+  //      trace would report outboundEmitted=false on every replied
+  //      turn (the dominant happy path), producing strictly worse data
+  //      than the blind `true` it replaced. Invariant #5's
+  //      `lastOutboundAt` correctness depends on this signal being
+  //      accurate.
+  const outboundEmitted = outboundEmittedOverride !== undefined
+    ? outboundEmittedOverride
+    : endingTurn != null
+      ? endingTurn.replyCalled === true
+      : currentTurn?.replyCalled === true
+  shadowEmit({ kind: 'turnEnd', key: key as _ChatKey, at: Date.now(), outboundEmitted })
+  clearReactionState(key)
+  activeTurnStartedAt.delete(key)
 
   // If no more active turns and a restart is pending, perform it now.
   //
@@ -1593,12 +1623,24 @@ async function resolveCompactCard(
 }
 
 function endStatusReaction(chatId: string, threadId: number | undefined, outcome: 'done' | 'error'): void {
+  // Mid-turn signal: the reply tool fired, or stream_reply finalized,
+  // and the status-reaction needs to transition to its terminal emoji
+  // (👍 / ⚠️). The turn itself is still active — the canonical turn-end
+  // signal is `endCurrentTurnAtomic(turn)`, which runs later via the
+  // turn_end handler / context-exhaust path / silent-marker path.
+  //
+  // Pre-#1603 audit step 2 (this commit), this called
+  // `purgeReactionTracking(key)` directly, which would fire shadow
+  // `turnEnd` and clear the turn-active marker mid-turn — the latter
+  // triggering the model-idle restart probe + pendingInbound flush as
+  // if claude had gone idle. Use `clearReactionState` to only do the
+  // reaction-cleanup work.
   const key = statusKey(chatId, threadId)
   const ctrl = activeStatusReactions.get(key)
   if (!ctrl) return
   if (outcome === 'done') ctrl.setDone()
   else ctrl.setError()
-  purgeReactionTracking(key)
+  clearReactionState(key)
 }
 
 function resolveThreadId(chat_id: string, explicit?: string | number | null): number | undefined {
@@ -3093,7 +3135,15 @@ silencePoke.startTimer({
     // Drop silence-poke state and clear turn-active so the next inbound
     // for this chat starts a fresh turn instead of queueing forever.
     silencePoke.endTurn(fbKey)
-    purgeReactionTracking(fbKey)
+    // PR 3b step 5 (#1603 audit): force outboundEmitted=false. The
+    // framework fallback fires precisely because visible delivery
+    // didn't happen in 5 min — `wedgedTurn.replyCalled` may have been
+    // set during the turn (e.g. reply tool invoked but Telegram side
+    // never confirmed delivery), but from the user's perspective no
+    // outbound landed. The state machine's `noteOutbound` effect
+    // must NOT fire for this path. Pass `undefined` for endingTurn
+    // and `false` as the explicit override.
+    purgeReactionTracking(fbKey, undefined, false)
     // Defense-in-depth: the fallback's purgeReactionTracking above
     // clears the canonical statusKey(chatId, threadId) for fbKey
     // only. activeTurnStartedAt can hold sibling entries for the
@@ -3106,10 +3156,14 @@ silencePoke.startTimer({
     // purger. Multi-chat-safe — only touches keys for fbChatId, so
     // #1546's intentional cross-chat safety guard is preserved.
     // See turn-state-purge.ts.
+    //
+    // Same `outboundEmitted=false` rationale as the bare call above —
+    // wrap the purger so every sibling-key purge emits a fallback
+    // shadow turnEnd with the truthful "no visible delivery" signal.
     const fbExtraPurge = purgeStaleTurnsForChat(
       fbChatId,
       activeTurnStartedAt.keys(),
-      purgeReactionTracking,
+      (k) => purgeReactionTracking(k, undefined, false),
     )
     // Null `currentTurn` if it's still pointing at the wedged turn —
     // when claude eventually fires a late `turn_end` for this session
@@ -5828,7 +5882,10 @@ function handleSessionEvent(ev: SessionEvent): void {
         const ceKey = statusKey(chatId, threadId)
         const ctrl = activeStatusReactions.get(ceKey)
         if (ctrl) ctrl.setError()
-        purgeReactionTracking(ceKey)
+        // Duplicate-emit removed (#1603 audit, step 1): the canonical
+        // endCurrentTurnAtomic(turn) call at line ~5851 below already
+        // invokes purgeReactionTracking on the same ceKey. The bare
+        // call here was firing a second shadow `turnEnd` per traversal.
         // Surfaced during CC-5 investigation (`docs/status-ask-cause-classes.md`):
         // the context-exhaust bail path teardown was missing
         // `silencePoke.endTurn(key)`. Without it, the silence-poke state for
@@ -5986,7 +6043,10 @@ function handleSessionEvent(ev: SessionEvent): void {
         // Fall through to normal state cleanup (ctrl.setDone, purge, etc.)
         // but skip the regular closeProgressLane so we don't re-finalize.
         if (ctrl) ctrl.setDone()
-        purgeReactionTracking(statusKey(chatId, threadId))
+        // Duplicate-emit removed (#1603 audit, step 1): endCurrentTurnAtomic(turn)
+        // at line ~6049 below invokes purgeReactionTracking on the same key
+        // (statusKey(chatId, threadId)). The bare call here was firing a
+        // second shadow `turnEnd` per silent-marker traversal.
         // Match the normal turn_end path's telemetry so silent-marker turns
         // still appear in turn-duration graphs.
         {
@@ -6127,7 +6187,15 @@ function handleSessionEvent(ev: SessionEvent): void {
                 // mirroring this contract — so reply-only turns transition
                 // to terminal 👍 in their own success path rather than
                 // relying on this dedup heuristic.
-                purgeReactionTracking(statusKey(backstopChatId, backstopThreadId))
+                //
+                // PR 3b step 3 (#1603 audit): thread the captured `turn`
+                // explicitly. `endCurrentTurnAtomic(turn)` ran at line ~6120
+                // before this IIFE started, so `currentTurn === null` by
+                // now — without an explicit endingTurn argument, the shadow
+                // trace would read `outboundEmitted=false` for this dedup
+                // path even though `recentCount > 0` proves the reply tool
+                // did fire (turn.replyCalled === true).
+                purgeReactionTracking(statusKey(backstopChatId, backstopThreadId), turn)
                 return
               }
             } catch {}
@@ -6255,14 +6323,35 @@ function handleSessionEvent(ev: SessionEvent): void {
             process.stderr.write(`telegram gateway: turn-flush send failed: ${(err as Error).message}\n`)
             if (backstopCtrl) backstopCtrl.setError()
           } finally {
-            purgeReactionTracking(statusKey(backstopChatId, backstopThreadId))
+            // PR 3b step 3 (#1603 audit): thread the captured `turn`
+            // explicitly. The turn-flush backstop runs inside this IIFE
+            // after `endCurrentTurnAtomic(turn)` already nulled
+            // `currentTurn` at line ~6120. Without threading, the shadow
+            // trace would read `outboundEmitted=currentTurn?.replyCalled
+            // === undefined` → false. For the turn-flush path
+            // `turn.replyCalled` is `false` regardless (the model didn't
+            // call the reply tool — the gateway backstop did the work),
+            // so the threaded value matches the existing fallback here.
+            // But pinning the source via the captured turn matches the
+            // canonical pattern and survives any future change to how
+            // `currentTurn` is sequenced.
+            purgeReactionTracking(statusKey(backstopChatId, backstopThreadId), turn)
           }
         })()
         return
       }
 
       if (ctrl) ctrl.setDone()
-      purgeReactionTracking(statusKey(chatId, threadId))
+      // Duplicate-emit removed (#1603 audit, step 4 — the audit's
+      // original "route through endCurrentTurnAtomic" recommendation
+      // missed that this same code path already calls
+      // `endCurrentTurnAtomic(turn)` ~90 lines below at line ~6412
+      // on the same key — `chatId === turn.sessionChatId` and
+      // `threadId === turn.sessionThreadId` per the bindings at
+      // ~5946-5947. Removing this bare call closes the last duplicate
+      // shadow-`turnEnd` emit on the dominant happy-path turn-end
+      // tail; the canonical primitive below still fires the single
+      // authoritative turnEnd with the threaded turn).
       {
         const sKey = streamKey(chatId, threadId)
         const turnDurationMs = turn.startedAt > 0 ? Date.now() - turn.startedAt : 0

package/telegram-plugin/tests/draft-stream.test.ts

@@ -1202,4 +1202,83 @@ describe('createDraftStream — draft transport', () => {
     })
   })
 
+  // ─── Follow-up: stream-end `sends` counter includes finalize-materialize ───
+  describe('finalize-materialize bumps sends counter', () => {
+    let captured: string[] = []
+    let originalWrite: typeof process.stderr.write
+
+    beforeEach(() => {
+      captured = []
+      originalWrite = process.stderr.write
+      process.stderr.write = ((chunk: string | Uint8Array) => {
+        const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8')
+        captured.push(text)
+        return true
+      }) as typeof process.stderr.write
+    })
+    afterEach(() => {
+      process.stderr.write = originalWrite
+    })
+
+    it('draft-transport stream that materializes on finalize shows sends>=1', async () => {
+      // Pre-fix this showed sends=0 even though sendMessage fired
+      // inside finalize. Bug was visible in production v0.13.0 traces.
+      const m = makeMock()
+      const sendMessageDraft = vi.fn(async () => {})
+      const stream = createDraftStream(m.send, m.edit, {
+        throttleMs: 50,
+        previewTransport: 'draft',
+        sendMessageDraft,
+        chatId: 'chat-x',
+      })
+      void stream.update('Hello world')
+      await microtaskFlush()
+      vi.advanceTimersByTime(100)
+      await microtaskFlush()
+      await stream.finalize()
+      // Real send() called inside finalize.
+      expect(m.sendCalls.length).toBe(1)
+      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
+      expect(endLine).toBeDefined()
+      // Counter now reflects reality.
+      expect(endLine).toMatch(/sends=[1-9]/)
+    })
+
+    it('persist-chain bump counts toward sends (size-trigger fires + finalize)', async () => {
+      // The sibling bug at the persist-chain callsite — its bare
+      // send(chunk) also bypasses sendViaMessage. Without the fix
+      // a stream that crosses the size boundary would show sends=1
+      // (only the finalize materialize), missing the chain fire.
+      // With the fix sends counts BOTH the persist send AND the
+      // finalize materialize → sends>=2.
+      const m = makeMock()
+      const sendMessageDraft = vi.fn(async () => {})
+      const stream = createDraftStream(m.send, m.edit, {
+        throttleMs: 50,
+        previewTransport: 'draft',
+        sendMessageDraft,
+        chatId: 'chat-chain',
+        persistSizeLimit: 200,
+      })
+      void stream.update('a'.repeat(100))
+      await microtaskFlush()
+      vi.advanceTimersByTime(300)
+      void stream.update('a'.repeat(250)) // size trigger fires (tail=250 ≥ 200)
+      await microtaskFlush()
+      vi.advanceTimersByTime(300)
+      await microtaskFlush()
+      // Extra text after persist so finalize-materialize tail is non-empty.
+      void stream.update('a'.repeat(250) + 'b'.repeat(50))
+      await microtaskFlush()
+      vi.advanceTimersByTime(300)
+      await microtaskFlush()
+      await stream.finalize()
+      const endLine = captured.find((c) => c.includes('gw-trace stream-end'))
+      expect(endLine).toBeDefined()
+      // Persist send + finalize materialize = at least 2.
+      expect(endLine).toMatch(/sends=[2-9]/)
+      expect(endLine).toMatch(/persists=[1-9]/)
+    })
+  })
+
 })