@vzn/vx 0.0.645 → 0.0.648

package/src/orchestrator/telemetry.ts

@@ -16,7 +16,7 @@
 // what or how tasks run. Contrast `cache`/`executor`, which return objects
 // core calls INTO; those are the behavior capabilities, kept separate.
 
-import { sampleTrees } from '../exec/index.js'
+import { sampleTrees, type MachineReport } from '../exec/index.js'
 import {
   type CacheSource,
   deriveCacheSource,
@@ -27,7 +27,13 @@ import {
   type TaskOutcome,
   type TaskStatus,
 } from '../graph/index.js'
-import { maskedCommand, settleWithin, teardownTimeoutMs } from '../util/index.js'
+import {
+  maskedCommand,
+  settleWithin,
+  stageTimes,
+  teardownTimeoutMs,
+  thrownMessage,
+} from '../util/index.js'
 import type { RunEvent, RunEventSubscriber } from '../report/index.js'
 
 /** Bumped when the record shape changes. Readers MUST check `v`. */
@@ -114,6 +120,10 @@ export interface TaskTelemetry {
   /** Executor-reported placement (a worker id) — absent for local runs.
    *  Additive-optional, no schema bump (the `attempts` precedent). */
   where?: string
+  /** A persistent task each dependant's executor started where that ran:
+   *  part of those runs, never an execution of its own (2026-10-23:
+   *  nothing runs on a distributed run's orchestrator). Additive-optional. */
+  carried?: true
   /** `'deferred'` when the outputs stayed remote (`--cache-download=none`).
    *  Additive-optional, same no-bump precedent as `where`. */
   outputs?: 'deferred'
@@ -127,6 +137,8 @@ export interface TaskTelemetry {
    * fail-fast skip and on every other status. Additive (schema stays 2).
    */
   blockedBy?: string
+  /** On a `skipped` task: its `exec.platforms` leave out the machine that ran the run. Additive. */
+  otherPlatform?: { readonly needs: readonly string[]; readonly host: string }
   /** On a `failed` task: vx's own `timeout` killed it (exit 143 is the deadline, not a signal). Additive. */
   timedOut?: true
   /** On a sandboxed task: how many declared-boundary violations the sandbox recorded (a failure on its own). Additive. */
@@ -188,6 +200,10 @@ export type TelemetryRecord =
       /** The run's canonical start (epoch ms) — equals the summary's
        *  `startedAt`; a sink derives per-task timing from it during the run. */
       startedAt: number
+      /** Where the run's stage table begins (epoch ms), the first stage's
+       *  start: at or before `startedAt`. A sink that draws the stages
+       *  starts the run here. Additive. */
+      originAt?: number
     }
   | {
       v: number
@@ -274,6 +290,17 @@ export interface RunSummaryRecord {
    * Absent when nothing was uploaded or tried. Additive.
    */
   uploads?: { count: number; bytes: number; ms: number; failed: number }
+  /**
+   * The machines an executor plugin ran tasks on, with what each did
+   * (`TaskExecutor.machines`); a task's `where` names one. Absent when no
+   * executor reports any. Additive.
+   */
+  machines?: readonly MachineReport[]
+  /**
+   * The run's end had an executor placed its tasks perfectly
+   * (`TaskExecutor.idealMs`), beside `totalDurationMs`. Additive.
+   */
+  idealMs?: number
 }
 
 /** One stage of a run, a wall window in epoch ms. */
@@ -305,6 +332,8 @@ export function assembleRunSummary(
     abortedCount: number
     stages?: readonly RunStage[]
     uploads?: { count: number; bytes: number; ms: number; failed: number }
+    machines?: readonly MachineReport[]
+    idealMs?: number | undefined
   },
 ): RunSummaryRecord {
   let failedCount = 0
@@ -343,6 +372,10 @@ export function assembleRunSummary(
     ...(timing.uploads !== undefined && timing.uploads.count + timing.uploads.failed > 0
       ? { uploads: { ...timing.uploads } }
       : {}),
+    ...(timing.machines !== undefined && timing.machines.length > 0
+      ? { machines: timing.machines }
+      : {}),
+    ...(timing.idealMs !== undefined ? { idealMs: timing.idealMs } : {}),
   }
 }
 
@@ -400,12 +433,25 @@ export interface TelemetrySource {
    * Sample this task's process tree every `SAMPLE_MS` until the returned
    * function is called, the root exits, or the run ends. Present only when
    * a sink wants `task.sample`: nobody asking costs no timer and no read.
+   * The returned stop answers what the samples saw, for the run history.
    */
-  readonly track?: (taskId: string, pid: number) => () => void
+  readonly track?: (taskId: string, pid: number) => () => TreeLoad | undefined
+}
+
+/**
+ * What a tracked task's samples saw: the most cores one interval between
+ * looks burned, and the mean resident memory over the looks. Undefined
+ * when no look landed (a task shorter than `SAMPLE_MS`).
+ */
+export interface TreeLoad {
+  peakCores: number
+  avgRssBytes: number
 }
 
 /** How often a running task's process tree is sampled. */
 const SAMPLE_MS = 1000
+/** How long an aborted flush may take to end its own requests. */
+const ABORT_GRACE_MS = 250
 
 /** Call `fn` every `ms` until the returned stop is called. */
 type Every = (ms: number, fn: () => Promise<void>) => () => void
@@ -468,7 +514,7 @@ export function createTelemetrySource(args: {
     if (disabled.has(sink)) return
     disabled.add(sink)
     warn?.(
-      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+      `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${thrownMessage(err)}`,
     )
   }
   // Precompute which sinks want each kind, so per-event fan-out is a plain
@@ -476,10 +522,18 @@ export function createTelemetrySource(args: {
   const wantsLog = sinks.some((s) => (s.wants ?? DEFAULT_KINDS).includes('task.log'))
   const wantsSample = sinks.some((s) => (s.wants ?? DEFAULT_KINDS).includes('task.sample'))
 
-  // taskId → the pid of its running root. One timer for every task, alive
-  // only while one runs; a tick still reading when the next is due is not
-  // doubled.
-  const tracked = new Map<string, number>()
+  // taskId → its running root and what the looks at it saw. One timer for
+  // every task, alive only while one runs; a tick still reading when the
+  // next is due is not doubled.
+  interface Tracked {
+    pid: number
+    lastTs: number
+    lastCpuMs: number
+    peakCores: number
+    rssSum: number
+    looks: number
+  }
+  const tracked = new Map<string, Tracked>()
   const every = args.every ?? everyInterval
   let stopEvery: (() => void) | undefined
   let sampling = false
@@ -488,8 +542,8 @@ export function createTelemetrySource(args: {
     stopEvery?.()
     stopEvery = undefined
   }
-  const untrack = (taskId: string, pid: number): void => {
-    if (tracked.get(taskId) === pid) tracked.delete(taskId)
+  const untrack = (taskId: string, t: Tracked): void => {
+    if (tracked.get(taskId) === t) tracked.delete(taskId)
     if (tracked.size === 0) stopTimer()
   }
   const tick = async (): Promise<void> => {
@@ -497,15 +551,23 @@ export function createTelemetrySource(args: {
     sampling = true
     try {
       const entries = [...tracked]
-      const usage = await sampleTrees(entries.map(([, pid]) => pid))
+      const usage = await sampleTrees(entries.map(([, t]) => t.pid))
       const ts = Date.now()
-      for (const [taskId, pid] of entries) {
-        if (ended || tracked.get(taskId) !== pid) continue
-        const u = usage.get(pid)
+      for (const [taskId, t] of entries) {
+        if (ended || tracked.get(taskId) !== t) continue
+        const u = usage.get(t.pid)
         if (u === undefined) {
-          untrack(taskId, pid)
+          untrack(taskId, t)
           continue
         }
+        // A descendant that exited takes its CPU out of the live sum, so an
+        // interval can read negative: it says nothing of the peak.
+        const ms = ts - t.lastTs
+        if (ms > 0) t.peakCores = Math.max(t.peakCores, (u.cpuMs - t.lastCpuMs) / ms)
+        t.lastTs = ts
+        t.lastCpuMs = u.cpuMs
+        t.rssSum += u.rssBytes
+        t.looks++
         deliver({
           v: TELEMETRY_SCHEMA_VERSION,
           kind: 'task.sample',
@@ -522,11 +584,17 @@ export function createTelemetrySource(args: {
       sampling = false
     }
   }
-  const track = (taskId: string, pid: number): (() => void) => {
-    if (ended) return () => {}
-    tracked.set(taskId, pid)
+  const track = (taskId: string, pid: number): (() => TreeLoad | undefined) => {
+    if (ended) return () => undefined
+    const t: Tracked = { pid, lastTs: Date.now(), lastCpuMs: 0, peakCores: 0, rssSum: 0, looks: 0 }
+    tracked.set(taskId, t)
     stopEvery ??= every(SAMPLE_MS, tick)
-    return () => untrack(taskId, pid)
+    return () => {
+      untrack(taskId, t)
+      return t.looks === 0
+        ? undefined
+        : { peakCores: t.peakCores, avgRssBytes: Math.round(t.rssSum / t.looks) }
+    }
   }
 
   function deliver(record: TelemetryRecord): void {
@@ -556,6 +624,7 @@ export function createTelemetrySource(args: {
           total: event.info.total,
           ts,
           startedAt: event.info.startedAtMs ?? ts,
+          ...originOf(),
         })
         return
       case 'task:start': {
@@ -639,28 +708,26 @@ export function createTelemetrySource(args: {
       // accessed_at bumps and every later plugin's teardown lost with it.
       // Sinks race concurrently, so each still gets the whole budget.
       const deadline = new AbortController()
-      const settled = await settleWithin(
-        Promise.all(
-          sinks.map(async (sink) => {
-            if (disabled.has(sink) || sink.flush === undefined) return
-            try {
-              await step(`${args.owners?.get(sink) ?? label(sink)}:telemetry`, () =>
-                sink.flush!(deadline.signal),
-              )
-            } catch (err) {
-              // A flush failure can never break the run — but it still costs
-              // this sink its export, so say so rather than dropping it.
-              warn?.(
-                `[vx] telemetry sink '${label(sink)}' failed to flush: ${err instanceof Error ? err.message : String(err)}`,
-              )
-            }
-          }),
-        ),
-        ms,
+      const all = Promise.all(
+        sinks.map(async (sink) => {
+          if (disabled.has(sink) || sink.flush === undefined) return
+          try {
+            await step(`${args.owners?.get(sink) ?? label(sink)}:telemetry`, () =>
+              sink.flush!(deadline.signal),
+            )
+          } catch (err) {
+            // A flush failure can never break the run — but it still costs
+            // this sink its export, so say so rather than dropping it.
+            warn?.(`[vx] telemetry sink '${label(sink)}' failed to flush: ${thrownMessage(err)}`)
+          }
+        }),
       )
-      if (!settled) {
+      if (!(await settleWithin(all, ms))) {
         deadline.abort(new Error(`telemetry flush deadline (${ms}ms)`))
         warn?.(`[vx] telemetry flush timed out after ${ms}ms; buffered records lost`)
+        // A sink told of the abort says what it lost as its request ends; the
+        // run ended first and that line was lost (vx-otel, on CI). Briefly.
+        await settleWithin(all, ABORT_GRACE_MS)
       }
     },
   }
@@ -704,9 +771,11 @@ export function taskTelemetryOf(o: TaskOutcome): TaskTelemetry {
   if (o.cpuMs !== undefined) t.cpuMs = o.cpuMs
   if (o.peakRssBytes !== undefined) t.peakRssBytes = o.peakRssBytes
   if (o.where !== undefined) t.where = o.where
+  if (o.carried === true) t.carried = true
   if (o.outputs !== undefined) t.outputs = o.outputs
   if (o.attempts !== undefined) t.attempts = o.attempts
   if (o.blockedBy !== undefined) t.blockedBy = o.blockedBy
+  if (o.otherPlatform !== undefined) t.otherPlatform = o.otherPlatform
   if (o.timedOut === true) t.timedOut = true
   if (o.sandboxViolations !== undefined) t.sandboxViolations = o.sandboxViolations
   if (o.notReady !== undefined) t.notReady = o.notReady
@@ -730,3 +799,9 @@ export function taskTelemetryOf(o: TaskOutcome): TaskTelemetry {
   if (o.wallclockEndNs !== undefined) t.wallclockEndNs = o.wallclockEndNs.toString()
   return t
 }
+
+/** The stage table's start, when a stage was marked. */
+function originOf(): { originAt?: number } {
+  const first = stageTimes()[0]
+  return first === undefined ? {} : { originAt: first.startedAt }
+}

package/src/orchestrator/upstream.ts

@@ -24,6 +24,21 @@ export function keyUpstream(node: TaskNode, upstream: TaskOutcome[]): TaskOutcom
   return node.excludedUpstream === undefined ? keyed : [...keyed, ...node.excludedUpstream]
 }
 
+/** The ids some task of the run depends on; the rest run with `noDependants`. */
+export function dependedOn(nodes: Iterable<TaskNode>): Set<string> {
+  const ids = new Set<string>()
+  for (const n of nodes) for (const d of n.deps) ids.add(d)
+  return ids
+}
+
+/**
+ * A server's key is read only by a dependant (A-17), so with none in the
+ * run it derives none (`noDependants`), and the plan must not show one.
+ */
+export function keylessServer(node: TaskNode, depended: ReadonlySet<string>): boolean {
+  return node.config.exec?.persistent !== undefined && !depended.has(node.id)
+}
+
 /** A dependency as a key reads it: only `node` and `hash` matter. */
 export function keyedOutcome(node: TaskNode, hash: string | undefined): TaskOutcome {
   const o: TaskOutcome = { node, status: 'success', exitCode: 0, durationMs: 0 }

package/src/report/events.ts

@@ -9,7 +9,7 @@
 import { exitSignal } from '../exec/index.js'
 import type { InputChanges, TaskNode, TaskOutcome } from '../graph/index.js'
 import { isGroupTask } from '../graph/index.js'
-import { maskedCommand, secretMask } from '../util/index.js'
+import { heldSecrets, maskedCommand, type SecretMask, secretMask } from '../util/index.js'
 import type { Logger } from './logger.js'
 import type { RunContext } from './summary.js'
 
@@ -122,10 +122,19 @@ export function busLogger(bus: EventBus): Logger {
   let done = false
   // A status line carries plugin warnings, and a remote layer's warning
   // quotes the server's reply, which may echo what it was sent (L-40).
-  const secrets = secretMask([process.env])
+  // Built again once a plugin's keychain answered: its token is in no env.
+  let secrets: SecretMask | null = null
+  let built = -1
+  const masked = (line: string): string => {
+    if (built !== heldSecrets()) {
+      built = heldSecrets()
+      secrets = secretMask([process.env])
+    }
+    return secrets?.mask(line) ?? line
+  }
   return {
-    status: (line) => bus.emit({ kind: 'run:status', line: secrets?.mask(line) ?? line }),
-    warn: (line) => bus.emit({ kind: 'run:status', line: secrets?.mask(line) ?? line, warn: true }),
+    status: (line) => bus.emit({ kind: 'run:status', line: masked(line) }),
+    warn: (line) => bus.emit({ kind: 'run:status', line: masked(line), warn: true }),
     taskStdout: (node, chunk) => bus.emit({ kind: 'task:stdout', node, chunk }),
     taskStderr: (node, chunk) => bus.emit({ kind: 'task:stderr', node, chunk }),
     taskComplete: (node, outcome) => bus.emit({ kind: 'task:complete', node, outcome }),
@@ -212,7 +221,7 @@ export function terminalSubscriber(sink: Logger): RunEventSubscriber {
 export function wireForwarder(send: (event: WireEvent) => void): RunEventSubscriber {
   // Which tasks the consumer has been told about. A skipped task never
   // reaches the scheduler's onStart, so its completion arrives with no
-  // preceding task:start — and `createWireRenderer` resolves a completion's
+  // preceding task:start — and a consumer resolves a completion's
   // node from the start it recorded, so it would drop the task entirely
   // while the forwarded footer still counted it. Synthesize the start here,
   // where the live TaskNode is in hand, so the projection stays full
@@ -292,6 +301,8 @@ export interface OutcomeView {
   /** A skipped task: the failed (or aborted) task at the root of the block
    *  (see `TaskOutcome`); absent for fail-fast's skip, which nothing blocked. */
   blockedBy?: string
+  /** A skipped task whose `exec.platforms` leave out this machine (see `TaskOutcome`). */
+  otherPlatform?: { readonly needs: readonly string[]; readonly host: string }
   /** How long an `admit` policy held the task with a worker free (see `TaskOutcome`). */
   admissionHeldMs?: number
   /** How long the task waited ready for a worker (see `TaskOutcome`). */
@@ -319,7 +330,8 @@ export interface OutcomeView {
  * header and footer, the focused one-liner, the hash-only audit line,
  * the verbose summary table: `success` / `restored-local` /
  * `restored-remote` / `up-to-date` / `failed` / `skipped`. A hit that
- * materialized nothing is up-to-date whichever layer answered.
+ * materialized nothing is up-to-date; a remote hit always restored
+ * (`hitOutcome`), so it is never up to date.
  */
 export function outcomeWord(o: Pick<OutcomeView, 'status' | 'restored'>): string {
   switch (o.status) {
@@ -344,26 +356,32 @@ export function outcomeLabel(
     | 'notReady'
     | 'inputMoved'
     | 'blockedBy'
+    | 'otherPlatform'
   >,
 ): string {
   if (o.status === 'failed')
     return failedLabel(o.exitCode, o.timedOut, o.sandboxViolations, o.notReady, o.inputMoved)
-  if (o.status === 'skipped') return skippedLabel(o.blockedBy)
+  if (o.status === 'skipped') return skippedLabel(o)
   return outcomeWord(o)
 }
 
 /**
- * Why a task was skipped, one copy for every surface: `blocked by lib#build`
- * (the failed or aborted task at the root of the block), or '' for fail-fast's skip — the run stopped,
+ * Why a task was skipped, one copy for every surface: `needs darwin-arm64,
+ * this is linux-x64` (its `exec.platforms`), `blocked by lib#build` (the
+ * task at the root of the block), or '' for fail-fast's skip — the run stopped,
  * nothing blocked it, and a label claiming an upstream failure would lie.
  */
-export function skippedReason(blockedBy: string | undefined): string {
-  return blockedBy === undefined ? '' : `blocked by ${blockedBy}`
+export function skippedReason(o: SkipView = {}): string {
+  if (o.otherPlatform !== undefined)
+    return `needs ${o.otherPlatform.needs.join(' or ')}, this is ${o.otherPlatform.host}`
+  return o.blockedBy === undefined ? '' : `blocked by ${o.blockedBy}`
 }
 
+type SkipView = Pick<OutcomeView, 'blockedBy' | 'otherPlatform'>
+
 /** `skipped (blocked by lib#build)`, or a bare `skipped` for fail-fast's. */
-function skippedLabel(blockedBy: string | undefined): string {
-  const why = skippedReason(blockedBy)
+function skippedLabel(o: SkipView): string {
+  const why = skippedReason(o)
   return why === '' ? 'skipped' : `skipped (${why})`
 }
 
@@ -448,6 +466,7 @@ export function projectOutcome(outcome: TaskOutcome): OutcomeView {
   if (outcome.notReady !== undefined) view.notReady = outcome.notReady
   if (outcome.inputMoved !== undefined) view.inputMoved = outcome.inputMoved
   if (outcome.blockedBy !== undefined) view.blockedBy = outcome.blockedBy
+  if (outcome.otherPlatform !== undefined) view.otherPlatform = outcome.otherPlatform
   if (outcome.restored !== undefined) view.restored = outcome.restored
   if (outcome.sandboxViolations !== undefined) view.sandboxViolations = outcome.sandboxViolations
   if (outcome.sandboxViolationLines !== undefined)

package/src/report/forecast.ts

@@ -10,16 +10,23 @@ export interface LiveForecast {
   etaMs?: number
   /** The running task at the head of the longest unfinished chain. */
   critical?: string
-  /** Each running task's unfinished dependents, direct and transitive. */
-  blocks: ReadonlyMap<string, number>
+  /** Tasks not started because a dependency has not finished: the tasks line's `blocked`. */
+  waiting: number
   /** Each running task's p50, where history knows it: the row's expected duration. */
   expected?: ReadonlyMap<string, number>
   /**
    * Tasks not started because a dependency has not finished, in the order
    * the scheduler would start them, at most one per worker: what an idle
-   * worker row holds (M, 2026-10-15).
+   * worker row holds (2026-10-15).
    */
   blocked?: readonly BlockedTask[]
+  /**
+   * Each running task's count of the tasks not started that depend on it
+   * directly (through a group, which runs nothing): its row's `blocked`
+   * cell, why they are not running. A task waiting on two running tasks
+   * counts under both.
+   */
+  blockedBy: ReadonlyMap<string, number>
 }
 
 /** A task an unfinished dependency holds back, and what holds it: the running task its longest chain waits on, else that dependency. */
@@ -34,16 +41,13 @@ export type Forecast = (
   nowMs: number,
 ) => LiveForecast
 
-/** How far past its p50 a running task may go before the forecast gives up. */
-const OVERRUN = 1.25
-
 /**
  * The later of the longest unfinished chain and the unfinished work spread
  * over the workers. A task still to run costs its p50 (a pending task may
  * yet hit, so this leans long, and the hits finish first); a running one
  * costs what its p50 has left, never below zero; a group or a task with no
- * history costs nothing. A running task well past its p50 means history
- * no longer describes this run, and the forecast says nothing of time.
+ * history costs nothing. Zero while tasks still run means the run is past
+ * its estimate: the live region counts the time since (2026-10-27).
  */
 export function createForecast(
   nodes: ReadonlyMap<string, TaskNode>,
@@ -84,37 +88,31 @@ export function createForecast(
   // graph order: once per run, as the scheduler computes it.
   const rank = computeReverseDepCount(nodes)
   const position = new Map(order.map((n, i) => [n.id, i]))
+  // The tasks each node waits on directly, a group's own looked through.
+  const direct = new Map<string, readonly string[]>()
+  const through = (id: string, into: Set<string>, seen: Set<string>): void => {
+    if (seen.has(id)) return
+    seen.add(id)
+    const d = nodes.get(id)
+    if (d === undefined || !isGroupTask(d)) into.add(id)
+    else for (const x of d.deps) through(x, into, seen)
+  }
+  for (const n of order) {
+    if (isGroupTask(n) || n.deps.length === 0) continue
+    const into = new Set<string>()
+    const seen = new Set<string>()
+    for (const d of n.deps) through(d, into, seen)
+    direct.set(n.id, [...into])
+  }
   const before = (a: string, b: string): boolean => {
     const d = (rank.get(a) ?? 0) - (rank.get(b) ?? 0)
     return d !== 0 ? d > 0 : position.get(a)! < position.get(b)!
   }
 
-  const dependents = new Map<string, string[]>()
-  for (const n of order)
-    for (const d of n.deps) {
-      const list = dependents.get(d)
-      if (list === undefined) dependents.set(d, [n.id])
-      else list.push(n.id)
-    }
-
-  const blocked = (id: string, finished: ReadonlySet<string>): number => {
-    const seen = new Set<string>()
-    const stack = [id]
-    while (stack.length > 0) {
-      for (const next of dependents.get(stack.pop()!) ?? []) {
-        if (seen.has(next) || finished.has(next)) continue
-        seen.add(next)
-        stack.push(next)
-      }
-    }
-    return seen.size
-  }
-
   return (finished, running, nowMs) => {
-    const blocks = new Map<string, number>()
     const expected = new Map<string, number>()
+    let waiting = 0
     for (const id of running.keys()) {
-      blocks.set(id, blocked(id, finished))
       const p = cost.get(id)
       if (p !== undefined) expected.set(id, p)
     }
@@ -125,9 +123,9 @@ export function createForecast(
     let chainEnd: string | undefined
     let work = 0
     let known = false
-    let overrun = false
     // The best `workers` blocked tasks, kept sorted as the pass meets them.
     const held: BlockedTask[] = []
+    const blockedBy = new Map<string, number>()
     for (const n of order) {
       if (finished.has(n.id)) continue
       let start = 0
@@ -145,6 +143,9 @@ export function createForecast(
       const by =
         since === undefined ? (head.get(n.id) ?? n.deps.find((d) => end.has(d))) : undefined
       if (by !== undefined && !isGroupTask(n)) {
+        waiting++
+        for (const on of direct.get(n.id) ?? [])
+          if (running.has(on)) blockedBy.set(on, (blockedBy.get(on) ?? 0) + 1)
         let at = held.length
         while (at > 0 && before(n.id, held[at - 1]!.id)) at--
         if (at < workers) {
@@ -156,7 +157,6 @@ export function createForecast(
       let own = 0
       if (p !== undefined) {
         known = true
-        if (since !== undefined && nowMs - since > p * OVERRUN) overrun = true
         own = since === undefined ? p : Math.max(0, p - (nowMs - since))
       }
       const e = start + own
@@ -167,14 +167,15 @@ export function createForecast(
       }
       work += own
     }
-    if (!known || overrun) return { blocks, expected, blocked: held }
+    if (!known) return { waiting, expected, blocked: held, blockedBy }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
       ...(critical !== undefined ? { critical } : {}),
-      blocks,
+      waiting,
       expected,
       blocked: held,
+      blockedBy,
     }
   }
 }