switchroom 0.14.28 → 0.14.29

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.29";
+var COMMIT_SHA = "33f6300c";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

@@ -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.29";
+var COMMIT_SHA = "33f6300c";
+var COMMIT_DATE = "2026-06-01T04:54:34Z";
+var LATEST_PR = 2052;
 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/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/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([])