switchroom 0.17.6 → 0.18.3

package/telegram-plugin/tests/worktree-watch-cwds.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Ownership predicate for the worktree-isolated cwds the subagent-watcher
+ * additionally watches (deterministic-turn-liveness.md Known Gap 2 / #2893
+ * review fix). Pins the fail-CLOSED behaviour: the review found the closure
+ * both FAILED OPEN (unset identity matched every ownerless record — the #1116
+ * leak reintroduced) and FAILED CLOSED (a plain `worktree claim` produced an
+ * ownerless record filtered out, so the sub-agent stayed invisible — Gap 2).
+ *
+ * Run with:
+ *   bun test telegram-plugin/tests/worktree-watch-cwds.test.ts
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  ownedWorktreeCwds,
+  __resetIdentityEscalationForTests,
+  type WorktreeOwnershipRecord,
+} from "../worktree-watch-cwds.js";
+
+const idPath = (p: string) => p; // identity realpath for deterministic tests
+
+beforeEach(() => __resetIdentityEscalationForTests());
+
+describe("ownedWorktreeCwds", () => {
+  const records: WorktreeOwnershipRecord[] = [
+    { path: "/wt/mine-1", ownerAgent: "klanker" },
+    { path: "/wt/mine-2", ownerAgent: "klanker" },
+    { path: "/wt/theirs", ownerAgent: "reggie" },
+    { path: "/wt/ownerless" }, // ownerAgent undefined
+  ];
+
+  it("returns NOTHING when the agent identity is unset and no durable fallback given (fail-closed, no #1116 leak)", () => {
+    expect(
+      ownedWorktreeCwds({ self: undefined, listRecords: () => records, realpath: idPath }),
+    ).toEqual([]);
+  });
+
+  it("returns NOTHING when the agent identity is empty string and no durable fallback given", () => {
+    expect(
+      ownedWorktreeCwds({ self: "", listRecords: () => records, realpath: idPath }),
+    ).toEqual([]);
+  });
+
+  // ---- Layer 2: durable, non-env identity fallback (#1116 / #2893) ----
+
+  it("(a) env SET → ownership resolves exactly as before (fast path unchanged)", () => {
+    expect(
+      ownedWorktreeCwds({
+        self: "klanker",
+        agentDir: "/home/x/.switchroom/agents/SHOULD_BE_IGNORED",
+        listRecords: () => records,
+        realpath: idPath,
+      }),
+    ).toEqual(["/wt/mine-1", "/wt/mine-2"]);
+  });
+
+  it("(b) env UNSET but agentDir present → identity derived from dir basename, ownership resolves", () => {
+    const out = ownedWorktreeCwds({
+      self: undefined,
+      agentDir: "/home/x/.switchroom/agents/klanker",
+      listRecords: () => records,
+      realpath: idPath,
+    });
+    expect(out).toEqual(["/wt/mine-1", "/wt/mine-2"]);
+  });
+
+  it("(b) env EMPTY but agentDir present → same durable derivation", () => {
+    const out = ownedWorktreeCwds({
+      self: "",
+      agentDir: "/home/x/.switchroom/agents/klanker",
+      listRecords: () => records,
+      realpath: idPath,
+    });
+    expect(out).toEqual(["/wt/mine-1", "/wt/mine-2"]);
+  });
+
+  it("(b) durable fallback NEVER mis-attributes: a dir for a different agent matches only THAT agent's records, never klanker's", () => {
+    // agentDir names 'reggie' → resolves reggie's worktrees, never klanker's
+    // or the ownerless ones. A wrong basename fails-closed to [], it can never
+    // attribute to the WRONG owner.
+    const out = ownedWorktreeCwds({
+      self: undefined,
+      agentDir: "/home/x/.switchroom/agents/reggie",
+      listRecords: () => records,
+      realpath: idPath,
+    });
+    expect(out).toEqual(["/wt/theirs"]);
+    expect(out).not.toContain("/wt/ownerless");
+  });
+
+  it("(c) BOTH env and agentDir unavailable → returns [] AND emits an escalated ERROR (no throw, no mis-attribution)", () => {
+    const logs: string[] = [];
+    const out = ownedWorktreeCwds({
+      self: undefined,
+      agentDir: undefined,
+      listRecords: () => records,
+      realpath: idPath,
+      log: (m) => logs.push(m),
+    });
+    expect(out).toEqual([]);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain("ERROR");
+    expect(logs[0]).toContain("identity resolution FAILED");
+  });
+
+  it("(c) blank agentDir (whitespace) is treated as unavailable → [] + escalated error", () => {
+    const logs: string[] = [];
+    const out = ownedWorktreeCwds({
+      self: "",
+      agentDir: "   ",
+      listRecords: () => records,
+      realpath: idPath,
+      log: (m) => logs.push(m),
+    });
+    expect(out).toEqual([]);
+    expect(logs).toHaveLength(1);
+    expect(logs[0]).toContain("identity resolution FAILED");
+  });
+
+  it("(c) the escalated error is one-shot per process (not re-logged every rescan tick)", () => {
+    const logs: string[] = [];
+    const call = () =>
+      ownedWorktreeCwds({
+        self: undefined,
+        agentDir: undefined,
+        listRecords: () => records,
+        realpath: idPath,
+        log: (m) => logs.push(m),
+      });
+    call();
+    call();
+    call();
+    expect(logs).toHaveLength(1);
+  });
+
+  it("does NOT match ownerless records even when identity is set", () => {
+    const out = ownedWorktreeCwds({ self: "klanker", listRecords: () => records, realpath: idPath });
+    expect(out).not.toContain("/wt/ownerless");
+    expect(out).not.toContain("/wt/theirs");
+  });
+
+  it("includes exactly the records this agent owns", () => {
+    expect(
+      ownedWorktreeCwds({ self: "klanker", listRecords: () => records, realpath: idPath }),
+    ).toEqual(["/wt/mine-1", "/wt/mine-2"]);
+  });
+
+  it("returns [] when the registry read throws (best-effort; base watch undisturbed)", () => {
+    expect(
+      ownedWorktreeCwds({
+        self: "klanker",
+        listRecords: () => {
+          throw new Error("registry unavailable");
+        },
+        realpath: idPath,
+      }),
+    ).toEqual([]);
+  });
+
+  it("realpaths owned paths (symlinked-base slug fix), falling back on failure", () => {
+    const out = ownedWorktreeCwds({
+      self: "klanker",
+      listRecords: () => [
+        { path: "/tmp/mine", ownerAgent: "klanker" },
+        { path: "/gone/mine", ownerAgent: "klanker" },
+      ],
+      realpath: (p) => {
+        if (p === "/tmp/mine") return "/private/tmp/mine";
+        throw new Error("ENOENT");
+      },
+    });
+    expect(out).toEqual(["/private/tmp/mine", "/gone/mine"]);
+  });
+
+  it("two-tick mutation: a fresh claim/release is picked up without restart", () => {
+    // The provider is re-invoked every rescan tick, so a mutating registry
+    // (claim adds an owned record; release removes it) must be reflected
+    // tick-over-tick with no process restart.
+    let live: WorktreeOwnershipRecord[] = [{ path: "/wt/a", ownerAgent: "klanker" }];
+    const provider = () =>
+      ownedWorktreeCwds({ self: "klanker", listRecords: () => live, realpath: idPath });
+
+    // Tick 1: one owned worktree.
+    expect(provider()).toEqual(["/wt/a"]);
+
+    // Claim a second (as the ambient owner would default via SWITCHROOM_AGENT_NAME).
+    live = [
+      { path: "/wt/a", ownerAgent: "klanker" },
+      { path: "/wt/b", ownerAgent: "klanker" },
+    ];
+    // Tick 2: both picked up, no restart.
+    expect(provider()).toEqual(["/wt/a", "/wt/b"]);
+
+    // Release the first.
+    live = [{ path: "/wt/b", ownerAgent: "klanker" }];
+    // Tick 3: reflects the release.
+    expect(provider()).toEqual(["/wt/b"]);
+  });
+});

package/telegram-plugin/turn-liveness-floor.ts

@@ -227,13 +227,47 @@ export interface PostAnswerLivenessInput {
   now: number
   /** Staleness cap in ms; `<= 0` disables the cap. */
   staleCapMs: number
+  /**
+   * A POSITIVE, independent signal that a sub-agent dispatch is still known to
+   * be outstanding (e.g. `turn.foregroundSubAgents.size > 0` — a foreground
+   * `Task`/`Agent` this turn dispatched and has not yet reported finished).
+   *
+   * ## The gap this closes
+   *
+   * The staleness cap above was built to stop the card climbing FOREVER once
+   * a worker's `onFinish` froze `subagentActivityAt` and nothing further would
+   * ever arrive — but the ONLY signal it read (`now - subagentActivityAt`) is
+   * identical whether the worker (a) actually finished, or (b) is still
+   * genuinely running a SINGLE long silent step (one long Bash call, a slow
+   * fetch) that simply hasn't produced a NEW distinguishable watcher tick.
+   * Case (b) is exactly the scenario `feed-heartbeat-climb.ts`'s 0-label climb
+   * and `worker-activity-feed.ts`'s own heartbeat both exist to handle
+   * deterministically elsewhere — this post-answer branch alone lacked that
+   * fallback, so it froze the card mid-delegation (the confirmed operator
+   * symptom: "Running a command" stuck for 41s / 3m12s while a sub-agent ran
+   * underneath).
+   *
+   * When `stillDispatched` is `true` we have POSITIVE evidence the worker has
+   * not reported completion, so the staleness cap is bypassed entirely and the
+   * verdict stays `'emit'` — the caller keeps climbing the card deterministically
+   * off wall-clock elapsed exactly like the sibling 0-label/worker-feed paths.
+   * When `false` (no such tracking available — e.g. a purely-background worker
+   * with no foreground registration), the ORIGINAL cap behaviour is preserved
+   * unchanged, so the runaway-climb-after-completion protection this cap was
+   * built for still applies wherever we have no better signal.
+   */
+  stillDispatched: boolean
 }
 
 export function evaluatePostAnswerLiveness(input: PostAnswerLivenessInput): PostAnswerLivenessVerdict {
-  const { subagentActivityAt, finalAnswerDeliveredAt, now, staleCapMs } = input
+  const { subagentActivityAt, finalAnswerDeliveredAt, now, staleCapMs, stillDispatched } = input
   const answeredAt = finalAnswerDeliveredAt ?? 0
   // idle-gap: nothing surfaced after the answer → silent (reply-is-last preserved).
   if (subagentActivityAt == null || subagentActivityAt <= answeredAt) return 'idle'
+  // A positive "still dispatched" signal overrides the staleness cap — we KNOW
+  // the worker hasn't reported done, so a quiet stretch is a long silent step,
+  // not completion. Never freeze the card while that's true.
+  if (stillDispatched) return 'emit'
   // staleness cap: the worker's last advance is older than the cap → stop emitting.
   if (staleCapMs > 0 && now - subagentActivityAt >= staleCapMs) return 'stale'
   return 'emit'

package/telegram-plugin/uat/assertions.ts

@@ -46,16 +46,80 @@ export function isWorkerFeedMessage(m: ObservedMessage): boolean {
  */
 const ACTIVITY_FEED_LINE_RE = /^[→✓]\s/u;
 
+/**
+ * A body line of the activity card: an in-progress `→`, a done `✓`, a nested
+ * child `↳`, or the rolling `✓ +N earlier…` / `↳ +N earlier…` overflow
+ * headers (both covered by the leading glyph). Distinct from
+ * {@link ACTIVITY_FEED_LINE_RE} in that it does NOT require the trailing space
+ * — `↳→ …` nested-in-progress lines render glyph-adjacent.
+ */
+const ACTIVITY_BODY_LINE_RE = /^[→✓↳]/u;
+
+/**
+ * The two-line header `renderActivityHeader`
+ * (telegram-plugin/tool-activity-summary.ts) prepends to the session
+ * activity / liveness card — the shape the pure-arrow
+ * {@link ACTIVITY_FEED_LINE_RE} predicate could never match, which is why the
+ * Phase-1 climb card (`silentTurnClimbRender`) was mis-classified as the
+ * answer and the whole climb test wall passed vacuously
+ * (`deterministic-turn-liveness.md` Phase 4a). Telegram strips the bold/italic
+ * entities, so the OBSERVED lines are:
+ *
+ *   line 1: `<emoji> <label>`            e.g. `🤖 Agent`   (optionally ` · <description>`)
+ *   line 2 running: `<elapsed> · <N> tool(s)`              e.g. `12s · 0 tools`, `2m05s · 3 tools`
+ *   line 2 done:    `<state> · <N> tools · <elapsed>`       e.g. `done · 3 tools · 41s`
+ *
+ * Elapsed is `formatFeedElapsed`: `<N>s` under a minute, else `<M>m<SS>s`.
+ */
+const LIVENESS_HEADER_L1_RE = /^(?:🤖|🛠[️]?|⚙[️]?)\s+\S/u;
+const LIVENESS_ELAPSED = String.raw`(?:\d+m)?\d+s`;
+const LIVENESS_HEADER_L2_RE = new RegExp(
+  `^(?:${LIVENESS_ELAPSED}\\s*·\\s*\\d+\\s+tools?` +
+    `|(?:done|failed)\\s*·\\s*\\d+\\s+tools?\\s*·\\s*${LIVENESS_ELAPSED})$`,
+  "iu",
+);
+
+/**
+ * True when `m` is the session activity / liveness card that carries the
+ * two-line `renderActivityHeader` (emoji + label, then the climbing
+ * `<elapsed> · <N> tools` status), followed only by `→`/`✓`/`↳` body lines.
+ *
+ * This is the card the Phase-1 climb (`feed-heartbeat-climb.ts`) and every
+ * headered activity feed render. The predicate stays strict — it requires
+ * BOTH header lines to match their exact shape — so a real reply that merely
+ * opens with an emoji or contains an arrow is never misclassified (the same
+ * documented reason the pure-arrow predicate demands every line be an activity
+ * line).
+ */
+export function isLivenessCardMessage(m: ObservedMessage): boolean {
+  const lines = m.text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l.length > 0);
+  if (lines.length < 2) return false;
+  if (!LIVENESS_HEADER_L1_RE.test(lines[0])) return false;
+  if (!LIVENESS_HEADER_L2_RE.test(lines[1])) return false;
+  // Any remaining line must be an activity body line — the moment prose
+  // appears below the header, this is no longer the card (guards against a
+  // reply that happens to lead with a header-shaped emoji).
+  return lines.slice(2).every((l) => ACTIVITY_BODY_LINE_RE.test(l));
+}
+
 /**
  * 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.
+ * message qualifies when EITHER every non-empty line is a pure activity line
+ * (`→`/`✓`, the header-less feed) OR it carries the two-line liveness header
+ * (see {@link isLivenessCardMessage}) — 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.
+ * lands, and an `expectMessage(/\S/)` would otherwise latch onto it. Before
+ * this predicate learned the header shape, the Phase-1 climb card (which
+ * ALWAYS carries the header) slipped through as an "answer" and silently
+ * broke the entire liveness-climb test wall.
  */
 export function isActivityFeedMessage(m: ObservedMessage): boolean {
   const lines = m.text
@@ -63,7 +127,8 @@ export function isActivityFeedMessage(m: ObservedMessage): boolean {
     .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));
+  if (lines.every((l) => ACTIVITY_FEED_LINE_RE.test(l))) return true;
+  return isLivenessCardMessage(m);
 }
 
 /**
@@ -83,6 +148,25 @@ export function isAnswer(m: ObservedMessage, driverUserId: number): boolean {
   );
 }
 
+/**
+ * Wording of the framework's own mid-turn / dark-turn fallback sends — the
+ * exact erosion class the liveness test wall exists to catch. A re-added
+ * cadence "still working…" text ping (the #2667 shape the RFC bans) or a
+ * dark-turn fallback would carry one of these phrases. Scenarios use this to
+ * REJECT such a message from the "answer" lane: without it, the first loud
+ * mid-turn framework send is swallowed as the turn's answer and the ping-free
+ * guarantee passes vacuously. Keep in sync with `SILENT_END_FALLBACK_TEXT`
+ * (gateway.ts) and `formatFrameworkFallbackText` (silence-poke.ts).
+ */
+export const FRAMEWORK_FALLBACK_RE =
+  /still working|no update from agent|didn't send a reply|finished working but|waiting for your approval/i;
+
+/** True when `text` reads like a framework mid-turn/dark-turn fallback send
+ *  (see {@link FRAMEWORK_FALLBACK_RE}) rather than a model-authored answer. */
+export function isFrameworkFallbackText(text: string): boolean {
+  return FRAMEWORK_FALLBACK_RE.test(text);
+}
+
 export interface ReplyIsLastOptions {
   /**
    * The answer message that must be last in its foreground turn. The turn is

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

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "bun:test";
 import {
   isActivityFeedMessage,
+  isFrameworkFallbackText,
+  isLivenessCardMessage,
   isWorkerFeedMessage,
   WORKER_FEED_RE,
 } from "./assertions.js";
@@ -83,4 +85,71 @@ describe("isActivityFeedMessage", () => {
   it("does NOT match an empty message", () => {
     expect(isActivityFeedMessage(feed("   "))).toBe(false);
   });
+
+  // The regression that silently broke the whole liveness-climb test wall
+  // (deterministic-turn-liveness.md Phase 4a): the climb card carries the
+  // two-line `renderActivityHeader`, which the pure-arrow predicate could
+  // never match — so it was classified as the answer and every climb test
+  // exited vacuously. isActivityFeedMessage must now recognise the header.
+  it("matches the Phase-1 climb card (two-line header + Working… body)", () => {
+    expect(
+      isActivityFeedMessage(feed("🤖 Agent\n12s · 0 tools\n→ Working…")),
+    ).toBe(true);
+    expect(
+      isActivityFeedMessage(feed("🤖 Agent\n2m05s · 0 tools\n→ Working…")),
+    ).toBe(true);
+  });
+
+  it("matches a headered narration card (header + narrated → step)", () => {
+    expect(
+      isActivityFeedMessage(feed("🤖 Agent\n18s · 2 tools\n✓ Checking the hostname\n→ Writing the file")),
+    ).toBe(true);
+  });
+});
+
+describe("isLivenessCardMessage", () => {
+  it("matches the climbing Working… card (running header)", () => {
+    expect(isLivenessCardMessage(feed("🤖 Agent\n12s · 0 tools\n→ Working…"))).toBe(true);
+    expect(isLivenessCardMessage(feed("🤖 Agent\n1m41s · 3 tools\n→ Working…"))).toBe(true);
+  });
+
+  it("matches the done header shape", () => {
+    expect(isLivenessCardMessage(feed("🤖 Agent\ndone · 3 tools · 41s\n✓ Ran the check"))).toBe(true);
+  });
+
+  it("matches a header with a description on line 1", () => {
+    expect(isLivenessCardMessage(feed("🤖 Agent · summarising the logs\n8s · 1 tool\n→ Working…"))).toBe(true);
+  });
+
+  it("does NOT match a plain reply", () => {
+    expect(isLivenessCardMessage(feed("done! I created the file and listed it."))).toBe(false);
+  });
+
+  it("does NOT match a reply that opens with an emoji but is prose", () => {
+    expect(
+      isLivenessCardMessage(feed("🤖 Agent here — I finished the task.\nAll four steps done.")),
+    ).toBe(false);
+  });
+
+  it("does NOT match when prose follows the header", () => {
+    expect(
+      isLivenessCardMessage(feed("🤖 Agent\n12s · 0 tools\nHere is your answer.")),
+    ).toBe(false);
+  });
+
+  it("does NOT match a bare single header line", () => {
+    expect(isLivenessCardMessage(feed("🤖 Agent"))).toBe(false);
+  });
+});
+
+describe("isFrameworkFallbackText", () => {
+  it("flags the mid-turn / dark-turn fallback wording", () => {
+    expect(isFrameworkFallbackText("⚠️ still working… (no update from agent in 5 min)")).toBe(true);
+    expect(isFrameworkFallbackText("The agent finished working but didn't send a reply.")).toBe(true);
+    expect(isFrameworkFallbackText("I'm blocked — waiting for your approval to proceed.")).toBe(true);
+  });
+
+  it("does NOT flag an ordinary answer", () => {
+    expect(isFrameworkFallbackText("Done — I created /tmp/foo and wrote a file in it.")).toBe(false);
+  });
 });

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

@@ -0,0 +1,155 @@
+/**
+ * Fuzz: dead-air-between-visible-updates bound across turn shapes (Phase 4c,
+ * `deterministic-turn-liveness.md`). Non-required (`uat-fuzz`,
+ * `workflow_dispatch` + scheduled — see `ci-uat.yml`), scoped to `fuzz-*`.
+ *
+ * SCOPE HONESTY (read before trusting this as "the fuzz invariant" wholesale):
+ * the RFC's Phase 4c corpus is message-timing × turn-length × tool-churn ×
+ * sub-agent-fan-out × surface × role — a genuinely randomized property-fuzz.
+ * That full corpus already exists at the DECISION layer
+ * (`telegram-plugin/tests/turn-liveness-invariant.test.ts`, 2000 random
+ * shapes × both surfaces, fast/local/every-CI-run). What does NOT exist yet
+ * is a live-transport fuzz of the same breadth — each live turn burns real
+ * subscription quota and ~30-90s wall-clock, so a 2000-shape live corpus is
+ * not realistic to author or run from this sandbox (or CI, at any cadence
+ * short of a dedicated long-running canary). This file is the SCAFFOLD:
+ * a handful of FIXED, hand-picked turn shapes run on the real surface,
+ * checked against the SAME dead-air bound the decision-layer fuzz proves in
+ * the abstract. It is not a substitute for a true randomized live corpus —
+ * see the RFC's Known gaps / follow-up list, where this limitation is named
+ * explicitly rather than left implicit.
+ *
+ * Each case fires a turn shape and watches the two Phase-1 (keystone)
+ * invariants on the real surface — this is a climb/dead-air fuzz, NOT a
+ * dark-turn fuzz (the dark-turn at-most-once latch is proven in the
+ * `silent-end-recovery-{dm,channel}` scenarios, not here):
+ *
+ *   - dead air between VISIBLE updates (card edits, narration, or the final
+ *     answer) never exceeds `MAX_DEAD_AIR_MS` — generous slack over the
+ *     ~6-12s Phase-1 bound to absorb live Bot API + model latency jitter;
+ *   - zero mid-turn erosion: no non-final message with `silent===false`, and
+ *     no framework fallback TEXT send masquerading as the answer.
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+import { isActivityFeedMessage, isFrameworkFallbackText } from "../assertions.js";
+import type { ObservedMessage } from "../driver.js";
+
+const MAX_DEAD_AIR_MS = 25_000; // generous slack over the ~6-12s Phase-1 bound
+const CASE_BUDGET_MS = 130_000;
+
+interface FuzzCase {
+  name: string;
+  prompt: string;
+  windowMs: number;
+}
+
+const CASES: FuzzCase[] = [
+  {
+    name: "single-silent-tool-short",
+    prompt:
+      "Run exactly one Bash command `sleep 20` with NO narration before or " +
+      "during it, then reply with a one-line confirmation.",
+    windowMs: 30_000,
+  },
+  {
+    name: "single-silent-tool-long",
+    prompt:
+      "Run exactly one Bash command `sleep 50` with NO narration before or " +
+      "during it, then reply with a one-line confirmation.",
+    windowMs: 60_000,
+  },
+  {
+    name: "two-silent-tools-back-to-back",
+    prompt:
+      "Run Bash `sleep 20`, then immediately (no narration in between) run " +
+      "Bash `sleep 20` again, then reply with a one-line confirmation.",
+    windowMs: 50_000,
+  },
+];
+
+describe("uat-fuzz: liveness dead-air bound across a handful of turn shapes (Phase 4c scaffold)", () => {
+  for (const fc of CASES) {
+    it(
+      `[${fc.name}] dead air between visible updates never exceeds ${MAX_DEAD_AIR_MS}ms; 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(fc.prompt);
+          const sentAt = Date.now();
+          let lastVisibleAt = sentAt;
+          let maxGap = 0;
+          let answer: ObservedMessage | null = null;
+          let loudMidTurn: ObservedMessage | null = null;
+
+          const deadline = Date.now() + fc.windowMs + 40_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;
+
+            const now = Date.now();
+            if (isActivityFeedMessage(m)) {
+              const gap = now - lastVisibleAt;
+              maxGap = Math.max(maxGap, gap);
+              lastVisibleAt = now;
+              if (m.edited && m.silent === false) loudMidTurn = loudMidTurn ?? m;
+              continue;
+            }
+            if (m.edited) continue;
+            // A framework fallback TEXT send is a mid-turn erosion, not the
+            // answer — never let it be swallowed as the reply (else a re-added
+            // "still working…" ping would pass this fuzz vacuously).
+            if (isFrameworkFallbackText(m.text)) {
+              loudMidTurn = loudMidTurn ?? m;
+              continue;
+            }
+            if (!answer && m.text.trim().length > 0) {
+              answer = m;
+              const gap = now - lastVisibleAt;
+              maxGap = Math.max(maxGap, gap);
+              continue;
+            }
+            if (m.silent === false) loudMidTurn = loudMidTurn ?? m;
+          }
+          await iter.return?.();
+
+          console.log(
+            `[fuzz-liveness-climb][${fc.name}] maxGap=${maxGap}ms answer=${answer != null}`,
+          );
+
+          expect(
+            loudMidTurn,
+            `[${fc.name}] a mid-turn message pinged the device: ` +
+              JSON.stringify(loudMidTurn?.text?.slice(0, 120)),
+          ).toBeNull();
+
+          expect(answer, `[${fc.name}] FAIL — no answer within budget; turn may be wedged.`).not.toBeNull();
+
+          expect(
+            maxGap,
+            `[${fc.name}] dead air of ${maxGap}ms between visible updates exceeds the ` +
+              `${MAX_DEAD_AIR_MS}ms bound — the Phase-1 climb should have kept the card ` +
+              "moving throughout the silent tool stretch.",
+          ).toBeLessThanOrEqual(MAX_DEAD_AIR_MS);
+        } finally {
+          await sc.tearDown();
+        }
+      },
+      CASE_BUDGET_MS,
+    );
+  }
+});