switchroom 0.17.6 → 0.17.10

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

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