mixdog 1.2.5 → 1.3.0

package/src/runtime/shared/session-activity-signal.mjs

@@ -0,0 +1,23 @@
+// session-activity-signal.mjs
+// Process-local "a session's activity state may have changed" pulse: a turn
+// started or settled, a task wait began or ended, a background task was
+// handed off or finished. Status surfaces that project activity from the
+// runtime map (the Agents pool) listen and re-read at once instead of waiting
+// for their next store event. Import-free leaf.
+const listeners = new Set();
+
+export function onSessionActivityChange(listener) {
+  if (typeof listener !== 'function') return () => {};
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+export function emitSessionActivityChange(sessionId = '') {
+  for (const listener of [...listeners]) {
+    try {
+      listener(String(sessionId || ''));
+    } catch {
+      /* a listener's failure never affects the transition */
+    }
+  }
+}

package/src/runtime/shared/shell-output-summary.mjs

@@ -0,0 +1,23 @@
+// Formatting shared by every surface that hands shell output to an agent.
+// Program output is untrusted text: anything shaped like a harness/system tag
+// is escaped so it can never forge a notice, a result boundary or a reminder.
+// (Capping lives in tools/builtin/lib/shell-delivery.mjs, per-job cursors in
+// tools/builtin/lib/shell-task-output.mjs.)
+
+// A tag-looking token: `<name`, `</name`, where the name is a known
+// harness/system/transcript word or any hyphenated/underscored/namespaced
+// name (task-notification, system-reminder, tool_result, ns:tag ...). Plain
+// HTML-ish words like <div> or a comparison `a<b` stay readable.
+const HARNESS_TAG =
+  /<(\/?)(?=(?:[a-z][\w]*[-_:][\w:-]*|system|result|results|summary|status|error|user|assistant|human|tool|function|functions|instructions|context|notification|reminder|output|invoke|parameter|thinking)\b)/gi;
+
+export function escapeHarnessTags(text) {
+  return String(text ?? '').replace(HARNESS_TAG, '&lt;$1');
+}
+
+export function formatDuration(ms) {
+  if (!(ms >= 0)) return '';
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60_000);
+  return `${minutes}m ${Math.round((ms % 60_000) / 1000)}s`;
+}

package/src/runtime/shared/singleton-owner.mjs

@@ -1,8 +1,23 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, renameSync, rmdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { readFile, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { withFileLock, withFileLockSync } from './file-lock.mjs';
 import { readJsonSafe } from './json-file.mjs';
 import { isPidAlive } from './pid-liveness.mjs';
-import { sleepSync } from './sleep.mjs';
+
+// Claim-lock protocol shared by the sync and async paths: `<path>.claim.lock`
+// is a file-lock.mjs lock, published atomically with its holder's pid and
+// token. A holder whose pid is alive is waited out however long it holds the
+// lock — a holder stalled mid-refresh still owns it: reclaiming it on age let
+// a successor claim the record and the stalled refresh then overwrite it. Its
+// lock is reclaimed only once that pid is dead, and only the holder's own
+// acquisition (pid + token) is ever released. A lock naming no holder — the
+// bare directory versions before this one took the lock with — is reclaimed
+// once older than CLAIM_LOCK_STALE_MS, as those versions did.
+const CLAIM_LOCK_TIMEOUT_MS = 500;
+const CLAIM_LOCK_STALE_MS = 5000;
+const CLAIM_LOCK_OPTS = Object.freeze({ timeoutMs: CLAIM_LOCK_TIMEOUT_MS, staleMs: CLAIM_LOCK_STALE_MS });
+const BUSY = Symbol('claim lock busy');
 
 function writeJsonAtomic(path, value) {
   mkdirSync(dirname(path), { recursive: true });
@@ -11,28 +26,82 @@ function writeJsonAtomic(path, value) {
   renameSync(tmp, path);
 }
 
-function acquireClaimLock(path) {
+// Held by another live process or this one's async holder ('busy'). Any other
+// failure (an unwritable data directory) is thrown, as before.
+function claimLockHeld(error) {
+  return error?.code === 'ELOCKCONTENDED' || (error?.code === 'ELOCKTIMEOUT' && error.cause?.code === 'EEXIST');
+}
+
+function legacyLockStale(info) {
+  return info.isDirectory() && Date.now() - info.mtimeMs > CLAIM_LOCK_STALE_MS;
+}
+
+// An older version's stale bare lock directory is removed with rmdir alone,
+// never recursive or forced: between the stat and the removal a contender may
+// have replaced it with a live owner-named lock file. rmdir refuses a file
+// (ENOENT on Windows, ENOTDIR elsewhere) and a non-empty directory
+// (ENOTEMPTY); a missing path (ENOENT) is already gone. Any refusal (EPERM
+// included) leaves the path untouched to the shared acquire loop below, which
+// waits a live holder out and reclaims only a dead one's lock.
+
+// `fn()` under the claim lock, or BUSY. file-lock creates a missing data
+// directory (a first boot, e.g. a daemon an ssh bootstrap starts on a fresh
+// server).
+function withClaimLockSync(path, fn) {
   const lockPath = `${path}.claim.lock`;
-  // A first boot (e.g. a daemon an ssh bootstrap starts on a fresh server)
-  // has no data directory yet: the lock's parent must exist.
-  mkdirSync(dirname(path), { recursive: true });
-  for (let i = 0; i < 20; i++) {
-    try {
-      mkdirSync(lockPath, { recursive: false });
-      return lockPath;
-    } catch (error) {
-      if (error?.code !== 'EEXIST') throw error;
-      try {
-        const ageMs = Date.now() - statSync(lockPath).mtimeMs;
-        if (ageMs > 5000) {
-          rmSync(lockPath, { recursive: true, force: true });
-          continue;
-        }
-      } catch {}
-      sleepSync(25);
-    }
+  try {
+    if (legacyLockStale(statSync(lockPath))) rmdirSync(lockPath);
+  } catch {}
+  let entered = false;
+  try {
+    return withFileLockSync(
+      lockPath,
+      () => {
+        entered = true;
+        return fn();
+      },
+      CLAIM_LOCK_OPTS
+    );
+  } catch (error) {
+    if (!entered && claimLockHeld(error)) return BUSY;
+    throw error;
+  }
+}
+
+// The same lock taken without blocking the event loop: every file operation
+// and every retry wait is awaited (a synchronous refresh once held the
+// daemon's loop for 20 s in one rmSync under disk contention).
+async function withClaimLock(path, fn) {
+  const lockPath = `${path}.claim.lock`;
+  try {
+    if (legacyLockStale(await stat(lockPath))) await rmdir(lockPath);
+  } catch {}
+  let entered = false;
+  try {
+    return await withFileLock(
+      lockPath,
+      () => {
+        entered = true;
+        return fn();
+      },
+      CLAIM_LOCK_OPTS
+    );
+  } catch (error) {
+    if (!entered && claimLockHeld(error)) return BUSY;
+    throw error;
+  }
+}
+
+function namesOtherPid(record, pid) {
+  return Boolean(record?.pid) && Number(record.pid) !== Number(pid);
+}
+
+async function readJsonSafeAsync(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return null;
   }
-  return null;
 }
 
 // A live pid alone does not prove the record's process still owns it: the OS
@@ -64,18 +133,15 @@ export function claimSingletonOwner(path, { kind = 'runtime', pid = process.pid,
     return { owned: false, owner: current };
   }
 
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
-  try {
+  const result = withClaimLockSync(path, () => {
     const lockedCurrent = readJsonSafe(path);
     if (livePeer(lockedCurrent)) {
       return { owned: false, owner: lockedCurrent };
     }
     writeJsonAtomic(path, owner);
     return { owned: true, owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { owned: false, owner: readJsonSafe(path) } : result;
 }
 
 export function releaseSingletonOwner(path, pid = process.pid) {
@@ -94,16 +160,37 @@ export function releaseSingletonOwner(path, pid = process.pid) {
 // naming another pid is reported, never overwritten ('superseded'); a claim
 // lock held past its wait leaves the record alone ('busy').
 export function refreshSingletonOwner(path, owner) {
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { status: 'busy', owner: null };
-  try {
+  const result = withClaimLockSync(path, () => {
     const current = readJsonSafe(path);
-    if (current?.pid && Number(current.pid) !== Number(owner.pid)) return { status: 'superseded', owner: current };
+    if (namesOtherPid(current, owner.pid)) return { status: 'superseded', owner: current };
     writeJsonAtomic(path, owner);
     return { status: 'refreshed', owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { status: 'busy', owner: null } : result;
+}
+
+/** refreshSingletonOwner without blocking the event loop: the same claim
+ *  lock (mutually exclusive with the sync claim/refresh/handoff), the same
+ *  verdicts, every file operation and retry wait awaited. Its awaited write
+ *  may stall, so the record is read again right before it is replaced: a
+ *  record another pid wrote meanwhile is reported, never overwritten. */
+export async function refreshSingletonOwnerAsync(path, owner) {
+  const result = await withClaimLock(path, async () => {
+    const current = await readJsonSafeAsync(path);
+    if (namesOtherPid(current, owner.pid)) return { status: 'superseded', owner: current };
+    let tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    try {
+      await writeFile(tmp, `${JSON.stringify(owner, null, 2)}\n`);
+      const latest = await readJsonSafeAsync(path);
+      if (namesOtherPid(latest, owner.pid)) return { status: 'superseded', owner: latest };
+      await rename(tmp, path);
+      tmp = null;
+      return { status: 'refreshed', owner };
+    } finally {
+      if (tmp) await rm(tmp, { force: true }).catch(() => {});
+    }
+  });
+  return result === BUSY ? { status: 'busy', owner: null } : result;
 }
 
 // Atomic ownership handoff: replace the owner record from fromPid to toOwner
@@ -113,11 +200,9 @@ export function refreshSingletonOwner(path, owner) {
 // (someone else won), the handoff is refused (owned:false) and the caller
 // should fall back to the winner rather than overwrite it.
 export function handoffSingletonOwner(path, fromPid, toOwner = {}) {
-  const lockPath = acquireClaimLock(path);
-  if (!lockPath) return { owned: false, owner: readJsonSafe(path) };
-  try {
+  const result = withClaimLockSync(path, () => {
     const current = readJsonSafe(path);
-    if (current?.pid && Number(current.pid) !== Number(fromPid)) {
+    if (namesOtherPid(current, fromPid)) {
       return { owned: false, owner: current };
     }
     const owner = {
@@ -127,7 +212,6 @@ export function handoffSingletonOwner(path, fromPid, toOwner = {}) {
     };
     writeJsonAtomic(path, owner);
     return { owned: true, owner };
-  } finally {
-    rmSync(lockPath, { recursive: true, force: true });
-  }
+  });
+  return result === BUSY ? { owned: false, owner: readJsonSafe(path) } : result;
 }

package/src/runtime/shared/slow-span.mjs

@@ -3,8 +3,8 @@
 // monotonic clock the owner heartbeat uses (performance.now), completed spans
 // over `minMs` land in a bounded ring, and spans over `slowMs` are logged as
 // `[slow-op] <label> <ms>`. When the event loop stalls, `describe(from, to)`
-// names the spans that overlapped the stall window. Spans carry labels, phase
-// durations and sizes only — never payloads.
+// names the spans that overlapped the stall window. Spans carry labels and
+// phase durations only — never payloads.
 
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { performance } from 'node:perf_hooks';
@@ -36,18 +36,11 @@ export function markPhase(name) {
   span.mark = t;
 }
 
-/** Records a size (count/bytes) on the caller's span. */
-export function noteSpanSize(size) {
-  const span = current.getStore();
-  if (span && Number.isFinite(size)) span.size = size;
-}
-
 const round = (ms) => Math.round(ms);
 
 function formatSpan(span) {
   const phases = span.phases.map(([name, ms]) => `${name}=${round(ms)}`).join(' ');
-  const size = span.size === undefined ? '' : ` size=${span.size}`;
-  return `${span.label} ${round(span.ms)}ms${phases ? ` ${phases}` : ''}${size}`;
+  return `${span.label} ${round(span.ms)}ms${phases ? ` ${phases}` : ''}`;
 }
 
 export function createSlowSpans({
@@ -70,7 +63,6 @@ export function createSlowSpans({
         end: span.end,
         ms: span.ms,
         phases: span.phases,
-        size: span.size,
       });
       if (ring.length > capacity) ring.shift();
     }
@@ -90,7 +82,7 @@ export function createSlowSpans({
     /** Runs `fn` inside a span; markPhase/annotateSpan inside it attach to this span. */
     async trace(label, fn) {
       const start = now();
-      const span = { label: String(label), start, mark: start, now, phases: [], size: undefined };
+      const span = { label: String(label), start, mark: start, now, phases: [] };
       try {
         return await current.run(span, fn);
       } finally {

package/src/runtime/shared/statusline/statusline-segments.mjs

@@ -200,7 +200,8 @@ async function refreshShellJobsStatus(ownerPid) {
       // its owner retires the record. Its root pid may be gone while a
       // descendant lives, so the owner's liveness decides, not the root's.
       const unconfirmed = detail?.terminationUnconfirmed === true;
-      if (unconfirmed ? !isPidAlive(ownerByJob.get(id) || 0) : !(await isShellJobAlive(detail, p, dir, id))) continue;
+      if (unconfirmed ? !isHeldShellJobAlive(detail, ownerByJob.get(id)) : !(await isShellJobAlive(detail, p, dir, id)))
+        continue;
       // A foreground command is awaited in its own tool card; listing it here
       // made every short command flash in and out of the shell list. Only
       // backgrounded jobs (including promoted ones) are background work.
@@ -326,6 +327,17 @@ function summarizeShellJobs({ count, oldestMs, jobs, bySession }) {
   return { count, elapsedLabel, jobs, sessions };
 }
 
+// A held record lives while its owner process does. Once its owner session
+// has closed, it also needs a process left to hold: the root or a survivor
+// its termination watch last reported. Without one it is an orphan whose
+// processes are gone, and it resolves instead of staying unconfirmed.
+function isHeldShellJobAlive(detail, ownerPid) {
+  if (!isPidAlive(ownerPid || 0)) return false;
+  if (detail?.ownerSessionClosed !== true) return true;
+  const survivors = Array.isArray(detail?.survivorPids) ? detail.survivorPids : [];
+  return [detail?.pid, ...survivors].some((pid) => isPidAlive(positiveInt(pid)));
+}
+
 async function isShellJobAlive(detail, detailPath, dir, id) {
   const pid = positiveInt(detail?.pid);
   if (!pid) return false;

package/src/runtime/shared/tool-output-limit.mjs

@@ -3,6 +3,8 @@
 // context cost of any one tool call is bounded and consistent. Override with
 // MIXDOG_TOOL_OUTPUT_MAX_BYTES. Line-based sub-caps (e.g. bash max lines) stay
 // per-tool; this governs only the byte budget.
+import { capMarker } from './tool-output-marker.mjs';
+export { capMarker, formatCapSize, windowMarker } from './tool-output-marker.mjs';
 // A positive integer from an env var, or `fallback` when unset or invalid.
 export function positiveEnvInt(name, fallback) {
   const v = parseInt(process.env[name], 10);
@@ -53,7 +55,7 @@ export function capLineOrientedToolOutput(result, maxBytes, footerForPrefix) {
   while (lo <= hi) {
     const mid = Math.floor((lo + hi) / 2);
     const kept = lines.slice(0, mid);
-    const footer = String(footerForPrefix?.(kept, lines) || '... [output budget reached; remainder omitted]');
+    const footer = String(footerForPrefix?.(kept, lines) || capMarker({ limit: cap }));
     const candidate = `${kept.join('\n')}${kept.length ? '\n' : ''}${footer}`;
     if (Buffer.byteLength(candidate, 'utf8') <= cap) {
       best = candidate;
@@ -63,5 +65,5 @@ export function capLineOrientedToolOutput(result, maxBytes, footerForPrefix) {
     }
   }
   if (best) return best;
-  return _prefixByBytes(String(footerForPrefix?.([], lines) || '... [output budget reached; remainder omitted]'), cap);
+  return _prefixByBytes(String(footerForPrefix?.([], lines) || capMarker({ limit: cap })), cap);
 }

package/src/runtime/shared/tool-output-marker.mjs

@@ -0,0 +1,58 @@
+// One marker vocabulary for every non-shell tool output that is not the whole
+// answer. Two shapes, never mixed:
+//   window  `[lines a-b of N; offset:N for more]`  the agent asked for this slice
+//   cap     `[output capped at X KB; …; offset:N for more]`  the tool cut it
+// A cap marker always carries the continuation (offset / cursor, else narrowing
+// advice) and, when the complete output was saved, `full output: <path>`.
+
+export function formatCapSize(bytes) {
+  const n = Number(bytes);
+  if (n < 1024) return `${Math.max(0, Math.trunc(n))} bytes`;
+  const kb = n / 1024;
+  return `${Number.isInteger(kb) ? kb : kb.toFixed(1)} KB`;
+}
+
+/**
+ * Requested window: `[lines 5-27 of 90; offset:28 for more]` (no continuation
+ * at the end). `capBytes` marks a window the byte cap shortened:
+ * `[lines 5-27 of 90; output capped at 50 KB; offset:28 for more]`.
+ */
+export function windowMarker({
+  unit = 'lines',
+  from,
+  to,
+  total = null,
+  nextOffset = null,
+  capBytes = null,
+  offsetKey = 'offset',
+}) {
+  const of = total == null ? '' : ` of ${total}`;
+  const cap = capBytes == null ? '' : `; output capped at ${formatCapSize(capBytes)}`;
+  const more = nextOffset == null ? '' : `; ${offsetKey}:${nextOffset} for more`;
+  return `[${unit} ${from}-${to}${of}${cap}${more}]`;
+}
+
+/**
+ * Cap hit. `limit` is bytes (number) or a ready label ("500 rows"). `shown`
+ * says what survived. Continuation is `nextOffset`, else `cursor`, else
+ * `narrow` advice (a default is supplied so it is never missing).
+ */
+export function capMarker({
+  limit,
+  shown = '',
+  nextOffset = null,
+  offsetKey = 'offset',
+  cursor = null,
+  narrow = '',
+  fullPath = '',
+}) {
+  const parts = [`output capped at ${typeof limit === 'number' ? formatCapSize(limit) : limit}`];
+  if (shown) parts.push(shown);
+  if (nextOffset != null) parts.push(`${offsetKey}:${nextOffset} for more`);
+  else if (cursor != null) parts.push(`cursor:${cursor} for more`);
+  if (narrow || (nextOffset == null && cursor == null)) {
+    parts.push(`narrow: ${narrow || 'restrict the path, pattern or scope'}`);
+  }
+  if (fullPath) parts.push(`full output: ${fullPath}`);
+  return `[${parts.join('; ')}]`;
+}

package/src/runtime/shared/transcript-metadata.mjs

@@ -2,6 +2,7 @@
 // These pure helpers keep live rows, persisted messages and restored rows on
 // the same field contract without rewriting older display-only transcripts.
 import { displayModelName } from './model-display.mjs';
+import { routineTriggerField } from './routine-trigger.mjs';
 
 export function transcriptRouteMetadataFields(value) {
   if (!value || typeof value !== 'object') return {};
@@ -76,10 +77,19 @@ export function persistedUserTranscriptMetadata(value) {
     // The turn's change-record key (the outer prompt id), so a restored user
     // row still addresses its turn's Undo/Reapply.
     ...(typeof value.checkpointId === 'string' && value.checkpointId ? { checkpointId: value.checkpointId } : {}),
+    // Every submission a merged queued batch delivered as this turn.
+    ...submissionIdsField(value.submissionIds),
     ...attachmentsField(value.attachments),
+    // A routine fire delivered as this turn (routine-trigger.mjs).
+    ...routineTriggerField(value),
   };
 }
 
+function submissionIdsField(value) {
+  const ids = Array.isArray(value) ? value.filter((id) => typeof id === 'string' && id) : [];
+  return ids.length ? { submissionIds: ids } : {};
+}
+
 function attachmentsField(value) {
   const attachments = normalizeMessageAttachments(value);
   return attachments.length ? { attachments } : {};

package/src/runtime/shared/turn-changes.mjs

@@ -27,7 +27,6 @@ import {
 export const TURN_CHANGE_FILE_PATCH_MAX_BYTES = 8 * 1024 * 1024;
 const APPLY_TIMEOUT_MS = 60_000;
 const APPLY_OUTPUT_MAX_BYTES = 4 * 1024 * 1024;
-const STATUSES = new Set(['A', 'M', 'D', 'R']);
 // Characters a patch header cannot carry unquoted; such a path is recorded but
 // never replayed.
 const UNSAFE_PATH_CHARACTERS = /[\t\n\r"\0]/;
@@ -37,13 +36,6 @@ export function changePathKey(value) {
   return process.platform === 'win32' ? text.toLowerCase() : text;
 }
 
-/** git status letter → record status (copies create a new file). */
-export function normalizeChangeStatus(code) {
-  const letter = String(code || 'M').charAt(0);
-  if (STATUSES.has(letter)) return letter;
-  return letter === 'C' ? 'A' : 'M';
-}
-
 /** A root-relative forward-slash path that a patch may name, or ''. */
 function safeChangePath(value) {
   const text = clean(value).replace(/\\/g, '/');

package/src/runtime/shared/usage-readout-totals.mjs

@@ -0,0 +1,56 @@
+// Session-cumulative figures behind the composer's usage readout, kept on the
+// session record (`session.usageReadout`) so they survive restart, reload and
+// compaction. One fold per model call of the session itself; calls of other
+// sessions (delegated sub-agents have their own records) never enter.
+//
+// - cache hit = cacheRead / (input + cacheRead + cacheWrite) over every call
+//   whose prompt was measured. A call that could not measure its prompt
+//   (promptKnown === false) has unknown zeros, so it adds nothing.
+// - speed = output tokens over generation ms (first visible token → end of the
+//   response) of the calls long enough to time. A reply too short says nothing
+//   about the model's speed, so each call is held to the floors below BEFORE it
+//   is summed.
+// - total tokens = input + cacheRead + cacheWrite + output, from the same sums.
+export const MIN_SPEED_OUTPUT_TOKENS = 20;
+export const MIN_SPEED_MS = 500;
+
+function num(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+/** The zeroed totals record. */
+export function emptyUsageReadout() {
+  return { input: 0, cacheRead: 0, cacheWrite: 0, output: 0, speedOutputTokens: 0, speedMs: 0 };
+}
+
+/**
+ * Fold one `onUsageDelta` event (and the call's generation ms, 0 when it was
+ * not timed) into the totals; returns a new record, never mutates `totals`.
+ * Providers differ on whether input counts cache; the prompt total does not,
+ * so fresh input is the prompt less its cache read/write.
+ */
+export function foldUsageReadout(totals, delta = {}, generationMs = 0) {
+  const base = totals || emptyUsageReadout();
+  const next = { ...base };
+  if (delta.promptKnown !== false) {
+    const cacheRead = num(delta.deltaCachedRead);
+    const cacheWrite = num(delta.deltaCacheWrite);
+    const prompt = num(delta.deltaPrompt) || num(delta.deltaInput) + cacheRead + cacheWrite;
+    next.input = num(base.input) + Math.max(0, prompt - cacheRead - cacheWrite);
+    next.cacheRead = num(base.cacheRead) + cacheRead;
+    next.cacheWrite = num(base.cacheWrite) + cacheWrite;
+  }
+  const output = num(delta.deltaOutput);
+  // Every call's output enters the session's total tokens, timed or not. A
+  // record saved before the field existed has no output sum to extend, and a
+  // partial one would pass for the whole: it stays without until the session
+  // starts over.
+  if (Number.isFinite(base.output)) next.output = base.output + output;
+  const ms = num(generationMs);
+  if (ms >= MIN_SPEED_MS && output >= MIN_SPEED_OUTPUT_TOKENS) {
+    next.speedOutputTokens = num(base.speedOutputTokens) + output;
+    next.speedMs = num(base.speedMs) + ms;
+  }
+  return next;
+}