switchroom 0.13.4 → 0.13.5

package/telegram-plugin/runtime-metrics.ts

@@ -19,6 +19,7 @@
 import { existsSync, mkdirSync, appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { captureEvent } from './analytics-posthog.js'
+import type { PokeLevel } from './silence-poke.js'
 
 export type RuntimeMetricEvent =
   /**
@@ -62,28 +63,33 @@ export type RuntimeMetricEvent =
       ended_via: 'reply' | 'stream_reply_done' | 'silent' | 'forced' | 'framework_fallback'
     }
   /**
-   * Framework safety-net: a silence-poke was armed at 75s (soft) or
-   * 180s (firm). The system-reminder appended to the next tool result
-   * nudges the model to send an update. Doubles as a design-health
-   * signal — if these fire frequently, the conversational-pacing
-   * prompt isn't doing its job.
+   * Framework safety-net: a silence-poke was armed. `ack` is the early
+   * (~10s) ack-budget poke — the model has sent NOTHING this turn and is
+   * leaving the user on a silent chat. `soft` (75s) / `firm` (180s) are
+   * the silence-since-last-outbound ladder. The system-reminder appended
+   * to the next tool result nudges the model to send an update. Doubles
+   * as a design-health signal — if these fire frequently, the
+   * conversational-pacing prompt isn't doing its job.
    */
   | {
       kind: 'silence_poke_fired'
       key: string
-      level: 'soft' | 'firm'
+      level: PokeLevel
       silence_ms: number
       subagent_wait: boolean
     }
   /**
    * The model sent an outbound message within the success window
    * (default 15s) after a poke fired. Pair with `silence_poke_fired`
-   * to compute success rate — the design target is >80%.
+   * to compute success rate — the design target is >80%. (`ack`-level
+   * success is not currently emitted — the ack poke sits outside the
+   * `pokesFired` ladder noteOutbound measures against; the type admits
+   * `ack` only so the silence-poke metric union stays assignable.)
    */
   | {
       kind: 'silence_poke_succeeded'
       key: string
-      level: 'soft' | 'firm'
+      level: PokeLevel
       latency_ms: number
     }
   /**

package/telegram-plugin/silence-poke.ts

@@ -43,7 +43,7 @@
  * pacing prompt still applies; only the framework safety net is off.
  */
 
-export type PokeLevel = 'soft' | 'firm'
+export type PokeLevel = 'ack' | 'soft' | 'firm'
 
 /** #1292: snapshot of an in-flight tool call, surfaced in the 300s
  * framework-fallback message so the user sees the actual observable
@@ -76,6 +76,10 @@ export interface SilencePokeState {
   lastThinkingAt: number | null
   /** True once the 300s framework fallback has fired this turn. */
   fallbackFired: boolean
+  /** True once the early ack-budget poke has fired this turn. One-shot:
+   *  the ack nudge is specifically about the *first* outbound, so it
+   *  never re-arms even after the model later goes quiet again. */
+  ackPokeFired: boolean
   /** Wall-clock ms of last poke fire — used for poke-success latency. */
   lastPokeFiredAt: number | null
   /** #1292: in-flight tool calls keyed by toolUseId. Populated by
@@ -91,6 +95,12 @@ export interface SilencePokeState {
 }
 
 export interface ThresholdsMs {
+  /** Ack budget: if NO outbound at all has landed this many ms after
+   *  turn start, arm an 'ack' poke. This is the framework enforcing the
+   *  human-baseline "acknowledge within a beat" — far tighter than the
+   *  75s `soft` threshold, which measures silence-since-last-outbound
+   *  and is the wrong instrument for "you never said hello." */
+  ack: number
   soft: number
   firm: number
   fallback: number
@@ -101,6 +111,7 @@ export interface ThresholdsMs {
 }
 
 export const DEFAULT_THRESHOLDS: ThresholdsMs = {
+  ack: 10_000,
   soft: 75_000,
   firm: 180_000,
   fallback: 300_000,
@@ -176,6 +187,7 @@ export function startTurn(key: string, now: number): void {
     subagentDispatchActive: false,
     lastThinkingAt: null,
     fallbackFired: false,
+    ackPokeFired: false,
     lastPokeFiredAt: null,
     inFlightTools: new Map(),
   })
@@ -340,6 +352,16 @@ export function endTurn(key: string): void {
 
 /** Verbatim poke text. Wording is load-bearing — see issue #1122 design. */
 export function formatPokeText(level: PokeLevel): string {
+  if (level === 'ack') {
+    return (
+      "[silence-poke] You haven't sent the user anything yet this turn — "
+      + 'they are looking at a silent chat. Send a short, human one-line '
+      + 'acknowledgement now via `reply` (e.g. "on it — checking"), in your '
+      + "persona's voice, before you do any more work. A good colleague "
+      + "answers in a beat; don't leave the message hanging while you think. "
+      + 'If the full answer is genuinely seconds away, send that instead.'
+    )
+  }
   if (level === 'soft') {
     return (
       "[silence-poke] You've been silent to the user for 75s. If you're "
@@ -437,6 +459,32 @@ function tick(now: number): void {
       ? thresholds.subagentSoft
       : thresholds.soft
 
+    // Ack budget — the framework enforcing the human-baseline "answer
+    // in a beat." Fires once, only when NOTHING has been sent this turn
+    // (`lastOutboundAt == null`), well before the 75s `soft` threshold.
+    // `soft` measures silence-since-last-outbound and is the wrong
+    // instrument for "you never acknowledged me." Independent of the
+    // soft/firm/fallback ladder: if the model never acks, it still
+    // escalates soft → firm → fallback on schedule after this.
+    if (
+      !s.ackPokeFired
+      && s.lastOutboundAt == null
+      && s.pokesFired === 0
+      && silence >= thresholds.ack
+    ) {
+      s.pokeArmed = { level: 'ack' }
+      s.ackPokeFired = true
+      s.lastPokeFiredAt = now
+      activeDeps.emitMetric({
+        kind: 'silence_poke_fired',
+        key,
+        level: 'ack',
+        silence_ms: silence,
+        subagent_wait: s.subagentDispatchActive,
+      })
+      continue
+    }
+
     if (s.pokesFired === 0 && silence >= softThreshold) {
       s.pokeArmed = { level: 'soft' }
       s.pokesFired = 1

package/telegram-plugin/tests/silence-poke.test.ts

@@ -33,7 +33,15 @@ function setupDeps(opts?: { thresholds?: Partial<typeof DEFAULT_THRESHOLDS> }):
   __setDepsForTests({
     emitMetric: (e) => fixtures.emitted.push(e),
     onFrameworkFallback: (ctx) => { fixtures.fallbacks.push(ctx) },
-    thresholdsMs: { ...DEFAULT_THRESHOLDS, ...(opts?.thresholds ?? {}) },
+    // The ack budget (a new poke that fires *earlier* than `soft`) is
+    // disabled by default in this fixture so the soft/firm/fallback
+    // ladder tests stay isolated from it. The 'ack budget' describe
+    // block opts back in with a real value.
+    thresholdsMs: {
+      ...DEFAULT_THRESHOLDS,
+      ack: Number.MAX_SAFE_INTEGER,
+      ...(opts?.thresholds ?? {}),
+    },
   })
   return fixtures
 }
@@ -139,6 +147,127 @@ describe('silence-poke — escalation ladder', () => {
   })
 })
 
+// PR1 (human-feel UX epic): the ack budget. A person you message
+// answers in a beat — the framework enforces that baseline by arming an
+// 'ack' poke if NOTHING has been sent within `thresholds.ack` of turn
+// start. It is a one-shot nudge (the model still authors every word),
+// deliberately OUTSIDE the soft/firm/fallback `pokesFired` ladder: if
+// the model never acks, the ladder still escalates on its own schedule.
+// See `reference/conversational-pacing.md` and the "Open with an
+// acknowledgement" bullet in `profiles/_shared/telegram-style.md.hbs`.
+//
+// NB: `setupDeps` disables the ack budget by default (ack = MAX_SAFE);
+// every test here opts back in with a real `ack` threshold.
+describe('silence-poke — ack budget (PR1 human-feel UX)', () => {
+  it('arms an ack poke at the ack threshold when nothing has been sent', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+
+    __tickForTests(9_000) // before the ack budget
+    expect(consumeArmedPoke()).toBeNull()
+    expect(fx.emitted).toHaveLength(0)
+
+    __tickForTests(10_000) // at the ack budget
+    expect(fx.emitted).toEqual([
+      expect.objectContaining({ kind: 'silence_poke_fired', level: 'ack' }),
+    ])
+    const text = consumeArmedPoke()
+    expect(text).toContain('[silence-poke]')
+    expect(text).toContain('reply')
+  })
+
+  it('does NOT arm an ack poke if an outbound landed before the budget', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    noteOutbound('chat:0', 3_000) // model acked fast — inside the budget
+    __tickForTests(10_000)
+    __tickForTests(20_000)
+    expect(consumeArmedPoke()).toBeNull()
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'ack'),
+    ).toHaveLength(0)
+  })
+
+  it('is one-shot — never re-arms even if the model goes quiet again', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000)         // ack fires
+    consumeArmedPoke()             // drain it
+    noteOutbound('chat:0', 12_000) // model finally acks
+    // The model goes quiet again. The ack poke is specifically about the
+    // FIRST outbound — it must not fire twice. A later silence is the
+    // soft poke's job, not the ack budget's.
+    __tickForTests(40_000)
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'ack'),
+    ).toHaveLength(1)
+  })
+
+  it('ackPokeFired resets across turns even when endTurn was skipped (CC-5 invariant)', () => {
+    // Mirrors the subagentDispatchActive CC-5 guard: `ackPokeFired` is a
+    // turn-scoped one-shot flag, and the only thing that keeps it from
+    // leaking into the next turn (when an abnormal abort skips endTurn)
+    // is startTurn's unconditional state overwrite. Pin that here so a
+    // future read-modify-write refactor of startTurn fails loud.
+    setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('k', 0)
+    __tickForTests(10_000) // ack fires
+    expect(__getStateForTests('k')?.ackPokeFired).toBe(true)
+    // Turn 2 in the same key, no endTurn — startTurn MUST clear the flag.
+    startTurn('k', 1_000_000)
+    expect(__getStateForTests('k')?.ackPokeFired).toBe(false)
+  })
+
+  it('does not advance the ladder — soft still requires a full 75s of silence', () => {
+    // The ack poke is deliberately outside `pokesFired`. After it fires,
+    // a soft poke must still wait the normal 75s.
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000) // ack
+    consumeArmedPoke()
+    __tickForTests(70_000) // 70s total — under the 75s soft threshold
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'soft'),
+    ).toHaveLength(0)
+    __tickForTests(75_000)
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'soft'),
+    ).toHaveLength(1)
+  })
+
+  it('still escalates ack -> soft -> firm -> fallback on a turn that never acks', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000)  // ack
+    consumeArmedPoke()
+    __tickForTests(75_000)  // soft
+    consumeArmedPoke()
+    __tickForTests(180_000) // firm
+    consumeArmedPoke()
+    __tickForTests(300_000) // fallback
+    const trail = fx.emitted.map((e) =>
+      e.kind === 'silence_poke_fired'
+        ? `poke:${e.level}`
+        : e.kind === 'silence_fallback_sent'
+          ? `fallback:${e.fallback_kind}`
+          : e.kind,
+    )
+    expect(trail).toEqual([
+      'poke:ack',
+      'poke:soft',
+      'poke:firm',
+      'fallback:working',
+    ])
+  })
+
+  it('formatPokeText("ack") nudges for a human acknowledgement via reply', () => {
+    const text = formatPokeText('ack')
+    expect(text).toContain('[silence-poke]')
+    expect(text.toLowerCase()).toContain('acknowledg')
+    expect(text).toContain('reply')
+  })
+})
+
 describe('silence-poke — outbound resets clock + success measurement', () => {
   it('noteOutbound resets the silence clock', () => {
     setupDeps()
@@ -608,7 +737,9 @@ describe('silence-poke — fallback handler errors do not break timer', () => {
     __setDepsForTests({
       emitMetric: (e) => fx.emitted.push(e),
       onFrameworkFallback: () => { throw new Error('oh no') },
-      thresholdsMs: DEFAULT_THRESHOLDS,
+      // ack budget out of the way — this test exercises the
+      // soft/firm/fallback ladder under a throwing fallback handler.
+      thresholdsMs: { ...DEFAULT_THRESHOLDS, ack: Number.MAX_SAFE_INTEGER },
     })
     startTurn('k', 0)
     expect(() => {
@@ -625,7 +756,8 @@ describe('silence-poke — fallback handler errors do not break timer', () => {
     __setDepsForTests({
       emitMetric: (e) => fx.emitted.push(e),
       onFrameworkFallback: () => Promise.reject(new Error('async fail')),
-      thresholdsMs: DEFAULT_THRESHOLDS,
+      // ack budget out of the way — see the throwing-handler test above.
+      thresholdsMs: { ...DEFAULT_THRESHOLDS, ack: Number.MAX_SAFE_INTEGER },
     })
     startTurn('k', 0)
     __tickForTests(75_000)

package/telegram-plugin/uat/scenarios/jtbd-fast-ack-dm.test.ts

@@ -0,0 +1,217 @@
+/**
+ * JTBD scenario — guaranteed fast acknowledgement (human-feel UX epic).
+ *
+ * Serves: `reference/conversational-pacing.md` and the JTBD
+ * "talking to my agent feels like talking to a capable person".
+ *
+ * A person you message answers in a beat — "got it", "on it, checking
+ * now" — before the work is done. PR #1633 made that opening
+ * acknowledgement a *guarantee*, split across two layers:
+ *
+ *   - the conversational-pacing prompt teaches the model to open with
+ *     a short human one-liner unless the real answer lands in a second
+ *     or two;
+ *   - the silence-poke subsystem *enforces* it — a ~10s ack-budget
+ *     poke fires when nothing at all has been sent this turn, nudging
+ *     the model to acknowledge before it does more work.
+ *
+ * This UAT drives a FUZZY set of non-trivial prompt shapes — research,
+ * multi-step compute, open-ended advice, code, reflective asks. Every
+ * one needs real work, so a turn that goes silent for tens of seconds
+ * is a black box. The invariant under test: the user sees a sign of
+ * life FAST, every time, across every prompt shape.
+ *
+ * ## Targets
+ *
+ *   - **Hard contract:** the first outbound lands within `ACK_HARD_MS`
+ *     for every prompt. This is a tight *latency target*, not a
+ *     framework guarantee. The silence-poke ack rung is a *nudge*
+ *     piggybacked on the model's next tool result (`consumeArmedPoke`
+ *     drained at the gateway tool-result chokepoint) — not a
+ *     framework-composed send. It helps the model along, but a
+ *     pure-reasoning prompt that issues no tool call never drains the
+ *     nudge, so the bound ultimately depends on model latency. It
+ *     still has teeth: pre-#1633 a slow prompt's first outbound was
+ *     the full answer, often 30-60s out, so 20s cleanly separates the
+ *     fixed behaviour from a regression. A failure here means the
+ *     agent left the user on a silent chat — a real pacing defect.
+ *   - **Vision target (soft, per-case forensic):** the first outbound
+ *     lands within `ACK_VISION_MS` and is short — a genuine
+ *     acknowledgement, not a full-answer dump. The model self-acking
+ *     quickly is what makes it *feel* human. Logged, not failed: real
+ *     model runs vary, and the prompt explicitly lets a turn skip the
+ *     ack when the answer itself arrives in the first couple seconds.
+ *
+ * ## Relationship to adjacent UATs
+ *
+ *   - `jtbd-fast-trivial-dm.test.ts` — TRIVIAL prompts: the answer
+ *     itself should land fast, no ack ceremony. This file is the
+ *     non-trivial inverse: real work, but a fast *acknowledgement*.
+ *   - `jtbd-soft-commit-dm.test.ts` — the predecessor: a single slow
+ *     prompt, a looser "first reply within 30s" floor. This file is
+ *     the stronger, fuzzed successor of that contract.
+ *
+ * Each case is a single inbound; cases run sequentially. As with the
+ * other fuzz files, a prior turn may still be finishing in the
+ * background when the next case starts — an accepted, noted risk.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+
+// Hard contract: a sign of life within this budget, every prompt.
+// A tight latency target — well above a healthy self-ack (~3-8s on a
+// warm agent) and well below the pre-#1633 silent-then-dump regression
+// (30-60s). Model-dependent, not a framework guarantee (see header
+// doc), so it carries generous headroom for mtcute polling jitter and
+// for a model that leans on the ack-poke nudge instead of self-acking.
+const ACK_HARD_MS = 20_000;
+
+// Vision target: the model self-acknowledges in a beat, fast enough
+// that the ack-poke nudge never has to come into it.
+const ACK_VISION_MS = 8_000;
+
+// A first outbound at or under this length reads as an acknowledgement
+// one-liner rather than a full-answer dump. Mirrors the >200-char
+// "long answer" heuristic in jtbd-soft-commit-dm, with headroom for a
+// persona-voiced ack ("on it — pulling the os-release and hostname now").
+const ACK_LEN_CEILING = 320;
+
+interface AckCase {
+  name: string;
+  /** A prompt that genuinely needs more than a second or two of work,
+   *  so an instant full answer is not a legitimate ack-skip. */
+  prompt: string;
+}
+
+const ACK_CASES: readonly AckCase[] = [
+  // ─── Research / multi-source read ─────────────────────────────
+  {
+    name: "machine-summary research",
+    prompt:
+      "Read /etc/os-release and /etc/hostname, then tell me in one "
+      + "sentence what kind of machine this is.",
+  },
+  // ─── Multi-step compute ───────────────────────────────────────
+  {
+    name: "compound date math",
+    prompt:
+      "Work out what day of the week it is today, then tell me how "
+      + "many days are left until the end of this month.",
+  },
+  // ─── Open-ended advice ("take your time") ─────────────────────
+  {
+    name: "open-ended prioritisation",
+    prompt:
+      "I've got a free afternoon and three half-finished side "
+      + "projects. Help me decide what to focus on. Take your time.",
+  },
+  // ─── Summarise / explain ──────────────────────────────────────
+  {
+    name: "plain-language summary",
+    prompt:
+      "Give me a 3-bullet summary of what a Linux container actually "
+      + "is, in plain language.",
+  },
+  // ─── Code task ────────────────────────────────────────────────
+  {
+    name: "bash one-liner with explanation",
+    prompt:
+      "Write me a small bash one-liner that counts the total number "
+      + "of lines across all .ts files under the current directory, "
+      + "and explain how it works.",
+  },
+  // ─── Reflective / vague-but-real ──────────────────────────────
+  {
+    name: "reflective open ask",
+    prompt:
+      "Something feels off with how I'm spending my mornings lately. "
+      + "Help me think through it.",
+  },
+  // ─── Comparison / judgement ───────────────────────────────────
+  {
+    name: "tech comparison",
+    prompt:
+      "Compare REST and GraphQL for a small side project — which "
+      + "would you pick and why?",
+  },
+  // ─── Investigate the box ──────────────────────────────────────
+  {
+    name: "disk-usage investigation",
+    prompt:
+      "Have a look at what's taking up the most space under /var/log "
+      + "and summarise what you find.",
+  },
+];
+
+describe("uat: guaranteed fast acknowledgement — fuzzy prompt shapes", () => {
+  for (const tc of ACK_CASES) {
+    it(
+      `[ack] ${tc.name} — sign of life within ${ACK_HARD_MS / 1000}s`,
+      async () => {
+        const sc = await spinUp({ agent: AGENT });
+        try {
+          const sendStart = Date.now();
+          await sc.sendDM(tc.prompt);
+
+          const firstOutbound = await sc.expectMessage(/\S/, {
+            from: "bot",
+            timeout: ACK_HARD_MS + 6_000,
+          });
+          const ttfo = Date.now() - sendStart;
+          const len = firstOutbound.text.trim().length;
+
+          // Invariant: the outbound is a real, non-empty message.
+          expect(len).toBeGreaterThan(0);
+
+          // Hard contract: a sign of life FAST. A latency target, not
+          // a framework guarantee (see header doc) — but a failure
+          // here is a real pacing defect, so it fails the build.
+          if (ttfo >= ACK_HARD_MS) {
+            throw new Error(
+              `[ack] ${tc.name}: TTFO=${ttfo}ms exceeds the hard `
+              + `contract ${ACK_HARD_MS}ms — the user sat on a silent `
+              + `chat. The fast-ack path (pacing prompt + ack-poke `
+              + `nudge) is not delivering. First outbound: `
+              + `${JSON.stringify(firstOutbound.text.slice(0, 200))}`,
+            );
+          }
+          expect(ttfo).toBeLessThan(ACK_HARD_MS);
+
+          // Forensic, soft: did the model self-acknowledge in a beat,
+          // or did it only get there with the ack-poke nudge?
+          const looksLikeAck = len <= ACK_LEN_CEILING;
+          if (ttfo < ACK_VISION_MS && looksLikeAck) {
+            console.log(
+              `[ack] ${tc.name}: TTFO=${ttfo}ms, ${len} chars — fast `
+              + `short acknowledgement. Feels human.`,
+            );
+          } else if (ttfo < ACK_VISION_MS && !looksLikeAck) {
+            // Fast but long: the answer itself arrived quickly. The
+            // pacing prompt explicitly sanctions skipping the ack when
+            // the answer lands in the first couple of seconds.
+            console.log(
+              `[ack] ${tc.name}: TTFO=${ttfo}ms, ${len} chars — fast `
+              + `full answer (legitimate ack-skip).`,
+            );
+          } else {
+            // Passed the hard contract but slower than the vision
+            // target — the canary for the model needing the ack-poke
+            // nudge instead of acknowledging promptly on its own.
+            console.warn(
+              `[ack] ${tc.name}: TTFO=${ttfo}ms (vision target `
+              + `<${ACK_VISION_MS}ms), ${len} chars`
+              + `${looksLikeAck ? "" : " — and long, not an ack one-liner"}`
+              + `. The model did not acknowledge promptly on its own.`,
+            );
+          }
+        } finally {
+          await sc.tearDown();
+        }
+      },
+      ACK_HARD_MS + 45_000,
+    );
+  }
+});

package/telegram-plugin/uat/scenarios/jtbd-soft-commit-dm.test.ts

@@ -1,16 +1,21 @@
 /**
- * JTBD scenario — soft-commit for slow turns.
+ * JTBD scenario — first sign of life on a slow turn.
  *
- * The new conversational-pacing prompt (#1122) instructs the agent
- * to send a one-liner "let me check, back in a few" before slow
- * work. This UAT exercises that behaviour: send a prompt that
- * obviously needs >15s, expect the FIRST outbound to be a short
- * soft-commit message, with the final answer landing later.
+ * The conversational-pacing prompt instructs the agent to open with
+ * an acknowledgement before slow work. (The original ">15s soft
+ * commit" bullet this file was named for was superseded by the
+ * guaranteed "Open with an acknowledgement" bullet in PR #1633 —
+ * acknowledge every turn unless the answer lands in a second or two.)
  *
- * Not strict — the agent's allowed to skip the soft-commit if it
- * judges the work is fast enough. The assertion is "the user does
- * NOT see a long silent gap before the first sign of life": either
- * a soft-commit OR the actual reply lands within 20s.
+ * This UAT exercises a single slow prompt and asserts the loose
+ * floor: the user does NOT see a long silent gap before the first
+ * sign of life — a reply lands within 30s.
+ *
+ * The stronger, fuzzed successor of this contract is
+ * `jtbd-fast-ack-dm.test.ts` — varied prompt shapes, a tight 20s
+ * hard latency target (a tight target, not a framework guarantee —
+ * see that file's header). This file is retained as a minimal
+ * single-prompt floor.
  */
 
 import { describe, it, expect } from "vitest";
@@ -26,7 +31,7 @@ const SLOW_PROMPT = (
 
 describe("uat: soft-commit pacing", () => {
   it(
-    "user asks slow question → first reply lands within 20s",
+    "user asks slow question → first reply lands within 30s",
     async () => {
       const sc = await spinUp({ agent: "test-harness" });
       try {