switchroom 0.17.6 → 0.17.10

package/telegram-plugin/uat/scenarios/jtbd-liveness-climb-channel.test.ts

@@ -0,0 +1,192 @@
+/**
+ * Deterministic-turn-liveness climb — CHANNEL twin of
+ * `jtbd-liveness-climb-dm.test.ts` (Phase 4a, `deterministic-turn-liveness.md`).
+ *
+ * Surface parity is a production-readiness bar for this job (job spec §
+ * Production-readiness: "every signal is proven in both DM and forum
+ * channel"). Phase 1's climb is keyed on the SAME `feedHeartbeatTick` /
+ * `runSilentTurnHeartbeatTick` path regardless of chat type — this scenario
+ * proves the card edits land, CLIMB, and stay ping-free in a supergroup too,
+ * not just a DM. It is brought to full parity with the DM twin: it parses the
+ * elapsed suffix, asserts non-decreasing climb, and HARD-FAILS on a frozen
+ * card (zero edits across a clearly-long silent tool) — the exact freeze this
+ * fix exists to detect. (Previously it only warned "INCONCLUSIVE" on a freeze,
+ * so it could never catch the regression it exists for.)
+ *
+ * Self-skips green when no test supergroup is wired (`SWITCHROOM_UAT_CHAT_ID`
+ * unset / unresolvable) — mirrors the existing channel-twin convention (see
+ * `jtbd-foreground-subagent-activity-channel.test.ts`).
+ *
+ * mtcute has no forum-topic API here, so this uses the General topic — same
+ * limitation as every other channel twin in this suite.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { isActivityFeedMessage, isFrameworkFallbackText } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+
+const MIN_CLIMB_EDITS = 4;
+const OVERALL_BUDGET_MS = 160_000;
+const SILENT_TOOL_SECONDS = 40;
+
+const SILENT_TOOL_PROMPT =
+  "Do exactly this and nothing else: run a single Bash command " +
+  `\`sleep ${SILENT_TOOL_SECONDS}\` and wait for it to finish. Do NOT narrate ` +
+  "anything before or during the sleep — no commentary, no other tool calls, " +
+  "no intermediate messages. Only after the sleep completes, reply with a " +
+  "one-line confirmation that you waited.";
+
+/** Parse the `Working · Ns` (or `· Nm Ss`) elapsed suffix out of a card body.
+ *  Returns null when the shape isn't present. Mirrors the DM twin. */
+function parseElapsedSeconds(text: string): number | null {
+  const m = text.match(/(?:^|\s)·\s*(?:(\d+)\s*m)?\s*(\d+)\s*s\b/i);
+  if (!m) return null;
+  const minutes = m[1] ? Number.parseInt(m[1], 10) : 0;
+  const seconds = Number.parseInt(m[2], 10);
+  return minutes * 60 + seconds;
+}
+
+describe("uat: deterministic turn liveness — silent-tool card climb (channel parity)", () => {
+  it(
+    "climbs the activity card in a supergroup ≥4 times with non-decreasing elapsed, no mid-turn ping",
+    async () => {
+      if (!Number.isFinite(SUPERGROUP_ID)) {
+        console.warn("[liveness-climb-channel] SWITCHROOM_UAT_CHAT_ID unset — skipping");
+        return;
+      }
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        await sc.driver.primeDialogs();
+        if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+          console.warn(`[liveness-climb-channel] supergroup ${SUPERGROUP_ID} not resolvable — skipping`);
+          return;
+        }
+
+        const iter = sc.driver
+          .observeMessages(SUPERGROUP_ID)
+          [Symbol.asyncIterator]();
+
+        await sc.driver.sendText(SUPERGROUP_ID, SILENT_TOOL_PROMPT);
+        const sentAt = Date.now();
+        console.log("[liveness-climb-channel] prompt sent; watching card edits…");
+
+        let cardMessageId: number | null = null;
+        const elapsedSamples: number[] = [];
+        let cardEditCount = 0;
+        let answer: ObservedMessage | null = null;
+        let otherLoudMessage: ObservedMessage | null = null;
+
+        const deadline = Date.now() + 110_000;
+        while (Date.now() < deadline) {
+          if (answer && cardEditCount >= MIN_CLIMB_EDITS) break;
+          const remaining = deadline - Date.now();
+          const next = await Promise.race([
+            iter.next(),
+            new Promise<{ done: true; value: undefined }>((r) =>
+              setTimeout(() => r({ done: true, value: undefined }), Math.max(0, remaining)),
+            ),
+          ]);
+          if (next.done || next.value == null) break;
+          const m = next.value as ObservedMessage;
+          if (m.senderUserId === sc.driverUserId) continue;
+
+          if (isActivityFeedMessage(m)) {
+            if (cardMessageId == null) cardMessageId = m.messageId;
+            if (m.messageId === cardMessageId && m.edited) {
+              cardEditCount++;
+              const secs = parseElapsedSeconds(m.text);
+              if (secs != null) elapsedSamples.push(secs);
+              console.log(
+                `[liveness-climb-channel] card edit #${cardEditCount} at +${Date.now() - sentAt}ms: ` +
+                  JSON.stringify(m.text.slice(0, 100)),
+              );
+            }
+            if (m.edited && m.silent === false) otherLoudMessage = otherLoudMessage ?? m;
+            continue;
+          }
+
+          if (m.edited) continue;
+          // A framework fallback TEXT send is a mid-turn erosion, not the
+          // completion proof — reject it from the answer lane (see DM twin).
+          if (isFrameworkFallbackText(m.text)) {
+            otherLoudMessage = otherLoudMessage ?? m;
+            continue;
+          }
+          if (!answer && m.text.trim().length > 0) {
+            answer = m;
+            console.log(`[liveness-climb-channel] answer at +${Date.now() - sentAt}ms.`);
+            continue;
+          }
+          if (m.silent === false) otherLoudMessage = otherLoudMessage ?? m;
+        }
+        await iter.return?.();
+
+        // No mid-turn erosion: the climb is edit-only in a supergroup too.
+        expect(
+          otherLoudMessage,
+          `a mid-turn message eroded the ping-free/edit-only guarantee in the ` +
+            `supergroup (loud ping or framework fallback text): ` +
+            JSON.stringify(otherLoudMessage?.text?.slice(0, 120)),
+        ).toBeNull();
+
+        if (cardEditCount === 0 && cardMessageId == null) {
+          console.warn(
+            "[liveness-climb-channel] INCONCLUSIVE — no activity card observed at all " +
+              "(the model may have narrated, or the turn completed too fast).",
+          );
+          expect(answer, "even in the inconclusive branch the turn must complete").not.toBeNull();
+          return;
+        }
+
+        if (cardEditCount > 0 && cardEditCount < MIN_CLIMB_EDITS) {
+          console.warn(
+            `[liveness-climb-channel] INCONCLUSIVE — card edited ${cardEditCount} time(s), ` +
+              `below the ${MIN_CLIMB_EDITS} target (model may have narrated a tool label ` +
+              "partway through, handing to the labelled-feed heartbeat).",
+          );
+        } else {
+          expect(
+            cardEditCount,
+            `HARD FAIL — the silent tool ran ~${SILENT_TOOL_SECONDS}s in a supergroup but the ` +
+              `activity card edited only ${cardEditCount} time(s) (< ${MIN_CLIMB_EDITS}). This is ` +
+              "the pre-Phase-1 freeze regression, in the channel surface.",
+          ).toBeGreaterThanOrEqual(MIN_CLIMB_EDITS);
+        }
+
+        // Climbing property: elapsed samples must be non-decreasing…
+        for (let i = 1; i < elapsedSamples.length; i++) {
+          expect(
+            elapsedSamples[i],
+            `elapsed suffix went backwards/froze across edits: ${JSON.stringify(elapsedSamples)}`,
+          ).toBeGreaterThanOrEqual(elapsedSamples[i - 1]);
+        }
+        // …and must actually climb across the full window (frozen == the freeze
+        // this fix closes; backs the job-spec Prove-it claim).
+        if (elapsedSamples.length >= MIN_CLIMB_EDITS) {
+          expect(
+            elapsedSamples[elapsedSamples.length - 1],
+            `HARD FAIL — the elapsed suffix never advanced across ${elapsedSamples.length} ` +
+              `card edits in the supergroup (frozen at ${JSON.stringify(elapsedSamples)}).`,
+          ).toBeGreaterThan(elapsedSamples[0]);
+        }
+
+        // Completion proof: an ANSWER (not the card itself) resumes in the same
+        // chat. Guarding on `!isActivityFeedMessage` stops the old
+        // `expectMessage(SUPERGROUP_ID, /\S/)` from matching a card edit and
+        // declaring the turn done while the agent was still climbing.
+        expect(
+          answer,
+          "FAIL — no answer (distinct from the activity card) arrived within budget; the turn may be wedged.",
+        ).not.toBeNull();
+        expect(answer?.chatId).toBe(SUPERGROUP_ID);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    OVERALL_BUDGET_MS,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-liveness-climb-dm.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Deterministic-turn-liveness climb — DM (Phase 4a, `deterministic-turn-liveness.md`).
+ *
+ * The RFC's keystone (Phase 1) gives a busy-but-silent foreground turn a
+ * climbing activity card instead of the pre-#2143/#2527/#2667 freeze: once
+ * the card is open and no tool emits a label, `feedHeartbeatTick`'s 0-label
+ * branch re-renders the SAME message with a fresh `Working · Ns` elapsed
+ * every `FEED_HEARTBEAT_MIN_STALE_MS` (~6s), edit-only (no device buzz).
+ *
+ * IMPORTANT product fact this scenario respects: switchroom has NO streaming
+ * REPLY path — the final answer is sent whole (chunked over the char cap if
+ * needed). The card observed here is the activity/liveness card — a distinct,
+ * pre-existing card-edit surface (worker-activity-feed / liveness card), not
+ * a streamed reply. This scenario never asserts a streamed reply edit.
+ *
+ * ## Trigger
+ *
+ * A single `Bash` call that sleeps ~40s with no intermediate narration and no
+ * tool label — the exact "silent tool" shape the Phase-1 climb exists for.
+ *
+ * ## What it asserts (asymmetric — timing on a live model is not fully
+ * forceable)
+ *
+ *   PASS      — the SAME activity-card message is edited (non-initial
+ *               renders, i.e. `edited === true` on repeat observations of the
+ *               same `messageId`) at least `MIN_CLIMB_EDITS` (4) times across
+ *               the ~40s window, and the elapsed suffix parsed out of the
+ *               body is monotonically non-decreasing across those edits
+ *               (the "climbing" property — hard-fails on a frozen/repeated
+ *               elapsed value across all edits, which reproduces the pre-
+ *               Phase-1 freeze).
+ *   PASS      — no bot message OTHER than the one activity-card message id
+ *               appears during the silent window (no mid-turn notification
+ *               ping; the climb is edit-only, per Phase 1 + the job spec's
+ *               "no device buzz" bad-list item).
+ *   INCONCLUSIVE — the model narrated anyway (a tool label / narrative text
+ *               landed), so the 0-label silent-tool path was not exercised.
+ *               Warn + pass — not a regression of this fix.
+ *   FAIL      — no answer at all within budget (wedged), or a mid-turn ping
+ *               is observed (silent === false on a non-final message).
+ *   HARD FAIL — the turn ran clearly longer than the climb bound with fewer
+ *               than `MIN_CLIMB_EDITS` edits on the card and no narration —
+ *               the exact freeze this fix exists to close.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { isActivityFeedMessage, isFrameworkFallbackText } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
+
+const MIN_CLIMB_EDITS = 4;
+const OVERALL_BUDGET_MS = 140_000;
+const SILENT_TOOL_SECONDS = 40;
+
+const SILENT_TOOL_PROMPT =
+  "Do exactly this and nothing else: run a single Bash command " +
+  `\`sleep ${SILENT_TOOL_SECONDS}\` and wait for it to finish. Do NOT narrate ` +
+  "anything before or during the sleep — no commentary, no other tool calls, " +
+  "no intermediate messages. Only after the sleep completes, reply with a " +
+  "one-line confirmation that you waited.";
+
+/** Parse the `Working · Ns` (or `· Nm Ss`) elapsed suffix out of a card body.
+ *  Returns null when the shape isn't present (e.g. a labelled feed). */
+function parseElapsedSeconds(text: string): number | null {
+  const m = text.match(/(?:^|\s)·\s*(?:(\d+)\s*m)?\s*(\d+)\s*s\b/i);
+  if (!m) return null;
+  const minutes = m[1] ? Number.parseInt(m[1], 10) : 0;
+  const seconds = Number.parseInt(m[2], 10);
+  return minutes * 60 + seconds;
+}
+
+describe("uat: deterministic turn liveness — silent-tool card climb (DM)", () => {
+  it(
+    "climbs the SAME activity card ≥4 times with non-decreasing elapsed, no mid-turn ping",
+    async () => {
+      const sc = await spinUp({ agent: "test-harness" });
+      try {
+        const iter = sc.driver
+          .observeMessages(sc.botUserId)
+          [Symbol.asyncIterator]();
+
+        await sc.sendDM(SILENT_TOOL_PROMPT);
+        const sentAt = Date.now();
+        console.log("[liveness-climb-dm] prompt sent; watching card edits…");
+
+        let cardMessageId: number | null = null;
+        const elapsedSamples: number[] = [];
+        let cardEditCount = 0;
+        let answer: ObservedMessage | null = null;
+        let otherLoudMessage: ObservedMessage | null = null;
+
+        const deadline = Date.now() + 100_000;
+        while (Date.now() < deadline) {
+          if (answer && cardEditCount >= MIN_CLIMB_EDITS) break;
+          const remaining = deadline - Date.now();
+          const next = await Promise.race([
+            iter.next(),
+            new Promise<{ done: true; value: undefined }>((r) =>
+              setTimeout(() => r({ done: true, value: undefined }), Math.max(0, remaining)),
+            ),
+          ]);
+          if (next.done || next.value == null) break;
+          const m = next.value as ObservedMessage;
+          if (m.senderUserId === sc.driverUserId) continue;
+
+          if (isActivityFeedMessage(m)) {
+            if (cardMessageId == null) cardMessageId = m.messageId;
+            if (m.messageId === cardMessageId && m.edited) {
+              cardEditCount++;
+              const secs = parseElapsedSeconds(m.text);
+              if (secs != null) elapsedSamples.push(secs);
+              console.log(
+                `[liveness-climb-dm] card edit #${cardEditCount} at +${Date.now() - sentAt}ms: ` +
+                  JSON.stringify(m.text.slice(0, 100)),
+              );
+            }
+            // A non-silent card edit would still be a ping; card edits are
+            // asserted separately below via `silent`.
+            if (m.edited && m.silent === false) {
+              otherLoudMessage = otherLoudMessage ?? m;
+            }
+            continue;
+          }
+
+          if (m.edited) continue;
+          // Attributable-answer gate: a framework mid-turn/dark-turn fallback
+          // TEXT send (the exact #2667 erosion this wall guards against — a
+          // re-added "still working…" ping) must NOT be swallowed as the
+          // turn's answer. Classify it as a mid-turn erosion regardless of its
+          // silent flag, so the first loud mid-turn message trips the
+          // assertion instead of masquerading as the reply.
+          if (isFrameworkFallbackText(m.text)) {
+            otherLoudMessage = otherLoudMessage ?? m;
+            console.log(
+              `[liveness-climb-dm] framework fallback text mid-turn at +${Date.now() - sentAt}ms: ` +
+                JSON.stringify(m.text.slice(0, 120)),
+            );
+            continue;
+          }
+          if (!answer && m.text.trim().length > 0) {
+            answer = m;
+            console.log(`[liveness-climb-dm] answer at +${Date.now() - sentAt}ms.`);
+            continue;
+          }
+          // Any OTHER non-edit bot message during the window is a candidate
+          // mid-turn ping — track it for the loud-message assertion below.
+          if (m.silent === false) {
+            otherLoudMessage = otherLoudMessage ?? m;
+          }
+        }
+        await iter.return?.();
+
+        // No mid-turn erosion: neither a device-buzzing ping (silent=false on
+        // a non-final message) NOR a framework fallback TEXT send (a
+        // "still working…"-class mid-turn message — the climb is an edit-only
+        // card, never a text send).
+        expect(
+          otherLoudMessage,
+          `a mid-turn message eroded the ping-free/edit-only guarantee ` +
+            `(loud ping or framework fallback text): ` +
+            JSON.stringify(otherLoudMessage?.text?.slice(0, 120)),
+        ).toBeNull();
+
+        if (cardEditCount === 0 && cardMessageId == null) {
+          console.warn(
+            "[liveness-climb-dm] INCONCLUSIVE — no activity card observed at all " +
+              "(the model may have narrated before/instead of the silent sleep, " +
+              "or the turn completed too fast). Not a regression of this fix.",
+          );
+          expect(answer, "even in the inconclusive branch the turn must complete").not.toBeNull();
+          return;
+        }
+
+        if (cardEditCount > 0 && cardEditCount < MIN_CLIMB_EDITS) {
+          console.warn(
+            `[liveness-climb-dm] INCONCLUSIVE — card edited ${cardEditCount} time(s), ` +
+              `below the ${MIN_CLIMB_EDITS} target (model may have narrated a tool ` +
+              "label partway through, handing off to the labelled-feed heartbeat " +
+              "with a different cadence). Not a hard failure.",
+          );
+        } else {
+          expect(
+            cardEditCount,
+            `HARD FAIL — the silent tool ran ~${SILENT_TOOL_SECONDS}s but the activity ` +
+              `card edited only ${cardEditCount} time(s) (< ${MIN_CLIMB_EDITS}). This is ` +
+              "the pre-Phase-1 freeze regression (#2143/#2527/#2667 archaeology in " +
+              "reference/rfcs/deterministic-turn-liveness.md).",
+          ).toBeGreaterThanOrEqual(MIN_CLIMB_EDITS);
+        }
+
+        // Climbing property: elapsed samples must be non-decreasing (never
+        // rewinds across edits of the same card)…
+        for (let i = 1; i < elapsedSamples.length; i++) {
+          expect(
+            elapsedSamples[i],
+            `elapsed suffix went backwards/froze across edits: ${JSON.stringify(elapsedSamples)}`,
+          ).toBeGreaterThanOrEqual(elapsedSamples[i - 1]);
+        }
+        // …and, when we have the full climb (≥MIN_CLIMB_EDITS parsed samples),
+        // it must actually CLIMB — a frozen/repeated elapsed value across all
+        // edits is the exact pre-Phase-1 freeze and a hard failure (this backs
+        // the job-spec Prove-it claim; non-decreasing alone would pass a
+        // frozen card).
+        if (elapsedSamples.length >= MIN_CLIMB_EDITS) {
+          expect(
+            elapsedSamples[elapsedSamples.length - 1],
+            `HARD FAIL — the elapsed suffix never advanced across ${elapsedSamples.length} ` +
+              `card edits (frozen at ${JSON.stringify(elapsedSamples)}). A repeated elapsed ` +
+              "value across all edits is the pre-Phase-1 freeze this fix closes.",
+          ).toBeGreaterThan(elapsedSamples[0]);
+        }
+
+        expect(answer, "FAIL — no answer arrived within budget; the turn may be wedged.").not.toBeNull();
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    OVERALL_BUDGET_MS,
+  );
+});

package/telegram-plugin/uat/scenarios/jtbd-liveness-narration-channel.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Narrated mid-turn work still shows words on the card — CHANNEL twin of
+ * `jtbd-liveness-narration-dm.test.ts` (Phase 4a, `deterministic-turn-liveness.md`).
+ *
+ * Surface parity bar per the job spec. Like the DM twin (and unlike the
+ * previous version of this file), it also asserts the no-mid-turn-ping
+ * invariant inline — the RFC and job spec claim the ping-free assertion is
+ * baked into EVERY liveness scenario, DM and channel alike. Self-skips green
+ * when no test supergroup is wired.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { isActivityFeedMessage, isFrameworkFallbackText } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
+
+const AGENT = "test-harness";
+const SUPERGROUP_ID = Number.parseInt(process.env.SWITCHROOM_UAT_CHAT_ID ?? "", 10);
+const OVERALL_BUDGET_MS = 150_000;
+
+const NARRATED_WORK_PROMPT =
+  "Do four short steps, ONE AT A TIME. Before EACH step, write a brief " +
+  'one-sentence narration of what you are about to do (e.g. "Checking the ' +
+  'hostname now.") — this is not a reply, just your normal narration — then ' +
+  "run the step via Bash (`sleep 3` is fine as the step body). After all " +
+  "four steps, send a one-line final summary reply.";
+
+/** Body (narration/tool) lines of a card, minus header + climb placeholder.
+ *  Mirrors the DM twin's `narratedBodyLines`. */
+function narratedBodyLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0)
+    .map((l) => l.replace(/^[→✓↳]+\s*/u, "").trim())
+    .filter(
+      (l) =>
+        l.length > 0 &&
+        !/^(?:🤖|🛠[️]?|⚙[️]?)\s/u.test(l) &&
+        !/^(?:(?:\d+m)?\d+s\s*·\s*\d+\s+tools?|(?:done|failed)\s*·)/iu.test(l) &&
+        !/^Working(?:\s*[·…]|$)/i.test(l) &&
+        !/^\+?\d+\s+earlier/i.test(l),
+    );
+}
+
+describe("uat: deterministic turn liveness — narration lands mid-turn (channel parity)", () => {
+  it(
+    "the model's own words appear on the activity card mid-turn in a supergroup, with no mid-turn ping",
+    async () => {
+      if (!Number.isFinite(SUPERGROUP_ID)) {
+        console.warn("[liveness-narration-channel] SWITCHROOM_UAT_CHAT_ID unset — skipping");
+        return;
+      }
+      const sc = await spinUp({ agent: AGENT, settleMs: 0 });
+      try {
+        await sc.driver.primeDialogs();
+        if (!(await sc.driver.canResolve(SUPERGROUP_ID))) {
+          console.warn(`[liveness-narration-channel] supergroup ${SUPERGROUP_ID} not resolvable — skipping`);
+          return;
+        }
+
+        const iter = sc.driver
+          .observeMessages(SUPERGROUP_ID)
+          [Symbol.asyncIterator]();
+
+        await sc.driver.sendText(SUPERGROUP_ID, NARRATED_WORK_PROMPT);
+        const sentAt = Date.now();
+
+        const narrationSamples: string[] = [];
+        let answer: ObservedMessage | null = null;
+        let otherLoudMessage: ObservedMessage | null = null;
+
+        const deadline = Date.now() + 100_000;
+        while (Date.now() < deadline) {
+          if (answer) break;
+          const remaining = deadline - Date.now();
+          const next = await Promise.race([
+            iter.next(),
+            new Promise<{ done: true; value: undefined }>((r) =>
+              setTimeout(() => r({ done: true, value: undefined }), Math.max(0, remaining)),
+            ),
+          ]);
+          if (next.done || next.value == null) break;
+          const m = next.value as ObservedMessage;
+          if (m.senderUserId === sc.driverUserId) continue;
+
+          if (isActivityFeedMessage(m)) {
+            const narrated = narratedBodyLines(m.text);
+            if (narrated.length > 0) {
+              narrationSamples.push(narrated.join(" | "));
+              console.log(
+                `[liveness-narration-channel] narrated card content at +${Date.now() - sentAt}ms: ` +
+                  JSON.stringify(narrated.join(" | ").slice(0, 140)),
+              );
+            }
+            if (m.edited && m.silent === false) otherLoudMessage = otherLoudMessage ?? m;
+            continue;
+          }
+          if (m.edited) continue;
+          if (isFrameworkFallbackText(m.text)) {
+            otherLoudMessage = otherLoudMessage ?? m;
+            continue;
+          }
+          if (!answer && m.text.trim().length > 0) {
+            answer = m;
+            continue;
+          }
+          if (m.silent === false) otherLoudMessage = otherLoudMessage ?? m;
+        }
+        await iter.return?.();
+
+        // No-mid-turn-ping invariant, inline in the channel twin too.
+        expect(
+          otherLoudMessage,
+          `a mid-turn message eroded the ping-free/edit-only guarantee in the supergroup: ` +
+            JSON.stringify(otherLoudMessage?.text?.slice(0, 120)),
+        ).toBeNull();
+
+        if (narrationSamples.length === 0) {
+          console.warn(
+            "[liveness-narration-channel] INCONCLUSIVE — no narrated content observed on the " +
+              "card (model may have batched steps or the turn was too fast).",
+          );
+        }
+
+        expect(
+          answer,
+          "FAIL — no answer (distinct from the activity card) arrived within budget; the turn may be wedged.",
+        ).not.toBeNull();
+        expect(answer?.chatId).toBe(SUPERGROUP_ID);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    OVERALL_BUDGET_MS,
+  );
+});