switchroom 0.12.15 → 0.12.16

package/dist/cli/switchroom.js

@@ -47242,8 +47242,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.12.15";
-var COMMIT_SHA = "dc508a92";
+var VERSION = "0.12.16";
+var COMMIT_SHA = "b30ce83a";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

@@ -43366,6 +43366,15 @@ function redeliverBufferedInbound(buffer, agent, send) {
   }
   return { drained: pending.length, redelivered, rebuffered };
 }
+function idleDrainTick(buffer, agent, isBridgeAlive, send) {
+  if (!agent)
+    return null;
+  if (buffer.depth(agent) === 0)
+    return null;
+  if (!isBridgeAlive())
+    return null;
+  return redeliverBufferedInbound(buffer, agent, send);
+}
 function createPendingInboundBuffer(opts = {}) {
   const cap = opts.capPerAgent ?? DEFAULT_PENDING_INBOUND_CAP;
   const log = opts.log ?? ((line) => process.stderr.write(line));
@@ -46768,11 +46777,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.12.15";
-var COMMIT_SHA = "dc508a92";
-var COMMIT_DATE = "2026-05-19T07:24:41Z";
-var LATEST_PR = 1547;
-var COMMITS_AHEAD_OF_TAG = 22;
+var VERSION = "0.12.16";
+var COMMIT_SHA = "b30ce83a";
+var COMMIT_DATE = "2026-05-19T08:46:47Z";
+var LATEST_PR = 1550;
+var COMMITS_AHEAD_OF_TAG = 25;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -48777,6 +48786,20 @@ ${reminder}
   log: (msg) => process.stderr.write(`telegram gateway: ipc \u2014 ${msg}
 `)
 });
+var IDLE_DRAIN_INTERVAL_MS = 5000;
+if (!STATIC) {
+  setInterval(() => {
+    const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? "";
+    const r = idleDrainTick(pendingInboundBuffer, selfAgent, () => {
+      const c = ipcServer.getClient(selfAgent);
+      return c != null && c.isAlive();
+    }, (m) => ipcServer.sendToAgent(selfAgent, m));
+    if (r != null && r.redelivered > 0) {
+      process.stderr.write(`telegram gateway: idle-drain flushed ${r.redelivered}/${r.drained} buffered inbound for ${selfAgent}${r.rebuffered > 0 ? ` (${r.rebuffered} re-buffered)` : ""}
+`);
+    }
+  }, IDLE_DRAIN_INTERVAL_MS).unref();
+}
 var ALLOWED_TOOLS = new Set([
   "reply",
   "stream_reply",

package/telegram-plugin/gateway/gateway.ts

@@ -245,7 +245,7 @@ import { shouldSweepChatAtBoot } from './boot-sweep-filter.js'
 import { createIpcServer, type IpcClient, type IpcServer } from './ipc-server.js'
 import { handleRequestDriveApproval } from './drive-write-approval.js'
 import { buildDiffPreviewCard } from './diff-preview-card.js'
-import { createPendingInboundBuffer, redeliverBufferedInbound } from './pending-inbound-buffer.js'
+import { createPendingInboundBuffer, redeliverBufferedInbound, idleDrainTick } from './pending-inbound-buffer.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
 import {
   buildVaultGrantApprovedInbound,
@@ -3272,6 +3272,48 @@ const ipcServer: IpcServer = createIpcServer({
   log: (msg) => process.stderr.write(`telegram gateway: ipc — ${msg}\n`),
 })
 
+// ─── Opportunistic idle-drain of pendingInboundBuffer ─────────────────────
+// pendingInboundBuffer otherwise drains only on (a) bridge re-register
+// (onClientRegistered) or (b) the silence-poke framework fallback
+// clearing a wedged turn (#1546). NEITHER fires when a message is
+// buffered during a bridge-IPC flap that then settles with no
+// subsequent clean re-register AND claude is idle (no active turn →
+// silence-poke never arms). The message orphans until a manual restart
+// (finn, 2026-05-19 — buffered "verify with mff-query.py cashflow"
+// while idle; last `bridge registered` predated the buffer push, so
+// onClientRegistered's drain never ran for it).
+//
+// This is the third drain trigger. It's gated to be zero-cost and
+// zero-churn: skip entirely when nothing is buffered (one Map.get, no
+// log) or when the bridge isn't alive (exactly sendToAgent's own
+// guard — so we never drain into a dead bridge and re-buffer/log-spin).
+// Only when there IS a buffered message AND a live bridge do we reuse
+// the #1546 `redeliverBufferedInbound` (lossless: re-buffers any
+// per-message miss). A message delivered while a turn is active is
+// queued normally by the bridge — same as a live arrival, not lost.
+const IDLE_DRAIN_INTERVAL_MS = 5000
+if (!STATIC) {
+  setInterval(() => {
+    const selfAgent = process.env.SWITCHROOM_AGENT_NAME ?? ''
+    const r = idleDrainTick(
+      pendingInboundBuffer,
+      selfAgent,
+      () => {
+        const c = ipcServer.getClient(selfAgent)
+        return c != null && c.isAlive()
+      },
+      (m) => ipcServer.sendToAgent(selfAgent, m),
+    )
+    if (r != null && r.redelivered > 0) {
+      process.stderr.write(
+        `telegram gateway: idle-drain flushed ${r.redelivered}/${r.drained} ` +
+        `buffered inbound for ${selfAgent}` +
+        `${r.rebuffered > 0 ? ` (${r.rebuffered} re-buffered)` : ''}\n`,
+      )
+    }
+  }, IDLE_DRAIN_INTERVAL_MS).unref()
+}
+
 // ─── Tool execution ──────────────────────────────────────────────────────
 
 /** Allowlisted tool names that bridges may invoke via IPC. Prevents a rogue

package/telegram-plugin/gateway/pending-inbound-buffer.ts

@@ -93,6 +93,38 @@ export function redeliverBufferedInbound(
   return { drained: pending.length, redelivered, rebuffered }
 }
 
+/**
+ * One opportunistic idle-drain tick. The third drain trigger, beside
+ * `onClientRegistered` (bridge re-register) and the silence-poke
+ * wedge-clear (#1546). Closes the orphan gap those two miss: a message
+ * buffered during a bridge-IPC flap that settles with no subsequent
+ * clean re-register while claude is idle (no turn → no silence-poke)
+ * — it would otherwise sit until a manual restart (finn, 2026-05-19).
+ *
+ * Gated to be zero-cost / zero-churn so it can run on a short timer:
+ *   - empty buffer → return null (one Map.get, NO drain, NO log)
+ *   - bridge not alive → return null (never drain into a dead bridge,
+ *     which would re-buffer+log-spin every tick; onClientRegistered
+ *     will drain on the eventual reconnect instead)
+ *   - otherwise → `redeliverBufferedInbound` (lossless: re-buffers any
+ *     per-message miss). A message delivered mid-turn is queued
+ *     normally by the bridge, same as a live arrival — not lost.
+ *
+ * Returns the redeliver counts only when it actually ran, else null
+ * (so the caller logs only on a real flush).
+ */
+export function idleDrainTick(
+  buffer: PendingInboundBuffer,
+  agent: string,
+  isBridgeAlive: () => boolean,
+  send: (msg: InboundMessage) => boolean,
+): { drained: number; redelivered: number; rebuffered: number } | null {
+  if (!agent) return null
+  if (buffer.depth(agent) === 0) return null
+  if (!isBridgeAlive()) return null
+  return redeliverBufferedInbound(buffer, agent, send)
+}
+
 export function createPendingInboundBuffer(
   opts: PendingInboundBufferOptions = {},
 ): PendingInboundBuffer {

package/telegram-plugin/tests/pending-inbound-buffer.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
-import { createPendingInboundBuffer, redeliverBufferedInbound, DEFAULT_PENDING_INBOUND_CAP } from '../gateway/pending-inbound-buffer.js'
+import { createPendingInboundBuffer, redeliverBufferedInbound, idleDrainTick, DEFAULT_PENDING_INBOUND_CAP } from '../gateway/pending-inbound-buffer.js'
 import type { InboundMessage } from '../gateway/ipc-protocol.js'
 
 function inbound(source: string, ts = Date.now()): InboundMessage {
@@ -200,3 +200,50 @@ describe('redeliverBufferedInbound — wedge-clear self-heal (fleet-update incid
     expect(buf.depth('clerk')).toBe(1) // untouched
   })
 })
+
+describe('idleDrainTick — the 3rd drain trigger (finn orphan gap, 2026-05-19)', () => {
+  it('no-op (returns null, no send) when the buffer is empty', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    let sent = 0
+    const r = idleDrainTick(buf, 'finn', () => true, () => { sent++; return true })
+    expect(r).toBeNull()
+    expect(sent).toBe(0)
+  })
+
+  it('no-op (returns null) when bridge is NOT alive — never drains into a dead bridge', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    buf.push('finn', inbound('user', 1))
+    let sent = 0
+    const r = idleDrainTick(buf, 'finn', () => false, () => { sent++; return true })
+    expect(r).toBeNull()
+    expect(sent).toBe(0)
+    expect(buf.depth('finn')).toBe(1) // untouched — onClientRegistered will get it on reconnect
+  })
+
+  it('flushes the buffer when bridge is alive AND something is buffered (the finn fix)', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    buf.push('finn', inbound('user', 2013)) // the orphaned "verify with mff-query.py" class
+    const seen: number[] = []
+    const r = idleDrainTick(buf, 'finn', () => true, (m) => { seen.push(m.messageId as number); return true })
+    expect(r).toEqual({ drained: 1, redelivered: 1, rebuffered: 0 })
+    expect(seen).toEqual([2013])
+    expect(buf.depth('finn')).toBe(0)
+  })
+
+  it('is lossless — a delivery miss re-buffers, returns null on empty agent', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    buf.push('finn', inbound('user', 1))
+    const r = idleDrainTick(buf, 'finn', () => true, () => false)
+    expect(r).toEqual({ drained: 1, redelivered: 0, rebuffered: 1 })
+    expect(buf.depth('finn')).toBe(1) // nothing lost
+    expect(idleDrainTick(buf, '', () => true, () => true)).toBeNull() // empty agent guard
+  })
+
+  it('checks depth BEFORE isBridgeAlive — empty buffer never probes the bridge', () => {
+    const buf = createPendingInboundBuffer({ log: () => {} })
+    let probed = false
+    const r = idleDrainTick(buf, 'finn', () => { probed = true; return true }, () => true)
+    expect(r).toBeNull()
+    expect(probed).toBe(false) // cheap path: Map.get only, no bridge probe, no log
+  })
+})