switchroom 0.14.28 → 0.14.30

package/dist/cli/switchroom.js

@@ -49420,8 +49420,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.28";
-var COMMIT_SHA = "cb64351f";
+var VERSION = "0.14.30";
+var COMMIT_SHA = "84f50bd2";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.14.28",
+  "version": "0.14.30",
   "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/bridge/bridge.js

@@ -23349,6 +23349,10 @@ function projectSubagentLine(line, agentId, state) {
         events.push({ kind: "sub_agent_text", agentId, text });
       }
     }
+    const stopReason = message?.stop_reason;
+    if (stopReason === "end_turn") {
+      events.push({ kind: "sub_agent_turn_end", agentId });
+    }
     return events;
   }
   if (type === "system" && obj.subtype === "turn_duration") {

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

@@ -38932,7 +38932,7 @@ var EDIT_INTERVAL_MS = 60000;
 var POLL_INTERVAL_MS = 5000;
 var MAX_LIFETIME_MS = 30 * 60000;
 var TELEGRAM_MSG_CAP2 = 4000;
-var SUFFIX_RE = /\n\n\u2014 still working \(\d+m\)$/;
+var SUFFIX_RE = /\n\n\u2014 still working \(\d+m\)( \u00b7 message me anytime, I'll keep you posted)?$/;
 var stateByKey = new Map;
 var timer2 = null;
 var activeDeps2 = null;
@@ -39044,7 +39044,7 @@ function tick2(now) {
     const minutes = Math.max(1, Math.round(elapsed / 60000));
     const suffix = `
 
-\u2014 still working (${minutes}m)`;
+\u2014 still working (${minutes}m) \u00b7 message me anytime, I'll keep you posted`;
     const newText = s.anchorOriginalText + suffix;
     if (newText.length > TELEGRAM_MSG_CAP2) {
       s.lastEditAt = now;
@@ -49160,6 +49160,10 @@ function projectSubagentLine(line, agentId, state4) {
         events.push({ kind: "sub_agent_text", agentId, text });
       }
     }
+    const stopReason = message?.stop_reason;
+    if (stopReason === "end_turn") {
+      events.push({ kind: "sub_agent_turn_end", agentId });
+    }
     return events;
   }
   if (type === "system" && obj.subtype === "turn_duration") {
@@ -49297,6 +49301,10 @@ function redactSecrets(text) {
   return out;
 }
 // registry/subagents-schema.ts
+function countRunningBackgroundSubagents(db2) {
+  const row = db2.prepare("SELECT count(*) AS n FROM subagents WHERE background = 1 AND status = 'running'").get();
+  return row?.n ?? 0;
+}
 function recordSubagentEnd(db2, args) {
   db2.prepare(`
     UPDATE subagents
@@ -50006,6 +50014,15 @@ function startSubagentWatcher(config) {
     },
     getRegistry() {
       return registry;
+    },
+    countRunningBackgroundWorkers() {
+      if (db2 == null)
+        return null;
+      try {
+        return countRunningBackgroundSubagents(db2);
+      } catch {
+        return null;
+      }
     }
   };
 }
@@ -51642,10 +51659,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.28";
-var COMMIT_SHA = "cb64351f";
-var COMMIT_DATE = "2026-06-01T04:23:25Z";
-var LATEST_PR = 2049;
+var VERSION = "0.14.30";
+var COMMIT_SHA = "84f50bd2";
+var COMMIT_DATE = "2026-06-01T06:07:00Z";
+var LATEST_PR = 2058;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -53063,6 +53080,9 @@ function finalizeStatusReaction(chatId, threadId, reason = "done") {
   purgeReactionTracking(key);
 }
 function countRunningWorkers() {
+  const dbCount = subagentWatcher?.countRunningBackgroundWorkers?.();
+  if (dbCount != null)
+    return dbCount;
   const reg = subagentWatcher?.getRegistry();
   if (reg == null)
     return 0;

package/telegram-plugin/dist/server.js

@@ -17387,6 +17387,10 @@ function projectSubagentLine(line, agentId, state) {
         events.push({ kind: "sub_agent_text", agentId, text });
       }
     }
+    const stopReason = message?.stop_reason;
+    if (stopReason === "end_turn") {
+      events.push({ kind: "sub_agent_turn_end", agentId });
+    }
     return events;
   }
   if (type === "system" && obj.subtype === "turn_duration") {

package/telegram-plugin/gateway/gateway.ts

@@ -2119,6 +2119,13 @@ function finalizeStatusReaction(
  * fired its `done`/`failed` onFinish no longer counts here.
  */
 function countRunningWorkers(): number {
+  // Prefer the dispatch-time DB count: a background worker's row is INSERTed
+  // `status='running'` when its `Agent` tool_use fires, i.e. BEFORE the parent
+  // turn ends. The registry below is populated by on-disk file discovery, which
+  // lags dispatch by a poll/fswatch tick — so a just-dispatched worker was
+  // invisible to the deferred-done gate and the 👍 promoted prematurely.
+  const dbCount = subagentWatcher?.countRunningBackgroundWorkers?.()
+  if (dbCount != null) return dbCount
   const reg = subagentWatcher?.getRegistry()
   if (reg == null) return 0
   let n = 0

package/telegram-plugin/pending-work-progress.ts

@@ -35,7 +35,11 @@
  *   turn_end with pending+anchor → activate the timer for the key
  *   tick (every 5s, edit every  → editMessageText against the anchor
  *     EDIT_INTERVAL_MS)            appending/refreshing the suffix
- *                                  " — still working (Nm)"
+ *                                  " — still working (Nm) · message me
+ *                                  anytime, I'll keep you posted"
+ *                                  (the reachability clause signals the
+ *                                  agent is still listening while a
+ *                                  background worker runs — issue PR3)
  *   inbound user message        → clear (user re-engaged or moved on)
  *   subagent_handback inject    → clear (model about to re-engage)
  *   MAX_LIFETIME_MS budget cap  → clear (give up; 30 min default)
@@ -70,10 +74,13 @@ export const TELEGRAM_MSG_CAP = 4000
 /**
  * Regex matching the suffix we append. Used to strip a prior suffix
  * before appending the next one. The (\d+) covers "1m" / "12m" / etc.
+ * The reachability clause is optional so anchors carrying a pre-v0.14.30
+ * suffix (no clause) are still stripped during a rolling upgrade.
  * Kept anchored to end-of-string so it only matches OUR suffix, not
  * something the model happened to write.
  */
-const SUFFIX_RE = /\n\n— still working \(\d+m\)$/
+const SUFFIX_RE =
+  /\n\n— still working \(\d+m\)( · message me anytime, I'll keep you posted)?$/
 
 export interface PendingProgressEditCtx {
   chatId: string
@@ -380,7 +387,7 @@ function tick(now: number): void {
     // user-visible counter reads honestly (we only edit at intervals
     // ≥ EDIT_INTERVAL_MS = 60s).
     const minutes = Math.max(1, Math.round(elapsed / 60_000))
-    const suffix = `\n\n— still working (${minutes}m)`
+    const suffix = `\n\n— still working (${minutes}m) · message me anytime, I'll keep you posted`
     const newText = s.anchorOriginalText + suffix
 
     if (newText.length > TELEGRAM_MSG_CAP) {

package/telegram-plugin/registry/subagents-schema.ts

@@ -360,6 +360,41 @@ export function getSubagentByJsonlId(db: SqliteDatabase, jsonlAgentId: string):
   return row ? mapSubagentRow(row) : null
 }
 
+/**
+ * Count background subagents that have not yet reached a terminal state.
+ *
+ * This is the dispatch-time source of truth for "is a background worker still
+ * running" — the row is INSERTed with `status='running'` by `recordSubagentStart`
+ * the moment the parent's `Agent` tool_use fires (keyed on the `toolu_…` id),
+ * which is BEFORE the parent's turn ends. The deferred-done-reaction gate reads
+ * this so it holds the 👍 the instant a worker is dispatched, rather than
+ * snapshotting the file-discovery registry (which lags dispatch by a poll/fswatch
+ * tick and so missed just-dispatched workers — the premature-👍 race).
+ *
+ * Counts `running` ONLY — `stalled` is deliberately excluded. `stalled` is NOT
+ * a terminal status: the reaper (`reapStuckRunningRows`) transitions a row to
+ * `stalled`, never to `completed`/`failed`. A genuinely-orphaned background row
+ * — one INSERTed at dispatch whose JSONL was never linked, so no activity ever
+ * bumped it and the in-memory silent-stall synthesis never terminalised it —
+ * sits in `stalled` indefinitely (the 1h reaper TTL is the only thing that
+ * moves it off `running`). Counting `stalled` would wedge the deferred 👍 above
+ * zero forever for that row (`reaction-defer.ts` `promote()` bails while the
+ * count is > 0). A live-but-quiet worker, by contrast, is driven to `completed`
+ * by the watcher's terminal paths (end_turn signal OR silent-stall synthesis,
+ * both call `recordSubagentEnd`) long before the 1h reaper, and a stalled row
+ * that genuinely resumes is flipped back to `running` by `recordSubagentResume`
+ * — so excluding `stalled` never releases the 👍 on a worker that's merely
+ * paused rather than dead.
+ */
+export function countRunningBackgroundSubagents(db: SqliteDatabase): number {
+  const row = db
+    .prepare(
+      "SELECT count(*) AS n FROM subagents WHERE background = 1 AND status = 'running'",
+    )
+    .get() as { n: number } | undefined
+  return row?.n ?? 0
+}
+
 /**
  * Record that a subagent has reached a terminal state (completed or failed).
  * Sets `ended_at`, `status`, and optionally `result_summary`.

package/telegram-plugin/registry/subagents.test.ts

@@ -28,6 +28,7 @@ import {
   bumpSubagentActivity,
   getSubagent,
   reapStuckRunningRows,
+  countRunningBackgroundSubagents,
 } from './subagents-schema.js'
 
 // ---------------------------------------------------------------------------
@@ -182,6 +183,83 @@ describe('recordSubagentStart + recordSubagentEnd happy path', () => {
   })
 })
 
+// ---------------------------------------------------------------------------
+// countRunningBackgroundSubagents — the dispatch-time gate for the
+// deferred-done 👍 reaction. A row counts as "still running" the instant
+// recordSubagentStart inserts it (status='running'), closing the
+// file-discovery registration race that promoted the 👍 prematurely.
+// ---------------------------------------------------------------------------
+
+describe('countRunningBackgroundSubagents', () => {
+  it('counts a background worker the moment it starts (before any terminal)', () => {
+    const db = openFreshSubagentsDbInMemory()
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    recordSubagentStart(db, { id: 'bg-1', background: true, startedAt: 1000 })
+    expect(countRunningBackgroundSubagents(db)).toBe(1)
+    db.close()
+  })
+
+  it('does NOT count a stalled worker — stalled is the reaper sink, never terminalised', () => {
+    // A `stalled` row is NOT terminal and is NOT actively running. The only
+    // way a background row reaches `stalled` is the 1h reaper firing on a row
+    // that never linked a JSONL (no activity bumps, no silent-stall synthesis
+    // to drive it to `completed`) — i.e. an orphaned/dead dispatch. Counting it
+    // would wedge the deferred 👍 above zero forever (promote() bails while the
+    // count is > 0). A live-but-quiet worker terminalises to `completed` long
+    // before the reaper, so `stalled` always means "dead" here.
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'bg-2', background: true, startedAt: 1000 })
+    recordSubagentStall(db, { id: 'bg-2', stalledAt: 1500 })
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    db.close()
+  })
+
+  it('a row reaped to stalled does not keep the gate above zero (permanent-👍-hold regression guard)', () => {
+    // Regression guard for the orphaned-dispatch wedge: dispatch inserts a
+    // `running` row, the JSONL never links, and the reaper transitions it to
+    // `stalled`. The deferred-👍 gate must read zero so promote() can fire —
+    // counting the reaped row would hold the 👍 forever.
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'bg-orphan', background: true, startedAt: 1000 })
+    expect(countRunningBackgroundSubagents(db)).toBe(1)
+    const result = reapStuckRunningRows(db, { ttlMs: 500, now: 5000 })
+    expect(result.reaped).toBe(1)
+    expect(getSubagent(db, 'bg-orphan')!.status).toBe('stalled')
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    db.close()
+  })
+
+  it('re-counts a stalled worker that resumes — recordSubagentResume flips it back to running', () => {
+    // A worker that's merely paused (not dead) and resumes JSONL activity is
+    // flipped stalled → running by recordSubagentResume, so the gate holds the
+    // 👍 again. Excluding `stalled` from the count never releases the 👍 on a
+    // worker that's only paused.
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'bg-resume', background: true, startedAt: 1000 })
+    recordSubagentStall(db, { id: 'bg-resume', stalledAt: 1500 })
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    recordSubagentResume(db, { id: 'bg-resume', resumedAt: 2000 })
+    expect(countRunningBackgroundSubagents(db)).toBe(1)
+    db.close()
+  })
+
+  it('drops to zero once the worker reaches a terminal status', () => {
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'bg-3', background: true, startedAt: 1000 })
+    expect(countRunningBackgroundSubagents(db)).toBe(1)
+    recordSubagentEnd(db, { id: 'bg-3', endedAt: 2000, status: 'completed' })
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    db.close()
+  })
+
+  it('ignores foreground subagents — only background workers gate the reaction', () => {
+    const db = openFreshSubagentsDbInMemory()
+    recordSubagentStart(db, { id: 'fg-1', background: false, startedAt: 1000 })
+    expect(countRunningBackgroundSubagents(db)).toBe(0)
+    db.close()
+  })
+})
+
 // ---------------------------------------------------------------------------
 // Test 4 — start → stall → end
 // ---------------------------------------------------------------------------

package/telegram-plugin/session-tail.ts

@@ -390,6 +390,21 @@ export function projectSubagentLine(
         events.push({ kind: 'sub_agent_text', agentId, text })
       }
     }
+    // Authoritative early terminal: a background `Agent` worker's JSONL on
+    // claude ≥2.1.156 never writes the `system/turn_duration` line below, so
+    // the watcher used to only learn the worker finished via the ~5-min
+    // silent-stall synthesis net — leaving the card stuck "running" and the
+    // deferred 👍 held for minutes after the work was actually done. The
+    // worker DOES write a final assistant message with
+    // `stop_reason: 'end_turn'` (a tool-using turn is `'tool_use'` and keeps
+    // going), so treat that as the terminal signal. Emitted AFTER the content
+    // events so the final text/preamble still renders; the watcher's turn_end
+    // handler is guarded on `state === 'running'`, so a later real
+    // turn_duration line is a no-op.
+    const stopReason = message?.stop_reason as string | undefined
+    if (stopReason === 'end_turn') {
+      events.push({ kind: 'sub_agent_turn_end', agentId })
+    }
     return events
   }
 

package/telegram-plugin/subagent-watcher.ts

@@ -43,7 +43,7 @@ import { homedir } from 'os'
 import { projectSubagentLine, sanitizeCwdToProjectName, detectErrorInTranscriptLine } from './session-tail.js'
 import { sanitiseToolArg } from './fleet-state.js'
 import { escapeHtml, truncate } from './card-format.js'
-import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows } from './registry/subagents-schema.js'
+import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows, countRunningBackgroundSubagents } from './registry/subagents-schema.js'
 import { touchTurnActiveMarker } from './gateway/turn-active-marker.js'
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -377,6 +377,13 @@ export interface SubagentWatcherHandle {
   stop(): void
   /** Snapshot of current registry for tests/inspection. */
   getRegistry(): ReadonlyMap<string, WorkerEntry>
+  /**
+   * Count background workers still in flight, read from the dispatch-time DB
+   * (not the file-discovery registry). Returns null when no DB is wired so the
+   * caller can fall back to the registry snapshot. Drives the deferred-done
+   * reaction gate — see `countRunningBackgroundSubagents`.
+   */
+  countRunningBackgroundWorkers(): number | null
 }
 
 // ─── Constants ───────────────────────────────────────────────────────────────
@@ -1498,5 +1505,16 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     getRegistry(): ReadonlyMap<string, WorkerEntry> {
       return registry
     },
+
+    countRunningBackgroundWorkers(): number | null {
+      if (db == null) return null
+      try {
+        return countRunningBackgroundSubagents(db)
+      } catch {
+        // A torn/locked DB read must not wedge the reaction gate — fall back
+        // to the registry snapshot by returning null.
+        return null
+      }
+    },
   }
 }

package/telegram-plugin/tests/pending-work-progress.test.ts

@@ -139,7 +139,7 @@ describe('pending-work-progress', () => {
     expect(cap.edits).toHaveLength(1)
     expect(cap.edits[0].messageId).toBe(100)
     expect(cap.edits[0].newText).toBe(
-      'Background sleep running; awaiting completion.\n\n— still working (1m)',
+      "Background sleep running; awaiting completion.\n\n— still working (1m) · message me anytime, I'll keep you posted",
     )
 
     // Tick at 3 intervals total — second edit, "3m".
@@ -148,7 +148,7 @@ describe('pending-work-progress', () => {
     await flush()
     expect(cap.edits).toHaveLength(2)
     expect(cap.edits[1].newText).toBe(
-      'Background sleep running; awaiting completion.\n\n— still working (3m)',
+      "Background sleep running; awaiting completion.\n\n— still working (3m) · message me anytime, I'll keep you posted",
     )
   })
 
@@ -168,7 +168,25 @@ describe('pending-work-progress', () => {
     await flush()
     // The new edit should be based on 'worker dispatched' alone.
     expect(cap.edits[0].newText).toBe(
-      'worker dispatched\n\n— still working (1m)',
+      "worker dispatched\n\n— still working (1m) · message me anytime, I'll keep you posted",
+    )
+  })
+
+  it('strips a prior NEW-shape suffix (with reachability clause) too', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, {
+      messageId: 100,
+      text:
+        "worker dispatched\n\n— still working (12m) · message me anytime, I'll keep you posted",
+    })
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits[0].newText).toBe(
+      "worker dispatched\n\n— still working (1m) · message me anytime, I'll keep you posted",
     )
   })
 
@@ -338,7 +356,7 @@ describe('pending-work-progress', () => {
     expect(cap.edits).toHaveLength(1)
     expect(cap.edits[0].parseMode).toBe('HTML')
     expect(cap.edits[0].newText).toBe(
-      '<b>Worker back.</b> Both blockers fixed.\n\n— still working (1m)',
+      "<b>Worker back.</b> Both blockers fixed.\n\n— still working (1m) · message me anytime, I'll keep you posted",
     )
   })
 

package/telegram-plugin/tests/session-tail.test.ts

@@ -492,6 +492,49 @@ describe('projectSubagentLine', () => {
     expect(events).toEqual([{ kind: 'sub_agent_turn_end', agentId: 'X' }])
   })
 
+  it('emits sub_agent_turn_end after the text when the final assistant message stop_reason is end_turn', () => {
+    // Background `Agent` workers (claude ≥2.1.156) never write the
+    // system/turn_duration line, only a final assistant message with
+    // stop_reason 'end_turn'. That IS the authoritative completion signal —
+    // without treating it as terminal the card hung "running" until the
+    // ~5-min stall-synthesis net fired (the screenshot bug).
+    const st = { hasEmittedStart: true }
+    const events = projectSubagentLine(
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          stop_reason: 'end_turn',
+          content: [{ type: 'text', text: 'Done. Fixed the bug.' }],
+        },
+      }),
+      'X',
+      st,
+    )
+    // Text first (so the final summary still renders), turn_end last.
+    expect(events).toEqual([
+      { kind: 'sub_agent_text', agentId: 'X', text: 'Done. Fixed the bug.' },
+      { kind: 'sub_agent_turn_end', agentId: 'X' },
+    ])
+  })
+
+  it('does NOT emit sub_agent_turn_end for a tool-using assistant message (stop_reason tool_use)', () => {
+    // A mid-run assistant message that calls a tool has stop_reason 'tool_use'
+    // and keeps going — it must not be mistaken for completion.
+    const st = { hasEmittedStart: true }
+    const events = projectSubagentLine(
+      JSON.stringify({
+        type: 'assistant',
+        message: {
+          stop_reason: 'tool_use',
+          content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+        },
+      }),
+      'X',
+      st,
+    )
+    expect(events.some((e) => e.kind === 'sub_agent_turn_end')).toBe(false)
+  })
+
   it('skips malformed lines silently', () => {
     const st = { hasEmittedStart: false }
     expect(projectSubagentLine('{not-json', 'X', st)).toEqual([])

package/telegram-plugin/uat/scenarios/cross-turn-pending-progress-dm.test.ts

@@ -81,7 +81,8 @@ interface TrailEntry {
   text: string;
 }
 
-const SUFFIX_RE = /\n\n— still working \(\d+m\)$/;
+const SUFFIX_RE =
+  /\n\n— still working \(\d+m\)( · message me anytime, I'll keep you posted)?$/;
 
 function pad(s: string, n: number): string {
   return s.length >= n ? s : s + " ".repeat(n - s.length);

package/telegram-plugin/uat/scenarios/jtbd-pending-progress-html-dm.test.ts

@@ -40,7 +40,8 @@ const PROMPT =
   `the bash, send that one HTML reply, end your turn. When it finishes ` +
   `much later, reply with the single word "done".`;
 
-const SUFFIX_RE = /\n\n— still working \(\d+m\)$/;
+const SUFFIX_RE =
+  /\n\n— still working \(\d+m\)( · message me anytime, I'll keep you posted)?$/;
 
 describe("uat: pending-progress edit preserves HTML formatting (#1698 regression gate)", () => {
   it(