switchroom 0.14.20 → 0.14.22

package/telegram-plugin/tests/stream-reply-error-paths.test.ts

@@ -40,7 +40,6 @@ function makeDeps(
     markdownToHtml: (t) => realMarkdownToHtml(t),
     escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -35,7 +35,6 @@ function makeDeps(
     markdownToHtml: (t) => `<b>${t}</b>`,
     escapeMarkdownV2: (t) => `\\${t}\\`,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,
@@ -104,29 +103,6 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage.mock.calls[0][2]?.parse_mode).toBeUndefined()
   })
 
-  it('prepends handoff prefix on first chunk only', async () => {
-    const state = makeState()
-    const deps = makeDeps(bot, {
-      takeHandoffPrefix: vi.fn<(fmt: string) => string>(() => '↩️ '),
-    })
-
-    // First call: prefix applied
-    const p1 = handleStreamReply({ chat_id: '1', text: 'first' }, state, deps)
-    await microtaskFlush()
-    await p1
-    // Prefix is prepended AFTER format rendering (it's already format-safe
-    // because takeHandoffPrefix takes the format tag).
-    expect(bot.api.sendMessage.mock.calls[0][1]).toBe('↩️ <b>first</b>')
-
-    // Second call: handoff not consumed again
-    vi.advanceTimersByTime(1000)
-    const p2 = handleStreamReply({ chat_id: '1', text: 'second' }, state, deps)
-    await microtaskFlush()
-    await p2
-    expect(bot.api.editMessageText.mock.calls[0][2]).toBe('<b>second</b>')
-    expect(deps.takeHandoffPrefix).toHaveBeenCalledTimes(1)
-  })
-
   it('throws when text exceeds 4096 (no silent id:pending)', async () => {
     // Pins the bug found in prod: a >4096-char text would hit draft-
     // stream's length guard, silently stop, and the handler would return

package/telegram-plugin/tests/streaming-e2e.test.ts

@@ -88,7 +88,6 @@ function setup(opts: { progressCardActive?: boolean } = {}): Fixture {
       markdownToHtml: (t) => `<b>${t}</b>`, // stream_reply: bold
       escapeMarkdownV2: (t) => t,
       repairEscapedWhitespace: (t) => t,
-      takeHandoffPrefix: () => '',
       assertAllowedChat: () => {},
       resolveThreadId: () => undefined,
       disableLinkPreview: true,

package/telegram-plugin/tests/streaming-orchestration.test.ts

@@ -407,7 +407,6 @@ function makeActivityDeps(
     markdownToHtml: (t) => t,
     escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
-    takeHandoffPrefix: () => '',
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,

package/telegram-plugin/tests/tool-activity-summary.test.ts

@@ -4,7 +4,9 @@ import {
   appendActivityLine,
   appendActivityLabel,
   renderActivityFeed,
+  renderActivityFeedWithNested,
   MIRROR_MAX_LINES,
+  NESTED_MAX_LINES,
 } from "../tool-activity-summary.js";
 
 describe("describeToolUse — friendly per-tool rendering (draft-mirror)", () => {
@@ -143,3 +145,45 @@ describe("appendActivityLabel — precomputed label feed (tool_label path)", ()
     expect(lines.length).toBe(2);
   });
 });
+
+describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A)", () => {
+  it("with no child lines, is identical to the flat feed", () => {
+    const lines = ["Searching memory", "Delegating: review the migration"];
+    expect(renderActivityFeedWithNested(lines, [])).toBe(renderActivityFeed(lines));
+    // whitespace-only children also collapse to the flat feed
+    expect(renderActivityFeedWithNested(lines, ["  ", ""])).toBe(renderActivityFeed(lines));
+  });
+
+  it("done-styles ALL parent lines and nests the child block (newest = bold →)", () => {
+    const parent = ["Searching memory", "Delegating: review the migration"];
+    const child = ["Reading schema.ts", "Looking for foreign keys"];
+    const out = renderActivityFeedWithNested(parent, child)!;
+    // Parent is blocked at the Task tool → none of its lines is the live step.
+    expect(out).toContain("<i>✓ Searching memory</i>");
+    expect(out).toContain("<i>✓ Delegating: review the migration</i>");
+    expect(out).not.toContain("<b>→ Delegating");
+    // The live → step is the newest nested child line; earlier child = italic.
+    expect(out).toContain("   ↳ <i>Reading schema.ts</i>");
+    expect(out).toContain("   ↳ <b>→ Looking for foreign keys</b>");
+  });
+
+  it("caps the nested block to NESTED_MAX_LINES with a '↳ +N earlier…' header", () => {
+    const child = Array.from({ length: NESTED_MAX_LINES + 3 }, (_, i) => `step ${i + 1}`);
+    const out = renderActivityFeedWithNested(["Delegating: x"], child)!;
+    expect(out).toContain("   ↳ <i>+3 earlier…</i>");
+    // newest nested line is the live → step
+    expect(out).toContain(`   ↳ <b>→ step ${NESTED_MAX_LINES + 3}</b>`);
+    // the oldest (collapsed) lines are not rendered verbatim
+    expect(out).not.toContain("step 1<");
+  });
+
+  it("renders the child block even when the parent feed is empty", () => {
+    const out = renderActivityFeedWithNested([], ["Reading a.ts"]);
+    expect(out).toBe("   ↳ <b>→ Reading a.ts</b>");
+  });
+
+  it("HTML-escapes nested child text", () => {
+    const out = renderActivityFeedWithNested(["Delegating: x"], ["touch <a> & <b>"])!;
+    expect(out).toContain("   ↳ <b>→ touch &lt;a&gt; &amp; &lt;b&gt;</b>");
+  });
+});

package/telegram-plugin/tests/turns-writer.test.ts

@@ -5,7 +5,7 @@
  *   1. Clean turn: insert + finalize → row has ended_via='stop', non-null
  *      ended_at, correct previews.
  *   2. Mid-turn restart: insert without finalize, simulate gateway boot via
- *      markOrphanedAsRestarted → row has ended_via='restart'.
+ *      markOrphanedWithTimeoutClassification → row has ended_via='restart'.
  *   3. Multiple concurrent turns same chat: each row has a unique turn_key,
  *      no cross-contamination.
  *   4. tool_call_count increments correctly for N tool_use events.
@@ -20,9 +20,19 @@ import {
   openTurnsDbInMemory,
   recordTurnStart,
   recordTurnEnd,
-  markOrphanedAsRestarted,
+  markOrphanedWithTimeoutClassification,
 } from '../registry/turns-schema.js'
 
+// The boot reaper as the gateway calls it between turns (no live hang
+// marker) — every open turn is a clean 'restart' interrupt.
+function reapAsRestart(db: Parameters<typeof recordTurnEnd>[0]) {
+  return markOrphanedWithTimeoutClassification(db, {
+    markerTurnKey: null,
+    markerAgeMs: null,
+    hangThresholdMs: 300_000,
+  })
+}
+
 // ---------------------------------------------------------------------------
 // 1. Clean turn
 // ---------------------------------------------------------------------------
@@ -110,7 +120,7 @@ describe('clean turn (Phase 1 #332)', () => {
 // ---------------------------------------------------------------------------
 
 describe('mid-turn restart (Phase 1 #332)', () => {
-  it('insert without finalize, then markOrphanedAsRestarted → ended_via=restart', () => {
+  it('insert without finalize, then reaper → ended_via=restart', () => {
     const db = openTurnsDbInMemory()
 
     recordTurnStart(db, {
@@ -120,8 +130,8 @@ describe('mid-turn restart (Phase 1 #332)', () => {
     })
 
     // Simulate gateway boot reaper (same path as the real gateway boot).
-    const swept = markOrphanedAsRestarted(db)
-    expect(swept).toBe(1)
+    const swept = reapAsRestart(db)
+    expect(swept.reaped).toBe(1)
 
     const row = db
       .prepare('SELECT ended_via, ended_at FROM turns WHERE turn_key = ?')
@@ -141,7 +151,7 @@ describe('mid-turn restart (Phase 1 #332)', () => {
     recordTurnEnd(db, { turnKey: 'chat2:_:2001', endedVia: 'stop' })
     recordTurnStart(db, { turnKey: 'chat2:_:2002', chatId: 'chat2' })
 
-    markOrphanedAsRestarted(db)
+    reapAsRestart(db)
 
     const clean = db
       .prepare('SELECT ended_via FROM turns WHERE turn_key = ?')

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

@@ -2,10 +2,24 @@ import { describe, it, expect } from 'vitest'
 import {
   renderWorkerActivity,
   createWorkerActivityFeed,
+  isWorkerActivityFeedEnabled,
   type WorkerActivityView,
   type BotApiForWorkerFeed,
 } from '../worker-activity-feed.js'
 
+describe('isWorkerActivityFeedEnabled (default ON)', () => {
+  it('defaults to true when the env var is unset', () => {
+    expect(isWorkerActivityFeedEnabled(undefined)).toBe(true)
+  })
+  it('stays on for any value other than "0"', () => {
+    expect(isWorkerActivityFeedEnabled('1')).toBe(true)
+    expect(isWorkerActivityFeedEnabled('')).toBe(true)
+  })
+  it('only "0" disables it', () => {
+    expect(isWorkerActivityFeedEnabled('0')).toBe(false)
+  })
+})
+
 function view(partial: Partial<WorkerActivityView> = {}): WorkerActivityView {
   return {
     description: 'research competitors',

package/telegram-plugin/tool-activity-summary.ts

@@ -216,6 +216,61 @@ export function renderActivityFeed(lines: string[]): string | null {
   return out.join("\n");
 }
 
+// ─── Foreground sub-agent nesting (Model A) ─────────────────────────────────
+//
+// A foreground sub-agent (Task/Agent with no `run_in_background`) runs INSIDE
+// the parent's turn — the parent is blocked at the Task tool until it returns.
+// Rather than a separate message, its live steps nest under the parent's own
+// activity feed: the gold-standard main-turn visibility applied one level
+// down. The parent's lines render as done (the parent handed off; it isn't
+// the active worker), and the sub-agent's recent narrative lines render as an
+// indented `↳` block with the newest as the in-progress `→` step.
+
+/** Trailing nested child lines kept visible (Telegram length + readability). */
+export const NESTED_MAX_LINES = 4;
+/** Hard cap on a single nested narrative line. */
+const NESTED_LINE_MAX = 90;
+/** Indent marker for a nested sub-agent step. */
+const NESTED_PREFIX = "   ↳ ";
+
+/**
+ * Render the parent activity feed with an active foreground sub-agent's steps
+ * nested beneath it. When `childLines` is empty this is identical to
+ * `renderActivityFeed(lines)`. Otherwise the parent's own lines are all
+ * done-styled (`✓` italic) — the live `→` step lives in the nested block —
+ * and the child block is indented, newest = bold `→`, earlier = italic, with
+ * a `↳ +N earlier…` header when it overflows. Returns ready Telegram HTML
+ * (callers must NOT re-escape) or null when there is nothing to show.
+ */
+export function renderActivityFeedWithNested(
+  lines: string[],
+  childLines: string[],
+): string | null {
+  const children = childLines.map((s) => s.trim()).filter((s) => s.length > 0);
+  if (children.length === 0) return renderActivityFeed(lines);
+
+  const out: string[] = [];
+  const shownParent = lines.slice(-MIRROR_MAX_LINES);
+  const hiddenParent = lines.length - shownParent.length;
+  if (hiddenParent > 0) out.push(`<i>✓ +${hiddenParent} earlier…</i>`);
+  for (const l of shownParent) out.push(`<i>✓ ${escapeFeedHtml(l)}</i>`);
+
+  const shownChild = children.slice(-NESTED_MAX_LINES);
+  const hiddenChild = children.length - shownChild.length;
+  if (hiddenChild > 0) out.push(`${NESTED_PREFIX}<i>+${hiddenChild} earlier…</i>`);
+  const lastChildIdx = shownChild.length - 1;
+  shownChild.forEach((l, i) => {
+    const t = l.length > NESTED_LINE_MAX ? l.slice(0, NESTED_LINE_MAX - 1) + "…" : l;
+    const esc = escapeFeedHtml(t);
+    out.push(
+      i === lastChildIdx
+        ? `${NESTED_PREFIX}<b>→ ${esc}</b>`
+        : `${NESTED_PREFIX}<i>${esc}</i>`,
+    );
+  });
+  return out.length > 0 ? out.join("\n") : null;
+}
+
 /**
  * Like appendActivityLine, but for a pre-computed label (from the
  * real-time PreToolUse sidecar / `tool_label` event) — the hook already

package/telegram-plugin/uat/assertions.ts

@@ -11,6 +11,59 @@
 
 import type { Driver, ObservedMessage, ObservedReaction } from "./driver.js";
 
+/**
+ * Canonical shape of a worker-activity-feed message (#2000) as rendered
+ * in Telegram: a running header `🔧 Worker · …` that edits in place and
+ * finalizes to `✅ Worker done · …` / `⚠️ Worker failed · …`. The feed is
+ * default-on fleet-wide as of v0.14.19, so background sub-agent activity
+ * now surfaces as its own bot message in any chat — including DMs whose
+ * scenario only cares about the agent's conversational reply.
+ *
+ * Single source of truth; the worker-feed scenario asserts against this,
+ * and recall/reply scenarios exclude it via {@link isWorkerFeedMessage}.
+ */
+export const WORKER_FEED_RE = /🔧\s*Worker|✅\s*Worker done|⚠️\s*Worker failed|Worker (?:done|failed)/i;
+
+/**
+ * True when `m` is a worker-activity-feed message rather than the agent's
+ * own reply. Use it to skip feed noise when matching for a turn's actual
+ * answer — without it, an `expectMessage(/\S/)` can latch onto the feed's
+ * first paint and miss (or mis-time) the real reply. See #2000 / the
+ * memory-survives-restart recall scenario.
+ */
+export function isWorkerFeedMessage(m: ObservedMessage): boolean {
+  return WORKER_FEED_RE.test(m.text);
+}
+
+/**
+ * A single tool-activity-feed line as rendered by
+ * `renderActivityFeed` (telegram-plugin/tool-activity-summary.ts): the
+ * in-progress step is `→ <label>`, finished steps are `✓ <label>`, and a
+ * long turn gets a `✓ +N earlier…` header. Telegram strips the bold/italic
+ * wrapping, so the observed text is just the marker glyph + label.
+ */
+const ACTIVITY_FEED_LINE_RE = /^[→✓]\s/u;
+
+/**
+ * True when `m` is the live tool-activity feed (the one-message list of
+ * "what the agent is doing this turn") rather than the agent's reply. A
+ * message qualifies only when EVERY non-empty line is an activity line —
+ * so a real reply that merely contains an arrow is never misclassified.
+ *
+ * Recall/reply scenarios must skip this in addition to
+ * {@link isWorkerFeedMessage}: on a turn that uses tools, the feed paints
+ * `→ Finding the right tool` as its own bot message before the real answer
+ * lands, and an `expectMessage(/\S/)` would otherwise latch onto it.
+ */
+export function isActivityFeedMessage(m: ObservedMessage): boolean {
+  const lines = m.text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+  if (lines.length === 0) return false;
+  return lines.every((l) => ACTIVITY_FEED_LINE_RE.test(l));
+}
+
 export interface PollOptions {
   /** Hard deadline; the predicate must resolve truthy before this. */
   timeout: number;

package/telegram-plugin/uat/driver.ts

@@ -646,6 +646,36 @@ export class Driver {
     return { messageId: sent.id };
   }
 
+  /**
+   * Send a photo album (Telegram media_group) — multiple photos posted as
+   * one group, the way a forwarded album or a multi-image paste arrives.
+   * Exercises the gateway's A2 multi-attachment coalescing: with
+   * coalesce.max_attachments default 10, the whole album folds into ONE
+   * Claude turn (the agent sees image_path, image_path_2, …). The optional
+   * caption rides on the first item, matching Telegram client behaviour.
+   * Returns every sent message id (one per album item).
+   */
+  async sendAlbum(
+    chatId: number,
+    photoPaths: string[],
+    caption?: string,
+    opts?: SendTextOptions,
+  ): Promise<{ messageIds: number[] }> {
+    const c = this.requireClient();
+    const replyTo = opts?.replyTo ?? opts?.messageThreadId;
+    // mtcute reads a bare string as a file_id/URL; the `file:` scheme is
+    // what forces an upload from local disk (see normalize-input-media).
+    const medias = photoPaths.map((p, i) =>
+      InputMedia.photo(`file:${p}`, i === 0 && caption ? { caption } : undefined),
+    );
+    const sent = await c.sendMediaGroup(
+      chatId,
+      medias,
+      replyTo ? { replyTo } : undefined,
+    );
+    return { messageIds: sent.map((m) => m.id) };
+  }
+
   /**
    * Send or remove an emoji reaction on a target message. Used by the
    * UAT reaction-trigger scenario (#1074) to exercise the gateway's

package/telegram-plugin/uat/feed-matcher.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "bun:test";
+import {
+  isActivityFeedMessage,
+  isWorkerFeedMessage,
+  WORKER_FEED_RE,
+} from "./assertions.js";
+
+// Pins the worker-activity-feed detector (#2000) used by recall/reply
+// scenarios to skip feed noise. The live UAT it guards can't run in CI
+// (needs sudo + a real Telegram session), so this is the CI-verifiable
+// floor for the matcher's behavior.
+const feed = (text: string) => ({ text }) as Parameters<typeof isWorkerFeedMessage>[0];
+
+describe("isWorkerFeedMessage", () => {
+  it("matches the running feed header", () => {
+    expect(isWorkerFeedMessage(feed("🔧 Worker · crawling changelog · 0:12"))).toBe(true);
+  });
+
+  it("matches the terminal done/failed recaps", () => {
+    expect(isWorkerFeedMessage(feed("✅ Worker done · 10 tools · 1:03"))).toBe(true);
+    expect(isWorkerFeedMessage(feed("⚠️ Worker failed · 3 tools"))).toBe(true);
+  });
+
+  it("matches a done/failed header even without the leading emoji", () => {
+    expect(isWorkerFeedMessage(feed("Worker done · 2 tools"))).toBe(true);
+    expect(isWorkerFeedMessage(feed("Worker failed mid-step"))).toBe(true);
+  });
+
+  it("does NOT match an ordinary agent reply", () => {
+    expect(isWorkerFeedMessage(feed("on it, pulling the logs now"))).toBe(false);
+    expect(
+      isWorkerFeedMessage(feed("SWITCHROOM_UAT_MEM_DEADBEEFCAFE1234")),
+    ).toBe(false);
+  });
+
+  it("does NOT match a reply that merely mentions the word worker", () => {
+    expect(
+      isWorkerFeedMessage(feed("I'll dispatch a worker to handle the crawl.")),
+    ).toBe(false);
+  });
+
+  it("exposes the regex for scenarios that assert on the feed directly", () => {
+    expect(WORKER_FEED_RE.test("🔧 Worker · x")).toBe(true);
+  });
+});
+
+describe("isActivityFeedMessage", () => {
+  it("matches the in-progress step line", () => {
+    expect(isActivityFeedMessage(feed("→ Finding the right tool"))).toBe(true);
+  });
+
+  it("matches a multi-line feed (done steps + in-progress)", () => {
+    expect(
+      isActivityFeedMessage(feed("✓ Reading CLAUDE.md\n→ Searching memory")),
+    ).toBe(true);
+  });
+
+  it("matches the +N earlier header", () => {
+    expect(
+      isActivityFeedMessage(feed("✓ +3 earlier…\n✓ Reading CLAUDE.md\n→ Searching memory")),
+    ).toBe(true);
+  });
+
+  it("does NOT match an ordinary agent reply", () => {
+    expect(isActivityFeedMessage(feed("on it, pulling the logs now"))).toBe(false);
+    expect(
+      isActivityFeedMessage(feed("SWITCHROOM_UAT_MEM_DEADBEEFCAFE1234")),
+    ).toBe(false);
+  });
+
+  it("does NOT match a reply that merely contains an arrow mid-text", () => {
+    expect(
+      isActivityFeedMessage(feed("The flow is request → response → render.")),
+    ).toBe(false);
+  });
+
+  it("does NOT match an empty message", () => {
+    expect(isActivityFeedMessage(feed("   "))).toBe(false);
+  });
+});

package/telegram-plugin/uat/scenarios/jtbd-album-coalescing-dm.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Album-coalescing scenario — driver sends a 3-photo Telegram album
+ * (media_group) in one shot; the gateway's A2 multi-attachment
+ * coalescing (coalesce.max_attachments, default 10 since v0.14.21)
+ * MUST fold all three into a SINGLE Claude turn, so the agent sees
+ * image_path + image_path_2 + image_path_3 together and can report a
+ * count of 3.
+ *
+ * Regression gate for the default-on flip (#2021): before max_attachments
+ * defaulted to 10, an album bypassed coalescing (each part its own turn),
+ * so the agent would only ever see ONE image per turn and answer "1".
+ * A reply of "3" proves the album coalesced.
+ *
+ * Part of: https://github.com/switchroom/switchroom/issues/865
+ *
+ * ## How the signal is read robustly
+ *
+ * The agent's answer is a bare count, which would collide with incidental
+ * digits the chat is now full of by default: the pinned progress card's
+ * timer (`00:03`) and — since the worker feed went default-on fleet-wide
+ * (#2009 / v0.14.19) — worker-feed lines like `🔧 Worker · … · 0:12`.
+ * A "first bot message containing a digit" matcher would latch onto one of
+ * those and false-fail even when coalescing is healthy (see the
+ * memory-survives-restart matcher-flake note + `isWorkerFeedMessage`).
+ *
+ * Two defences, mirroring the sibling `jtbd-forwarded-burst-dm` gate:
+ *   1. Anchor the answer on a distinctive token — the agent is told to
+ *      reply `IMAGECOUNT=<n>`. "IMAGECOUNT" never appears in a card or a
+ *      worker-feed line, so the matcher cannot collide with their digits.
+ *   2. Drain observed messages into a per-id map (collapsing streamed
+ *      edits to latest text), skip our own sends + worker-feed noise, and
+ *      poll until the ANSWER token appears — rather than returning the
+ *      first message that happens to match.
+ *
+ *   - Coalesced   → one turn sees 3 images → `IMAGECOUNT=3`.
+ *   - Non-coalesced → the turn carrying the caption/question sees only its
+ *     own (first) image → `IMAGECOUNT=1`. Surfaced as an explicit failure.
+ *
+ * Fixtures: three tiny solid-colour JPEGs under fixtures/album/, committed
+ * so the gate runs without a generation step. (Regenerate with
+ * `ffmpeg -f lavfi -i color=c=red:s=320x240 -frames:v 1 red.jpg`.)
+ */
+
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { pollUntil, isWorkerFeedMessage } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
+
+const AGENT = "test-harness";
+
+const FIXTURE_DIR = path.resolve(__dirname, "..", "fixtures", "album");
+const PHOTOS = ["red.jpg", "green.jpg", "blue.jpg"].map((f) =>
+  path.join(FIXTURE_DIR, f),
+);
+
+const CAPTION =
+  "I just sent you a photo album in a single message. Count the separate " +
+  "image files you received in THIS ONE incoming message and reply with " +
+  "ONLY the token IMAGECOUNT=<n> (e.g. IMAGECOUNT=3). Nothing else.";
+
+// Warm TTFO on test-harness is ~7s; an album adds the (sub-second)
+// coalesce window plus the model looking at three images.
+const ANSWER_TIMEOUT_MS = 90_000;
+
+// Pull the count out of an `IMAGECOUNT=<n>` token, tolerating "= : whitespace".
+function imageCountIn(text: string): number | undefined {
+  const m = text.match(/IMAGECOUNT\s*[:=]?\s*(\d+)/i);
+  return m ? Number.parseInt(m[1], 10) : undefined;
+}
+
+describe("uat: album-coalescing DM round-trip", () => {
+  it(
+    "a 3-photo album folds into ONE turn — agent reports seeing 3 images",
+    async () => {
+      for (const p of PHOTOS) {
+        if (!existsSync(p)) {
+          throw new Error(
+            `album fixture missing at ${p} — see scenario header to regenerate`,
+          );
+        }
+      }
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        // Observe BEFORE sending — observeMessages only sees live updates.
+        // Drain into a per-id map so streamed edits collapse to latest text;
+        // skip our own sends and worker-feed noise so neither can satisfy
+        // the count matcher.
+        const latestById = new Map<number, ObservedMessage>();
+        const stream = sc.driver.observeMessages(sc.botUserId);
+        const consume = (async () => {
+          for await (const m of stream) {
+            if (m.senderUserId === sc.driverUserId) continue;
+            if (isWorkerFeedMessage(m)) continue;
+            latestById.set(m.messageId, m);
+          }
+        })();
+
+        await sc.driver.sendAlbum(sc.botUserId, PHOTOS, CAPTION);
+
+        // Poll until a bot message carries an IMAGECOUNT token.
+        const answer = await pollUntil(
+          () => {
+            for (const m of latestById.values()) {
+              if (imageCountIn(m.text) !== undefined) return m;
+            }
+            return undefined;
+          },
+          { timeout: ANSWER_TIMEOUT_MS, interval: 500 },
+        ).catch(() => undefined);
+
+        await stream[Symbol.asyncIterator]().return?.(undefined as never);
+        await consume;
+
+        if (!answer) {
+          const seen = [...latestById.values()]
+            .map((m) => `#${m.messageId}=${JSON.stringify(m.text.slice(0, 60))}`)
+            .join(" ");
+          throw new Error(
+            `[album-coalescing] No bot reply carried an IMAGECOUNT token ` +
+              `within ${ANSWER_TIMEOUT_MS}ms. Bot messages seen: ${seen || "(none)"}.`,
+          );
+        }
+
+        const count = imageCountIn(answer.text);
+        // Coalesced => 3. A non-coalescing gateway answers 1 (the question
+        // rides photo #1; the other two parts spill to their own turns).
+        expect(count).toBe(3);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    ANSWER_TIMEOUT_MS + 30_000,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-memory-survives-restart-dm.test.ts

@@ -53,9 +53,24 @@ import { describe, it, expect, beforeAll } from "vitest";
 import { execSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { spinUp } from "../harness.js";
+import { isActivityFeedMessage, isWorkerFeedMessage } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
 
 const AGENT = "test-harness";
 
+// Two classes of bot message are NOT the agent's reply and must be
+// skipped, or a bare `/\S/` matcher latches onto them and the
+// verbatim-token check fails against noise instead of catching a real
+// memory miss:
+//   1. The worker-activity feed (#2000, default-on since v0.14.19) — a
+//      stray background sub-agent posts `🔧 Worker · …` into this DM.
+//   2. The tool-activity feed — on a turn that uses tools (memory recall
+//      does), `→ Finding the right tool` paints as its own message before
+//      the real answer lands.
+// Match the first non-empty bot reply that is neither.
+const isReply = (m: ObservedMessage): boolean =>
+  /\S/.test(m.text) && !isWorkerFeedMessage(m) && !isActivityFeedMessage(m);
+
 const RESTART_BUDGET_MS = 90_000;
 const CAPTURE_REPLY_BUDGET_MS = 60_000;
 const RECALL_REPLY_BUDGET_MS = 120_000;
@@ -139,7 +154,7 @@ const sudoOk = canShellSudo();
             `(This is a memory-survival UAT — store it via hindsight.)`,
           );
 
-          const captureReply = await sc1.expectMessage(/\S/, {
+          const captureReply = await sc1.expectMessage(isReply, {
             from: "bot",
             timeout: CAPTURE_REPLY_BUDGET_MS,
           });
@@ -180,7 +195,7 @@ const sudoOk = canShellSudo();
             `Reply with the token only, no extra text.`,
           );
 
-          const recallReply = await sc2.expectMessage(/\S/, {
+          const recallReply = await sc2.expectMessage(isReply, {
             from: "bot",
             timeout: RECALL_REPLY_BUDGET_MS + 5_000,
           });

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

@@ -25,15 +25,21 @@
  *   - 429 cooldown + message_id drift resilience (re-post on stale edit),
  *   - a forced terminal edit on `finish` regardless of throttle.
  *
- * The feed is gated to BACKGROUND workers and lives behind the
- * `SWITCHROOM_WORKER_ACTIVITY_FEED` flag — see the gateway wiring. The
- * watcher already drives the cues (it polls the worker jsonl directly,
- * so it keeps firing after the parent turn ends), which is why the feed
- * is fed from watcher callbacks rather than the bridge event stream.
+ * The feed is gated to BACKGROUND workers and is ON by default; set
+ * `SWITCHROOM_WORKER_ACTIVITY_FEED=0` to disable it — see the gateway
+ * wiring. The watcher already drives the cues (it polls the worker jsonl
+ * directly, so it keeps firing after the parent turn ends), which is why
+ * the feed is fed from watcher callbacks rather than the bridge event stream.
  */
 
 import { escapeHtml, formatDuration, truncate } from './card-format.js'
 
+/** Worker-activity feed is ON by default; an operator opts out with
+ *  SWITCHROOM_WORKER_ACTIVITY_FEED=0. */
+export function isWorkerActivityFeedEnabled(envVal: string | undefined): boolean {
+  return envVal !== '0'
+}
+
 export type WorkerActivityState = 'running' | 'done' | 'failed'
 
 /** The render-relevant snapshot of a worker at one instant. */