switchroom 0.14.14 → 0.14.16

package/telegram-plugin/tests/status-reactions.test.ts

@@ -340,4 +340,83 @@ describe('StatusReactionController', () => {
     await flush()
     expect(calls).toEqual(['👀'])
   })
+
+  // hold(): freeze on a WORKING glyph while background sub-agent workers
+  // outlive the parent turn, deferring the terminal 👍 (worker-reaction fix).
+  describe('hold() — defer 👍 while a background worker runs', () => {
+    it('suppresses stall promotion (no 🥱/😨) while held', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.setTool('Bash') // working: 👨‍💻
+      vi.advanceTimersByTime(3500)
+      await flush()
+
+      ctrl.hold()
+      await flush()
+      // Well past both stall thresholds — held must not yawn or panic.
+      vi.advanceTimersByTime(120000)
+      await flush()
+      expect(calls).not.toContain('🥱')
+      expect(calls).not.toContain('😨')
+    })
+
+    it('promotes a read/thinking glyph to a working glyph on hold', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued() // 👀 (read-receipt)
+      await flush()
+      expect(calls).toEqual(['👀'])
+
+      ctrl.hold() // should paint an explicit WORKING glyph (✍️)
+      await flush()
+      expect(calls[calls.length - 1]).toBe('✍')
+    })
+
+    it('finalize() still terminates to 👍 after hold (deferred terminal)', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.setTool() // ✍
+      vi.advanceTimersByTime(3500)
+      await flush()
+
+      ctrl.hold()
+      await flush()
+      // Worker runs for a while, then completes → gateway finalizes.
+      vi.advanceTimersByTime(60000)
+      await flush()
+      ctrl.finalize('done')
+      await flush()
+      expect(calls[calls.length - 1]).toBe('👍')
+    })
+
+    it('does not double-paint when already on a working glyph', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.setTool() // ✍
+      vi.advanceTimersByTime(3500)
+      await flush()
+      const before = calls.length
+
+      ctrl.hold() // already on ✍ → no new emit
+      await flush()
+      expect(calls.length).toBe(before)
+    })
+
+    it('hold() after finalize is a no-op (cannot resurrect a finished controller)', async () => {
+      const { emit, calls } = makeEmitter()
+      const ctrl = new StatusReactionController(emit)
+      ctrl.setQueued()
+      ctrl.finalize('done')
+      await flush()
+      const snapshot = [...calls]
+
+      ctrl.hold()
+      vi.advanceTimersByTime(120000)
+      await flush()
+      expect(calls).toEqual(snapshot)
+    })
+  })
 })

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

@@ -0,0 +1,256 @@
+import { describe, it, expect } from 'vitest'
+import {
+  renderWorkerActivity,
+  createWorkerActivityFeed,
+  type WorkerActivityView,
+  type BotApiForWorkerFeed,
+} from '../worker-activity-feed.js'
+
+function view(partial: Partial<WorkerActivityView> = {}): WorkerActivityView {
+  return {
+    description: 'research competitors',
+    lastTool: { name: 'Bash', sanitisedArg: 'grep -r pricing' },
+    toolCount: 3,
+    latestSummary: 'scanning vendor pages',
+    elapsedMs: 10_000,
+    state: 'running',
+    ...partial,
+  }
+}
+
+interface FakeBot extends BotApiForWorkerFeed {
+  sent: Array<{ chatId: string; text: string; opts?: Record<string, unknown> }>
+  edits: Array<{ messageId: number; text: string }>
+  failNextSendWith?: unknown
+  failNextEditWith?: unknown
+}
+
+function makeFakeBot(): FakeBot {
+  let nextId = 1000
+  const fb: FakeBot = {
+    sent: [],
+    edits: [],
+    sendMessage: async (chatId, text, opts) => {
+      if (fb.failNextSendWith != null) {
+        const e = fb.failNextSendWith
+        fb.failNextSendWith = undefined
+        throw e
+      }
+      fb.sent.push({ chatId, text, opts })
+      return { message_id: nextId++ }
+    },
+    editMessageText: async (_chatId, messageId, text) => {
+      if (fb.failNextEditWith != null) {
+        const e = fb.failNextEditWith
+        fb.failNextEditWith = undefined
+        throw e
+      }
+      fb.edits.push({ messageId, text })
+      return {}
+    },
+  }
+  return fb
+}
+
+// ─── renderWorkerActivity (pure) ─────────────────────────────────────────────
+
+describe('renderWorkerActivity', () => {
+  it('renders running header + tool activity line + summary', () => {
+    const out = renderWorkerActivity(view())
+    expect(out).toContain('🔧 <b>Worker</b> · <i>research competitors</i>')
+    expect(out).toContain('⚡ <code>Bash</code> grep -r pricing')
+    expect(out).toContain('(3 tools · ')
+    expect(out).toContain('↳ <i>scanning vendor pages</i>')
+  })
+
+  it('shows a "starting…" line when no tool has run yet', () => {
+    const out = renderWorkerActivity(view({ lastTool: null, latestSummary: '' }))
+    expect(out).toContain('🔧 <b>Worker</b>')
+    expect(out).toContain('starting…')
+    expect(out).not.toContain('⚡')
+  })
+
+  it('omits the summary line when latestSummary is blank', () => {
+    const out = renderWorkerActivity(view({ latestSummary: '   ' }))
+    expect(out).not.toContain('↳')
+  })
+
+  it('uses singular "tool" for a single tool call', () => {
+    const out = renderWorkerActivity(view({ toolCount: 1 }))
+    expect(out).toContain('(1 tool · ')
+  })
+
+  it('renders a done terminal recap', () => {
+    const out = renderWorkerActivity(view({ state: 'done', toolCount: 5 }))
+    expect(out).toContain('✅ <b>Worker done</b> · <i>research competitors</i>')
+    expect(out).toContain('5 tools · ')
+    expect(out).not.toContain('⚡')
+  })
+
+  it('renders a failed terminal recap', () => {
+    const out = renderWorkerActivity(view({ state: 'failed' }))
+    expect(out).toContain('⚠️ <b>Worker failed</b>')
+  })
+
+  it('escapes HTML in description, tool, arg, and summary', () => {
+    const out = renderWorkerActivity(
+      view({
+        description: 'a <b>bold</b> task',
+        lastTool: { name: 'Ba<sh', sanitisedArg: 'x & y' },
+        latestSummary: 'a > b',
+      }),
+    )
+    expect(out).toContain('a &lt;b&gt;bold&lt;/b&gt; task')
+    expect(out).toContain('Ba&lt;sh')
+    expect(out).toContain('x &amp; y')
+    expect(out).toContain('a &gt; b')
+  })
+})
+
+// ─── createWorkerActivityFeed (lifecycle) ────────────────────────────────────
+
+describe('createWorkerActivityFeed', () => {
+  it('holds first paint until the worker has run firstPaintMinMs', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      firstPaintMinMs: 8000,
+    })
+    clock = 5000
+    await feed.update('w1', 'chat', view({ elapsedMs: 5000 }))
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.has('w1')).toBe(false)
+
+    clock = 9000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000 }))
+    expect(bot.sent).toHaveLength(1)
+    expect(bot.sent[0].chatId).toBe('chat')
+    expect(bot.sent[0].opts?.parse_mode).toBe('HTML')
+    expect(feed.has('w1')).toBe(true)
+  })
+
+  it('dedups an identical body (no edit)', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+    await feed.update('w1', 'chat', view())
+    expect(bot.sent).toHaveLength(1)
+    clock = 20_000
+    await feed.update('w1', 'chat', view()) // same body
+    expect(bot.edits).toHaveLength(0)
+  })
+
+  it('throttles edits inside minEditIntervalMs but lets them through after', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 2500 })
+    await feed.update('w1', 'chat', view({ toolCount: 1 }))
+    expect(bot.sent).toHaveLength(1)
+
+    clock = 11_000 // +1000 < 2500
+    await feed.update('w1', 'chat', view({ toolCount: 2 }))
+    expect(bot.edits).toHaveLength(0)
+
+    clock = 13_000 // +3000 since last edit > 2500
+    await feed.update('w1', 'chat', view({ toolCount: 3 }))
+    expect(bot.edits).toHaveLength(1)
+    expect(bot.edits[0].text).toContain('(3 tools · ')
+  })
+
+  it('forces a terminal edit on finish, skipping the throttle', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 9_999_999 })
+    await feed.update('w1', 'chat', view())
+    expect(bot.sent).toHaveLength(1)
+
+    clock = 10_500 // well within the throttle window
+    await feed.finish('w1', view({ state: 'done', toolCount: 5 }))
+    expect(bot.edits).toHaveLength(1)
+    expect(bot.edits[0].text).toContain('✅ <b>Worker done</b>')
+    // finish forgets the worker.
+    expect(feed.has('w1')).toBe(false)
+    expect(feed.size).toBe(0)
+  })
+
+  it('finish is a no-op when no message was ever posted', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, firstPaintMinMs: 8000 })
+    clock = 2000
+    await feed.update('w1', 'chat', view({ elapsedMs: 2000 })) // too short to paint
+    expect(bot.sent).toHaveLength(0)
+    await feed.finish('w1', view({ state: 'done' }))
+    expect(bot.edits).toHaveLength(0)
+    expect(bot.sent).toHaveLength(0)
+  })
+
+  it('drop forgets a worker without editing', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock })
+    await feed.update('w1', 'chat', view())
+    expect(feed.has('w1')).toBe(true)
+    feed.drop('w1')
+    expect(feed.has('w1')).toBe(false)
+    expect(feed.size).toBe(0)
+    await feed.finish('w1', view({ state: 'done' }))
+    expect(bot.edits).toHaveLength(0)
+  })
+
+  it('honours a 429 cooldown before retrying the first paint', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, firstPaintMinMs: 0 })
+    bot.failNextSendWith = { error_code: 429, parameters: { retry_after: 2 } }
+    await feed.update('w1', 'chat', view())
+    expect(bot.sent).toHaveLength(0) // failed send
+
+    clock = 11_000 // still inside cooldown (10_000 + 2000 + 500 jitter = 12_500)
+    await feed.update('w1', 'chat', view())
+    expect(bot.sent).toHaveLength(0)
+
+    clock = 13_000 // past cooldown
+    await feed.update('w1', 'chat', view())
+    expect(bot.sent).toHaveLength(1)
+  })
+
+  it('re-posts after a stale-message edit failure', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+    await feed.update('w1', 'chat', view({ toolCount: 1 }))
+    expect(bot.sent).toHaveLength(1)
+
+    clock = 20_000
+    bot.failNextEditWith = new Error('Bad Request: message to edit not found')
+    await feed.update('w1', 'chat', view({ toolCount: 2 }))
+    expect(bot.edits).toHaveLength(0) // edit threw
+    expect(feed.has('w1')).toBe(false) // messageId reset
+
+    clock = 30_000
+    await feed.update('w1', 'chat', view({ toolCount: 3 }))
+    expect(bot.sent).toHaveLength(2) // re-posted
+    expect(feed.has('w1')).toBe(true)
+  })
+
+  it('skips entirely when chatId is empty (owner DM unconfigured)', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock })
+    await feed.update('w1', '', view())
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.has('w1')).toBe(false)
+    expect(feed.size).toBe(0)
+  })
+
+  it('forwards threadId as message_thread_id on send', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock })
+    await feed.update('w1', 'chat', view(), 42)
+    expect(bot.sent[0].opts?.message_thread_id).toBe(42)
+  })
+})

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