switchroom 0.17.6 → 0.18.3

package/telegram-plugin/uat/scenarios/jtbd-directive-capture-nudge-dm.test.ts

@@ -0,0 +1,185 @@
+/**
+ * JTBD scenario — a correction lands as a directive and survives `/reset`.
+ *
+ * Serves: `reference/jobs/remember-across-sessions.md` — the job's headline
+ * criterion is "a rule set once stays respected / a correction sticks."
+ *
+ * ## Why this exists (issue #2848 Stage B)
+ *
+ * Directive capture was guidance-only: the model is *told* to call
+ * `create_directive` on a durable correction, and a Stage A audit measured a
+ * **~55% miss rate** — the same broadcast correction captured by one agent,
+ * silently dropped by two others. Stage B adds a DETERMINISTIC regex nudge in
+ * the vendored recall hook (`vendor/hindsight-memory/scripts/recall.py`): on a
+ * correction-shaped inbound it appends a terse advisory telling the model to
+ * persist the rule with `create_directive` before answering. Detection is pure
+ * regex — the judgment happens IN the interactive session (claude-native
+ * invariant: no model callsite, no silent hook-side write).
+ *
+ * ## Contract this asserts
+ *
+ * 1. **Capture**: after a correction-shaped DM ("from now on, always end every
+ *    reply with <MARKER>"), an ACTIVE directive referencing the rule exists in
+ *    the agent's hindsight bank (queried via the REST API, the same surface
+ *    Stage A used).
+ * 2. **Survival across `/reset`**: after `/reset` clears the session, a fresh
+ *    neutral follow-up is still answered honoring the rule (the MARKER appears
+ *    in the reply) — proving the directive was re-injected from the bank, not
+ *    merely held in the wiped session context.
+ *
+ * ## Self-skip
+ *
+ * Self-skips GREEN when the mtcute driver isn't wired (no
+ * TELEGRAM_UAT_DRIVER_SESSION etc.), so it never reds an unwired host. The
+ * whole uat/** tree is excluded from gating CI regardless; run live with
+ * `bun run --cwd telegram-plugin test:uat jtbd-directive-capture-nudge-dm`.
+ */
+
+import { describe, it, expect } from "vitest";
+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";
+
+// Match the first non-empty bot reply that is neither the worker-activity
+// feed nor the tool-activity feed (same guard as jtbd-memory-survives).
+const isReply = (m: ObservedMessage): boolean =>
+  /\S/.test(m.text) && !isWorkerFeedMessage(m) && !isActivityFeedMessage(m);
+
+const CORRECTION_REPLY_BUDGET_MS = 60_000;
+const DIRECTIVE_SETTLE_MS = 12_000;
+const RESET_SETTLE_MS = 45_000;
+const POSTRESET_REPLY_BUDGET_MS = 120_000;
+
+// Unique per-run marker so directive-content matching and the honored-rule
+// check can't latch onto stale state from a prior run.
+const MARKER = `SR_UAT_DIRECTIVE_${randomBytes(6).toString("hex").toUpperCase()}`;
+
+// Hindsight REST base. Bank id == agent name (Stage A + CLAUDE.md). Override
+// via HINDSIGHT_UAT_API_URL if the host runs it elsewhere.
+const HINDSIGHT_BASE =
+  process.env.HINDSIGHT_UAT_API_URL ??
+  process.env.HINDSIGHT_API_URL ??
+  "http://127.0.0.1:18888";
+
+interface Directive {
+  content?: string;
+  name?: string;
+}
+
+async function fetchActiveDirectives(bank: string): Promise<Directive[]> {
+  const url = `${HINDSIGHT_BASE}/v1/default/banks/${encodeURIComponent(bank)}/directives?active_only=false`;
+  const res = await fetch(url, { signal: AbortSignal.timeout(8_000) });
+  if (!res.ok) {
+    throw new Error(`hindsight directives HTTP ${res.status} for bank ${bank} (${url})`);
+  }
+  const body = (await res.json()) as { items?: Directive[] };
+  return Array.isArray(body.items) ? body.items : [];
+}
+
+const uatWired = Boolean(
+  process.env.TELEGRAM_API_ID &&
+    process.env.TELEGRAM_API_HASH &&
+    process.env.TELEGRAM_UAT_DRIVER_SESSION &&
+    (process.env.TELEGRAM_TEST_BOT_USERNAME || false),
+);
+
+(uatWired ? describe : describe.skip)(
+  "uat: correction lands as a directive and survives /reset (remember-across-sessions JTBD)",
+  () => {
+    it(
+      "a standing-rule correction is persisted as a directive and honored after /reset",
+      async () => {
+        // --- Phase 1: give the agent a durable, correction-shaped rule ---
+        const sc1 = await spinUp({ agent: AGENT });
+        try {
+          await sc1.sendDM(
+            `From now on, always end every reply you send me with this exact ` +
+              `marker on its own final line: ${MARKER}. This is a standing ` +
+              `rule for how you should behave going forward — please persist ` +
+              `it so it sticks across sessions. Confirm you've noted it.`,
+          );
+
+          const reply = await sc1.expectMessage(isReply, {
+            from: "bot",
+            timeout: CORRECTION_REPLY_BUDGET_MS,
+          });
+          expect(reply.text.length).toBeGreaterThan(0);
+
+          // Give the in-turn create_directive call (nudged by the hook) time
+          // to land in the bank before we query it.
+          await new Promise((r) => setTimeout(r, DIRECTIVE_SETTLE_MS));
+
+          // --- Phase 2: CAPTURE — an active directive references the rule ---
+          const directives = await fetchActiveDirectives(AGENT);
+          const matched = directives.some((d) => {
+            const hay = `${d.content ?? ""} ${d.name ?? ""}`;
+            return (
+              hay.includes(MARKER) ||
+              /end (?:every|each|your) repl/i.test(hay) ||
+              /marker/i.test(hay)
+            );
+          });
+          if (!matched) {
+            throw new Error(
+              `[directive-capture] CONTRACT FAILED (capture): no active directive ` +
+                `references the standing rule. The correction was correction-shaped ` +
+                `(the recall hook should have nudged create_directive) but nothing ` +
+                `persisted. Directives seen: ` +
+                `${JSON.stringify(directives.map((d) => d.content ?? d.name).slice(0, 8))}`,
+            );
+          }
+          expect(matched).toBe(true);
+        } finally {
+          await sc1.tearDown();
+        }
+
+        // --- Phase 3: /reset clears the session ---
+        const scReset = await spinUp({ agent: AGENT });
+        try {
+          await scReset.sendDM("/reset");
+        } finally {
+          await scReset.tearDown();
+        }
+        // Let the reset complete + the bridge reattach before probing.
+        await new Promise((r) => setTimeout(r, RESET_SETTLE_MS));
+
+        // --- Phase 4: SURVIVAL — a fresh neutral turn still honors the rule ---
+        const sc2 = await spinUp({ agent: AGENT });
+        try {
+          await sc2.sendDM(
+            `What is 2 + 2? Answer normally — nothing special about this message.`,
+          );
+          const reply = await sc2.expectMessage(isReply, {
+            from: "bot",
+            timeout: POSTRESET_REPLY_BUDGET_MS,
+          });
+          expect(reply.text.length).toBeGreaterThan(0);
+
+          // The rule was NOT in this session's context (it was wiped by
+          // /reset). If the marker appears, the directive was re-injected from
+          // the bank on recall — the correction stuck.
+          const honored = reply.text.includes(MARKER);
+          if (!honored) {
+            throw new Error(
+              `[directive-capture] CONTRACT FAILED (survival): after /reset the ` +
+                `agent did not honor the standing rule — marker ${MARKER} absent ` +
+                `from the reply, so the directive did not survive/re-inject. Reply: ` +
+                `${JSON.stringify(reply.text.slice(0, 400))}`,
+            );
+          }
+          expect(honored).toBe(true);
+        } finally {
+          await sc2.tearDown();
+        }
+      },
+      CORRECTION_REPLY_BUDGET_MS +
+        DIRECTIVE_SETTLE_MS +
+        RESET_SETTLE_MS +
+        POSTRESET_REPLY_BUDGET_MS +
+        30_000,
+    );
+  },
+);

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