switchroom 0.14.15 → 0.14.16

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.16";
+var COMMIT_SHA = "6f5d9562";
 
 // src/cli/agent.ts
 init_source();

package/package.json

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

@@ -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.16";
+var COMMIT_SHA = "6f5d9562";
+var COMMIT_DATE = "2026-05-30T04:37:39Z";
+var LATEST_PR = 2003;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -61331,18 +61331,9 @@ 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;
+                let dispatchDesc = "";
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
                   for (const f of fleets) {
@@ -61354,11 +61345,23 @@ var didOneTimeSetup = false;
                 } catch {}
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb.prepare("SELECT background FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
-                    if (row != null)
+                    const row = turnsDb.prepare("SELECT background, description FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
+                    if (row != null) {
                       isBackground = row.background === 1;
+                      dispatchDesc = row.description ?? "";
+                    }
                   } catch {}
                 }
+                if (workerFeedEnabled) {
+                  workerActivityFeed.finish(agentId, {
+                    description: dispatchDesc || description,
+                    lastTool: null,
+                    toolCount,
+                    latestSummary: resultText,
+                    elapsedMs: durationMs,
+                    state: outcome === "failed" ? "failed" : "done"
+                  });
+                }
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
@@ -61394,6 +61397,7 @@ var didOneTimeSetup = false;
               onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
                 let fleetChatId = "";
                 let isBackground = false;
+                let dispatchDesc = "";
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? [];
                   for (const f of fleets) {
@@ -61405,16 +61409,18 @@ var didOneTimeSetup = false;
                 } catch {}
                 if (turnsDb != null) {
                   try {
-                    const row = turnsDb.prepare("SELECT background FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
-                    if (row != null)
+                    const row = turnsDb.prepare("SELECT background, description FROM subagents WHERE jsonl_agent_id = ?").get(agentId);
+                    if (row != null) {
                       isBackground = row.background === 1;
+                      dispatchDesc = row.description ?? "";
+                    }
                   } catch {}
                 }
                 if (!isBackground)
                   return;
                 if (workerFeedEnabled) {
                   workerActivityFeed.update(agentId, fleetChatId || (loadAccess().allowFrom[0] ?? ""), {
-                    description,
+                    description: dispatchDesc || description,
                     lastTool,
                     toolCount,
                     latestSummary,

package/telegram-plugin/gateway/gateway.ts

@@ -17396,21 +17396,6 @@ 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
@@ -17418,6 +17403,10 @@ void (async () => {
                 // `subagent-handback-decision.test.ts`.
                 let fleetChatId = ''
                 let isBackground = false
+                // Dispatch-time task description from the registry row —
+                // see the onProgress note; used for the feed's terminal recap
+                // header so it matches the running header ("· <real task>").
+                let dispatchDesc = ''
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
                   for (const f of fleets) {
@@ -17433,11 +17422,29 @@ void (async () => {
                 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
+                      .prepare('SELECT background, description FROM subagents WHERE jsonl_agent_id = ?')
+                      .get(agentId) as { background: number; description: string | null } | undefined
+                    if (row != null) {
+                      isBackground = row.background === 1
+                      dispatchDesc = row.description ?? ''
+                    }
                   } catch { /* best-effort */ }
                 }
+                // #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: dispatchDesc || description,
+                    lastTool: null,
+                    toolCount,
+                    latestSummary: resultText,
+                    elapsedMs: durationMs,
+                    state: outcome === 'failed' ? 'failed' : 'done',
+                  })
+                }
 
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
@@ -17511,6 +17518,11 @@ void (async () => {
               onProgress: ({ agentId, description, latestSummary, elapsedMs, prevBucketIdx, setBucketIdx, lastTool, toolCount }) => {
                 let fleetChatId = ''
                 let isBackground = false
+                // 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 — prefer it so the
+                // feed header reads "🔧 Worker · <real task>" not "· sub-agent".
+                let dispatchDesc = ''
                 try {
                   const fleets = progressDriver?.peekAllFleets() ?? []
                   for (const f of fleets) {
@@ -17523,9 +17535,12 @@ void (async () => {
                 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
+                      .prepare('SELECT background, description FROM subagents WHERE jsonl_agent_id = ?')
+                      .get(agentId) as { background: number; description: string | null } | undefined
+                    if (row != null) {
+                      isBackground = row.background === 1
+                      dispatchDesc = row.description ?? ''
+                    }
                   } catch { /* best-effort */ }
                 }
                 if (!isBackground) return // skip overhead for foreground
@@ -17541,7 +17556,7 @@ void (async () => {
                     agentId,
                     fleetChatId || (loadAccess().allowFrom[0] ?? ''),
                     {
-                      description,
+                      description: dispatchDesc || description,
                       lastTool,
                       toolCount,
                       latestSummary,

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,
+  );
+});