switchroom 0.14.15 → 0.14.17

package/dist/cli/switchroom.js

@@ -49413,8 +49413,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.14.15";
-var COMMIT_SHA = "e0f95f64";
+var VERSION = "0.14.17";
+var COMMIT_SHA = "95c1d475";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

@@ -51140,10 +51140,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.15";
-var COMMIT_SHA = "e0f95f64";
-var COMMIT_DATE = "2026-05-30T04:03:13Z";
-var LATEST_PR = 2001;
+var VERSION = "0.14.17";
+var COMMIT_SHA = "95c1d475";
+var COMMIT_DATE = "2026-05-30T05:17:47Z";
+var LATEST_PR = 2005;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -51605,6 +51605,34 @@ function applySubagentsSchema(db2) {
   }
   db2.exec("CREATE INDEX IF NOT EXISTS subagents_jsonl_id ON subagents(jsonl_agent_id)");
 }
+function mapSubagentRow(row) {
+  return {
+    id: row.id,
+    parent_session_id: row.parent_session_id,
+    parent_turn_key: row.parent_turn_key,
+    agent_type: row.agent_type,
+    description: row.description,
+    background: row.background !== 0,
+    started_at: row.started_at,
+    last_activity_at: row.last_activity_at,
+    ended_at: row.ended_at,
+    status: row.status,
+    result_summary: row.result_summary,
+    jsonl_agent_id: row.jsonl_agent_id
+  };
+}
+function getSubagentByJsonlId(db2, jsonlAgentId) {
+  const row = db2.prepare("SELECT * FROM subagents WHERE jsonl_agent_id = ?").get(jsonlAgentId);
+  return row ? mapSubagentRow(row) : null;
+}
+
+// gateway/worker-feed-dispatch.ts
+function resolveWorkerFeedDispatch(sub, watcherDescription) {
+  return {
+    isBackground: sub?.background ?? false,
+    feedDescription: (sub?.description ?? "") || watcherDescription
+  };
+}
 
 // gateway/resolve-calling-subagent.ts
 function resolveCallingSubagent(opts) {
@@ -61331,18 +61359,7 @@ var didOneTimeSetup = false;
               },
               onFinish: ({ agentId, outcome, description, resultText, toolCount, durationMs }) => {
                 deferredDoneReactions.promote();
-                if (workerFeedEnabled) {
-                  workerActivityFeed.finish(agentId, {
-                    description,
-                    lastTool: null,
-                    toolCount,
-                    latestSummary: resultText,
-                    elapsedMs: durationMs,
-                    state: outcome === "failed" ? "failed" : "done"
-                  });
-                }
                 let fleetChatId = "";
-                let isBackground = false;
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
                   for (const f of fleets) {
@@ -61352,13 +61369,23 @@ var didOneTimeSetup = false;
                     }
                   }
                 } catch {}
+                let dispatch = resolveWorkerFeedDispatch(null, description);
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb.prepare("SELECT background FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
-                    if (row != null)
-                      isBackground = row.background === 1;
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description);
                   } catch {}
                 }
+                const isBackground = dispatch.isBackground;
+                if (workerFeedEnabled) {
+                  workerActivityFeed.finish(agentId, {
+                    description: dispatch.feedDescription,
+                    lastTool: null,
+                    toolCount,
+                    latestSummary: resultText,
+                    elapsedMs: durationMs,
+                    state: outcome === "failed" ? "failed" : "done"
+                  });
+                }
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
@@ -61393,7 +61420,6 @@ var didOneTimeSetup = false;
               },
               onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
                 let fleetChatId = "";
-                let isBackground = false;
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
                   for (const f of fleets) {
@@ -61403,18 +61429,18 @@ var didOneTimeSetup = false;
                     }
                   }
                 } catch {}
+                let dispatch = resolveWorkerFeedDispatch(null, description);
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb.prepare("SELECT background FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
-                    if (row != null)
-                      isBackground = row.background === 1;
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description);
                   } catch {}
                 }
+                const isBackground = dispatch.isBackground;
                 if (!isBackground)
                   return;
                 if (workerFeedEnabled) {
                   workerActivityFeed.update(agentId, fleetChatId || (loadAccess().allowFrom[0] ?? ""), {
-                    description,
+                    description: dispatch.feedDescription,
                     lastTool,
                     toolCount,
                     latestSummary,

package/telegram-plugin/gateway/gateway.ts

@@ -418,7 +418,8 @@ import {
   findMostRecentInterruptedTurn,
   findRecentTurnsForChat,
 } from '../registry/turns-schema.js'
-import { applySubagentsSchema } from '../registry/subagents-schema.js'
+import { applySubagentsSchema, getSubagentByJsonlId } from '../registry/subagents-schema.js'
+import { resolveWorkerFeedDispatch, type WorkerFeedDispatch } from './worker-feed-dispatch.js'
 import { formatIdleFooter } from '../idle-footer.js'
 import { resolveCallingSubagent } from './resolve-calling-subagent.js'
 
@@ -17396,28 +17397,12 @@ void (async () => {
                 // handback gating below, so it must run before any early
                 // return. Cheap no-op when nothing is deferred.
                 deferredDoneReactions.promote()
-                // #PR2 live worker-feed: force the terminal recap edit on
-                // the worker's live message. No-op when no message was ever
-                // posted (trivial workers stay silent; handback covers them).
-                // 'orphan' is a stale boot row, not a fresh completion — map
-                // it to 'done' so an already-posted message still finalizes.
-                if (workerFeedEnabled) {
-                  void workerActivityFeed.finish(agentId, {
-                    description,
-                    lastTool: null,
-                    toolCount,
-                    latestSummary: resultText,
-                    elapsedMs: durationMs,
-                    state: outcome === 'failed' ? 'failed' : 'done',
-                  })
-                }
                 // IO: resolve the fleet chat id and the background flag.
                 // The DECISION (gating + inbound build) is delegated to
                 // the pure `decideSubagentHandback` so it is unit-tested
                 // independent of the gateway — see
                 // `subagent-handback-decision.test.ts`.
                 let fleetChatId = ''
-                let isBackground = false
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
                   for (const f of fleets) {
@@ -17430,14 +17415,33 @@ void (async () => {
                   // peek failures are non-fatal — fall through to the
                   // owner-chat fallback inside decideSubagentHandback.
                 }
+                // Background flag + feed header description, both derived from
+                // the registry row via the pure resolveWorkerFeedDispatch
+                // (worker-feed-dispatch.ts, pinned by its test). Best-effort:
+                // a DB hiccup keeps the watcher's generic label rather than
+                // throwing out of the terminal handler.
+                let dispatch: WorkerFeedDispatch = resolveWorkerFeedDispatch(null, description)
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb
-                      .prepare('SELECT background FROM subagents WHERE jsonl_agent_id = ?')
-                      .get(agentId) as { background: number } | undefined
-                    if (row != null) isBackground = row.background === 1
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description)
                   } catch { /* best-effort */ }
                 }
+                const isBackground = dispatch.isBackground
+                // #PR2 live worker-feed: force the terminal recap edit on
+                // the worker's live message. No-op when no message was ever
+                // posted (trivial workers stay silent; handback covers them).
+                // 'orphan' is a stale boot row, not a fresh completion — map
+                // it to 'done' so an already-posted message still finalizes.
+                if (workerFeedEnabled) {
+                  void workerActivityFeed.finish(agentId, {
+                    description: dispatch.feedDescription,
+                    lastTool: null,
+                    toolCount,
+                    latestSummary: resultText,
+                    elapsedMs: durationMs,
+                    state: outcome === 'failed' ? 'failed' : 'done',
+                  })
+                }
 
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
@@ -17510,7 +17514,6 @@ void (async () => {
               // lives in the `onFinish` block just above.
               onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
                 let fleetChatId = ''
-                let isBackground = false
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
                   for (const f of fleets) {
@@ -17520,14 +17523,18 @@ void (async () => {
                     }
                   }
                 } catch { /* peek failures non-fatal */ }
+                // The watcher's `description` is its 'sub-agent' default (it
+                // never reassigns it from the worker jsonl). The dispatch-time
+                // task description lives in the registry row — resolveWorkerFeedDispatch
+                // prefers it so the header reads "🔧 Worker · <real task>" not
+                // "· sub-agent" (worker-feed-dispatch.ts, pinned by its test).
+                let dispatch: WorkerFeedDispatch = resolveWorkerFeedDispatch(null, description)
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb
-                      .prepare('SELECT background FROM subagents WHERE jsonl_agent_id = ?')
-                      .get(agentId) as { background: number } | undefined
-                    if (row != null) isBackground = row.background === 1
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description)
                   } catch { /* best-effort */ }
                 }
+                const isBackground = dispatch.isBackground
                 if (!isBackground) return // skip overhead for foreground
 
                 // #PR2 live worker-feed: when ON, the worker's live chat
@@ -17541,7 +17548,7 @@ void (async () => {
                     agentId,
                     fleetChatId || (loadAccess().allowFrom[0] ?? ''),
                     {
-                      description,
+                      description: dispatch.feedDescription,
                       lastTool,
                       toolCount,
                       latestSummary,

package/telegram-plugin/gateway/worker-feed-dispatch.ts

@@ -0,0 +1,37 @@
+import type { Subagent } from '../registry/subagents-schema.js'
+
+export interface WorkerFeedDispatch {
+  /** True when the sub-agent was dispatched with `run_in_background: true`. */
+  isBackground: boolean
+  /**
+   * The human-readable task to render in the feed header
+   * ("🔧 Worker · <feedDescription>").
+   */
+  feedDescription: string
+}
+
+/**
+ * Resolve the two registry-derived inputs the worker-activity feed needs:
+ * whether the sub-agent was a background dispatch, and the task description
+ * to show in the feed header.
+ *
+ * The live watcher only carries a generic 'sub-agent' label — it never
+ * reassigns `description` from the worker jsonl. The real dispatch-time
+ * description lives in the registry `subagents` row (written by the pretool
+ * hook from the `Agent(description:)` input). Prefer it; fall back to the
+ * watcher's label only when the row is missing or its description is empty.
+ *
+ * Pure + DB-free so it pins the #2002 behavior under both vitest and bun —
+ * see worker-feed-dispatch.test.ts. The gateway must never inline this
+ * decision again: a regression here silently reverts the feed header to
+ * "· sub-agent".
+ */
+export function resolveWorkerFeedDispatch(
+  sub: Subagent | null,
+  watcherDescription: string,
+): WorkerFeedDispatch {
+  return {
+    isBackground: sub?.background ?? false,
+    feedDescription: (sub?.description ?? '') || watcherDescription,
+  }
+}

package/telegram-plugin/subagent-watcher.ts

@@ -73,7 +73,13 @@ export interface WorkerEntry {
   readonly agentId: string
   /** File path of the JSONL. */
   readonly filePath: string
-  /** Short description — from the sub-agent's first text/narrative line. */
+  /**
+   * Generic 'sub-agent' placeholder — the watcher deliberately does NOT
+   * reassign this from the worker jsonl (see the init at construction and
+   * the "Do NOT overwrite" note in the line-handler). The real dispatch-time
+   * task description lives in the registry `subagents` row; the gateway reads
+   * it there via resolveWorkerFeedDispatch for the worker-feed header.
+   */
   description: string
   /** Current lifecycle state. */
   state: WorkerState
@@ -864,6 +870,9 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     const entry: WorkerEntry = {
       agentId,
       filePath,
+      // Generic placeholder only — never overwritten from the jsonl. The
+      // gateway substitutes the real registry description for the worker
+      // feed (resolveWorkerFeedDispatch). See the WorkerEntry.description doc.
       description: 'sub-agent',
       state: 'running',
       dispatchedAt: n,

package/telegram-plugin/tests/worker-feed-dispatch.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+import type { Subagent } from '../registry/subagents-schema.js'
+import { resolveWorkerFeedDispatch } from '../gateway/worker-feed-dispatch.js'
+
+function makeSub(over: Partial<Subagent>): Subagent {
+  return {
+    id: 'toolu_01ABC',
+    parent_session_id: null,
+    parent_turn_key: null,
+    agent_type: 'general-purpose',
+    description: null,
+    background: false,
+    started_at: 0,
+    last_activity_at: null,
+    ended_at: null,
+    status: 'running',
+    result_summary: null,
+    jsonl_agent_id: 'a37ad7639ae61476c',
+    ...over,
+  }
+}
+
+describe('resolveWorkerFeedDispatch (#2002 regression pin)', () => {
+  it('uses the real registry description for the feed header, not the watcher label', () => {
+    const sub = makeSub({ background: true, description: 'Background ten-step worker' })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent')
+    expect(out.isBackground).toBe(true)
+    expect(out.feedDescription).toBe('Background ten-step worker')
+  })
+
+  it('falls back to the watcher label when the registry row is missing', () => {
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent')
+    expect(out.isBackground).toBe(false)
+    expect(out.feedDescription).toBe('sub-agent')
+  })
+
+  it('falls back to the watcher label when the registry description is null', () => {
+    const sub = makeSub({ background: true, description: null })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent')
+    expect(out.isBackground).toBe(true)
+    expect(out.feedDescription).toBe('sub-agent')
+  })
+
+  it('falls back to the watcher label when the registry description is empty', () => {
+    const sub = makeSub({ background: true, description: '' })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent')
+    expect(out.feedDescription).toBe('sub-agent')
+  })
+
+  it('reports a foreground sub-agent as not background', () => {
+    const sub = makeSub({ background: false, description: 'inline helper' })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent')
+    expect(out.isBackground).toBe(false)
+    // description still resolves — callers gate on isBackground separately.
+    expect(out.feedDescription).toBe('inline helper')
+  })
+
+  it('a missing row defaults isBackground false so the feed never fires blind', () => {
+    // The gateway gates the feed on isBackground; a registry miss must not
+    // flip a foreground turn into a background one.
+    expect(resolveWorkerFeedDispatch(null, '').isBackground).toBe(false)
+  })
+})

package/telegram-plugin/uat/scenarios/jtbd-worker-activity-feed-dm.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Live worker-activity feed (#2000) — UAT.
+ *
+ * A *background* sub-agent decouples from the parent turn; when the turn
+ * ends nothing surfaces its ongoing jsonl activity and a long worker
+ * reads as silence. The feed (flag `SWITCHROOM_WORKER_ACTIVITY_FEED=1`,
+ * set on the test-harness agent for this run) posts ONE regular Telegram
+ * message per background worker and edits it in place — current tool +
+ * short summary + elapsed — finalizing with a recap on completion.
+ *
+ * This scenario dispatches a real background worker (~60s of paced
+ * sleep/echo work, so it narrates between tools and the feed can paint
+ * + edit), then asserts:
+ *
+ *   1. a worker-feed message appears (🔧 Worker · …), distinct from the
+ *      parent's ack reply — proving background activity surfaces after
+ *      the parent turn closed;
+ *   2. the message edits in place while work is in flight (body changes
+ *      across a window) — proving it's live, not a one-shot post;
+ *   3. it finalizes to the terminal recap (✅ Worker done · … / N tools).
+ *
+ * It logs every observed body so a human can read the real rendered UX.
+ *
+ * Prompt is the deterministic Option-1 dispatch from
+ * `bg-sub-agent-dispatch-dm.test.ts` (naming the Agent tool + arg keeps
+ * the model from running the sleeps inline via Bash).
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+
+// The worker must keep its jsonl ticking faster than the *test-harness*
+// stall window (SWITCHROOM_SUBAGENT_STALL_MS=5000 /
+// SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS=10000 in switchroom.yaml — see
+// PR #1110): a worker silent for >15s gets a *synthesized* terminal
+// turn_end mid-flight, which flips the watcher entry to `done` and
+// suppresses every later onProgress (the feed then never paints). Long
+// silent `sleep 20`s tripped exactly that. So we drive ~10 short steps,
+// each its own Bash call with a one-line narration, keeping the gap
+// between jsonl emissions ~2s — well under the 5s stall floor — for
+// ~30-40s total: long enough to clear the 8s first-paint, throttle, and
+// land several in-place edits before the real end_turn.
+const BG_DISPATCH_PROMPT =
+  `Use the Agent tool with subagent_type "general-purpose" and ` +
+  `run_in_background: true to dispatch a worker with this exact task: ` +
+  `"Do ten steps, ONE AT A TIME, k = 1 through 10. Before each step ` +
+  `write a brief one-sentence narration of what you are about to do, ` +
+  `then run \`sleep 2\` via the Bash tool, then run \`echo step-k\` via ` +
+  `the Bash tool (substitute the real number for k). Run every sleep and ` +
+  `every echo as its OWN separate Bash call — never batch or chain them ` +
+  `with && — and narrate before each so progress surfaces incrementally. ` +
+  `Do not stop early; complete all ten steps." After dispatching, send a ` +
+  `brief reply saying you've kicked off the background worker so I can ` +
+  `watch its progress.`;
+
+// The feed header rendered in Telegram: "🔧 Worker · <desc>" (running)
+// or "✅ Worker done · …" / "⚠️ Worker failed · …" (terminal).
+const WORKER_FEED_RE = /🔧\s*Worker|Worker done|Worker failed|⚡/i;
+const WORKER_DONE_RE = /✅\s*Worker done|⚠️\s*Worker failed/i;
+
+describe("uat: live worker-activity feed (#2000)", () => {
+  it(
+    "surfaces a background worker as a live, editing message that finalizes",
+    async () => {
+      const sc = await spinUp({ agent: "test-harness" });
+      try {
+        await sc.sendDM(BG_DISPATCH_PROMPT);
+
+        // Parent ack — some bot reply so we know the parent turn closed.
+        const ack = await sc.expectMessage(/.+/, {
+          from: "bot",
+          timeout: 45_000,
+        });
+        console.log(`[worker-feed UAT] parent ack: ${JSON.stringify(ack.text)}`);
+
+        // The worker-feed message. May arrive after the parent ack since
+        // first-paint waits for the worker to run ~8s and narrate.
+        const feed = await sc.expectMessage(WORKER_FEED_RE, {
+          from: "bot",
+          timeout: 75_000,
+        });
+        console.log(
+          `[worker-feed UAT] first feed paint (id=${feed.messageId}): ${JSON.stringify(feed.text)}`,
+        );
+        expect(feed.messageId).toBeGreaterThan(0);
+
+        // Live edit: snapshot, wait past the throttle + a heartbeat, and
+        // re-fetch the SAME message. Body should change as work advances.
+        // Soft: a very terse worker might narrate only once; we still
+        // require the terminal recap below, which is the load-bearing
+        // proof. Log either way so the real cadence is visible.
+        const before = feed.text;
+        await new Promise((r) => setTimeout(r, 12_000));
+        const mid = await sc.driver.getMessage(sc.botUserId, feed.messageId);
+        console.log(
+          `[worker-feed UAT] after 12s (id=${feed.messageId}): ${JSON.stringify(mid?.text ?? null)}`,
+        );
+        expect(mid, "worker-feed message vanished mid-flight").not.toBeNull();
+
+        // Terminal recap — poll the same message until it flips to the
+        // done/failed header. Generous budget: ~60s of work + finalize.
+        let doneText: string | null = null;
+        const deadline = Date.now() + 120_000;
+        while (Date.now() < deadline) {
+          const m = await sc.driver.getMessage(sc.botUserId, feed.messageId);
+          if (m != null && WORKER_DONE_RE.test(m.text)) {
+            doneText = m.text;
+            break;
+          }
+          await new Promise((r) => setTimeout(r, 5_000));
+        }
+        console.log(
+          `[worker-feed UAT] terminal (id=${feed.messageId}): ${JSON.stringify(doneText)}`,
+        );
+        expect(doneText, "worker-feed never reached a terminal recap").not.toBeNull();
+        expect(doneText!).toMatch(/tools?|tool ·/i);
+        // Did the body actually move between first paint and terminal?
+        expect(doneText).not.toBe(before);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    240_000,
+  );
+});