@sema-agent/core 7.35.1 → 7.35.2

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 7.35.2 — 2026-09-29
+
+### A wait the watchdog cuts at the 30 s disclosure threshold is disclosed before the cut (#746; behavior (status frames: +1 `waiting_first_token` frame per attempt when a first-token or first-byte window is exactly the 30 s threshold); +0 exports, +0 wire keys, +0 codes, closed sets unchanged) (@cli @client-core @server @test)
+
+- **Before (v7.35.1).** Measured by cli against a running engine (L-778, five scenarios: a gateway that sends headers at once and its first token 45 s later, or holds its headers 45 s). With the first-token watchdog at 30 s (`firstTokenTimeoutMs`; server env `MODEL_FIRST_TOKEN_TIMEOUT_MS`), a request waited 30 s with no `status` frame at all and was then cut. The wait disclosure was armed only for a ceiling strictly above its 30 s threshold, so the one tick that fell on the deadline was never sent. At 40 s, or at the 600 s default, the 30 s frame was there. A first-byte window of exactly 30 s (knob plus upload allowance) had the same gap.
+- **Now.** The wait disclosure is armed whenever its ceiling reaches the threshold (`>=`, the watchdog's own comparison). When the watchdog fires, a wait not yet disclosed is disclosed at that instant — `waiting_first_token` with `elapsedMs` equal to `timeoutMs` — and the retry (or terminal) frame follows. The deadline owns that frame, so which timer runs first no longer decides whether it is sent. This holds for the first-token wait and the header wait alike. Re-announcements are unchanged: they stay strictly before the ceiling, so a 120 s watchdog still shows 30 / 60 / 90 s and no frame at 120 s.
+- **Not changed.** The retry after a watchdog cut keeps `phase: "reconnecting"` with `errClass: "stall"`. The shells already tell the two apart by `errClass`: cli L-264 renders it as "No output before the stream timeout · slow model or gateway", through client-core's `stalled` arm. The engine does not rename the phase. The header wait and the first-token wait still share `waiting_first_token`; a separate phase word would be a wire change.
+- **Readings (engine fixtures of cli's scenarios, fake clock).**
+  - A (token 45 s, watchdog 30 s, every request slow): 0 → 11 wait frames, one per attempt, each 30000 of 30000, each before its attempt's `reconnecting` / `stall` frame. The call still ends `gave_up` / `first-token timeout after 30000ms`.
+  - A2 (only the first request slow): `reconnecting, recovered` → `waiting_first_token, reconnecting, recovered`.
+  - B′ (header window exactly 30 s): the same.
+  - B (headers 45 s, first-byte 30 s + 3 s upload allowance), C (the 600 s default) and D (40 s): unchanged.
+- **Who is hurt.** A deployment whose first-token (or first-byte) window is exactly 30 s sees one more frame per attempt, at the deadline. The frame is closed by `recovered` / `gave_up` as before. client-core maps it to `kind: 'waiting'` and cli renders its waiting byline. A probe that counted zero wait frames under a 30 s watchdog goes red. The engine defaults are unchanged.
+- Pins: `test/backlog746-first-token-watchdog-phase.test.ts`:
+  - A ① every attempt's wait is disclosed at its deadline; A ② control: the retries and the end; A ③ an event loop stalled across the deadline still gets exactly one wait frame before the retry.
+  - A2, B′ (the full trails), B, C, D (controls).
+  - Baseline v7.35.1: A ①, A ③, A2 and B′ red; A ②, B, C and D green.
+  - Unchanged and green: `backlog530-waiting-first-token`, including the 120 s cell and the stalled-event-loop cell.
+- Mutations:
+  - D960, the disclosure arms only above the threshold (v7.35.1's `>`): A ①, A ③, A2 and B′ go red.
+  - D960b, the deadline does not disclose (`expire` does what `stop` does): the same four go red. Per site: the first-token watchdog calling `stop` turns A ①, A ③ and A2 red; the header `finally` always stopping turns B′ red.
+  - D960c, the deadline discloses a wait that was already disclosed: the controls go red (D, B, and `backlog530` ④ / ⑥ / ④c).
+  - Per-fixture table: `.gate-logs/criteria-7.35.2-mutations.md`.
+
 ## 7.35.1 — 2026-09-29
 
 ### A run that named no session holds the session its store minted — a second run on that id waits for it (#1206; behavior (tighten: a second run of a new session queues); +0 exports, +0 wire keys; +1 engine-invariant code `internal.session_lock_second_id` that no engine path reaches) (@server @test)

package/dist/brain/stream-engine.d.ts

@@ -96,7 +96,8 @@ export declare function shouldRetryHeaderVerdict(res: Response | undefined): boo
  * {@link WAITING_FIRST_TOKEN_AFTER_MS}, and one more every {@link WAITING_FIRST_TOKEN_EVERY_MS} after
  * that, until the first token lands, the watchdog fires, or the attempt ends. A short wait (under the
  * threshold) announces nothing — the frame exists for the unattended "no answer for a minute" case,
- * not for every request. The same 30s slice the retry countdown re-announces on.
+ * not for every request. A wait whose watchdog fires AT the threshold is disclosed once, at that
+ * instant, before the cut is announced. The same 30s slice the retry countdown re-announces on.
  */
 export declare const WAITING_FIRST_TOKEN_AFTER_MS = 30000;
 export declare const WAITING_FIRST_TOKEN_EVERY_MS = 30000;

package/dist/brain/stream-engine.js

@@ -337,29 +337,40 @@ export function runStreamingBrain(args) {
         const idleTimeoutMs = resolveWatchdogMs(config.idleTimeoutMs, stallTimeouts?.idleMs, STALL_IDLE_MS, "idleTimeoutMs");
         const firstByteRetryBudget = resolveFirstByteRetries(config.firstByteRetries);
         const armWaitDisclosure = (ceilingMs) => {
-            if (!(ceilingMs > WAITING_FIRST_TOKEN_AFTER_MS))
-                return { stop: () => undefined };
+            if (!(ceilingMs >= WAITING_FIRST_TOKEN_AFTER_MS))
+                return { stop: () => undefined, expire: () => undefined };
             const startedAt = Date.now();
             const emitWaitFrame = bindBrainStatusEmitter();
             let timer;
             let stopped = false;
+            let disclosed = false;
+            const disclose = () => {
+                disclosed = true;
+                announcedWait = true;
+                emitWaitFrame({ phase: "waiting_first_token", detail: "waiting for the first token", elapsedMs: Date.now() - startedAt, timeoutMs: ceilingMs });
+            };
             const schedule = (delayMs) => {
                 timer = setTimeout(() => {
                     timer = undefined;
                     if (stopped || Date.now() - startedAt >= ceilingMs)
                         return;
-                    announcedWait = true;
-                    emitWaitFrame({ phase: "waiting_first_token", detail: "waiting for the first token", elapsedMs: Date.now() - startedAt, timeoutMs: ceilingMs });
+                    disclose();
                     schedule(WAITING_FIRST_TOKEN_EVERY_MS);
                 }, delayMs);
             };
             schedule(WAITING_FIRST_TOKEN_AFTER_MS);
+            const stop = () => {
+                stopped = true;
+                if (timer)
+                    clearTimeout(timer);
+                timer = undefined;
+            };
             return {
-                stop: () => {
-                    stopped = true;
-                    if (timer)
-                        clearTimeout(timer);
-                    timer = undefined;
+                stop,
+                expire: () => {
+                    if (!stopped && !disclosed)
+                        disclose();
+                    stop();
                 },
             };
         };
@@ -378,13 +389,13 @@ export function runStreamingBrain(args) {
                     throw e;
                 }
                 const window = firstByteWindow(firstByteTimeoutMs, Buffer.byteLength(req.body), firstByteStalls);
+                const headerWait = armWaitDisclosure(window.windowMs);
                 const cc = createAttemptController(window.windowMs, signal);
                 let r;
                 let netErr;
                 let firstByteStall;
                 requestIdSeen = undefined;
                 attemptPartial = undefined;
-                const headerWait = armWaitDisclosure(window.windowMs);
                 const stalledAtFirstByte = () => {
                     firstByteWindowsWaited.push(window.windowMs);
                     return {
@@ -423,7 +434,10 @@ export function runStreamingBrain(args) {
                     }
                 }
                 finally {
-                    headerWait.stop();
+                    if (firstByteStall !== undefined)
+                        headerWait.expire();
+                    else
+                        headerWait.stop();
                 }
                 if (r && r.ok && r.body) {
                     cc.clearTimer();
@@ -587,14 +601,14 @@ export function runStreamingBrain(args) {
             let firstTokenSeen = false;
             let firedFirstTokenDeadlineMs;
             let ftTimer;
-            let firstTokenWait = { stop: () => undefined };
+            let firstTokenWait = { stop: () => undefined, expire: () => undefined };
             if (firstTokenTimeoutMs && firstTokenTimeoutMs > 0) {
+                firstTokenWait = armWaitDisclosure(firstTokenTimeoutMs);
                 ftTimer = setTimeout(() => {
                     firedFirstTokenDeadlineMs = firstTokenTimeoutMs;
-                    firstTokenWait.stop();
+                    firstTokenWait.expire();
                     void reader.cancel().catch(() => undefined);
                 }, firstTokenTimeoutMs);
-                firstTokenWait = armWaitDisclosure(firstTokenTimeoutMs);
             }
             let firedIdleDeadlineMs;
             let idleTimer;

package/dist/core/task-event.d.ts

@@ -78,7 +78,8 @@ export type BrainStatusPhase = "rate_limited" | "retrying" | "reconnecting" | "c
  * The first-token WAIT, before any failure: a first-token watchdog is armed
  * (`firstTokenTimeoutMs > 0`) and nothing has arrived yet. Emitted once the wait has lasted
  * `WAITING_FIRST_TOKEN_AFTER_MS` and re-emitted every `WAITING_FIRST_TOKEN_EVERY_MS` while it goes
- * on, carrying {@link BrainStatus.elapsedMs} and {@link BrainStatus.timeoutMs}; never carries a
+ * on; a wait whose watchdog fires at the threshold itself is emitted once at that instant, before the
+ * frame announcing the cut. Carries {@link BrainStatus.elapsedMs} and {@link BrainStatus.timeoutMs}; never carries a
  * retry countdown (`retryInMs`/`retryAtMs` — no wait is being announced, a wait is being
  * OBSERVED). CLOSED like a retry trail: once a wait frame went out, the call's terminal frame
  * follows — `recovered` when the call went on to be served (the first token arrived, on this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.35.1",
+  "version": "7.35.2",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",

package/wire-changes/core@7.35.2.json

@@ -0,0 +1,61 @@
+{
+  "repo": "core",
+  "version": "7.35.2",
+  "from": "47ed594ee8d729368c4be8d8a189d908b33e15e5",
+  "to": "v7.35.2",
+  "added": [],
+  "removed": [],
+  "changed": [],
+  "narrowed": [],
+  "closedSetMembers": [],
+  "closedSetsUnreadable": [],
+  "typeKeys": [],
+  "typeKeysUnreadableArms": [],
+  "typeKeysFlattenedCount": 219,
+  "declarationMoves": [],
+  "mintMoves": [],
+  "criteriaObserves": [
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.elapsedMs",
+      "assertions": [
+        "G1.a",
+        "G1.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.errClass",
+      "assertions": [
+        "G1.b"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.phase",
+      "assertions": [
+        "G1.a",
+        "G1.b",
+        "G1.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.timeoutMs",
+      "assertions": [
+        "G1.a",
+        "G1.b",
+        "G1.c"
+      ]
+    }
+  ],
+  "consumersHint": {
+    "cli": [],
+    "server": [],
+    "sdk": [],
+    "note": "scanned cli@6b6025f7 server@25d6b7a6 sdk@e8f6f0d — a name listed is MENTIONED there today, which is evidence of consumption, not proof of it"
+  },
+  "breakingCount": 0,
+  "breakingItems": [],
+  "toResolvedAt": "8a69688057ed91863f6574e06b9f4f83dfdcb7a6"
+}