@vzn/vx 0.0.650 → 0.0.652

package/src/graph/priorities.ts

@@ -156,29 +156,47 @@ export function computeReverseDepCount(
   /** Count only these dependents (the exec tier); every one when absent. */
   counted?: ReadonlyMap<string, unknown>,
 ): Map<string, number> {
+  return reverseDepCountsOver(nodes, [counted])[0]!
+}
+
+/**
+ * `computeReverseDepCount` once per entry of `counted`, from ONE closure:
+ * the closure is the cost (~100 ms at 11k nodes, 2026-10-29), each count
+ * one popcount pass over it.
+ */
+function reverseDepCountsOver(
+  nodes: ReadonlyMap<string, TaskNode>,
+  counted: ReadonlyArray<ReadonlyMap<string, unknown> | undefined>,
+): Map<string, number>[] {
   // Exact transitive-dependent COUNTS need closure SETS (diamonds
   // double-count under naive summing). Set-of-strings closures are
   // O(N²) entries and took 8.5s on a 1090-package, 100-layer repo;
-  // bitsets make the same closure O(E·N/32) time and N²/8 bits of
-  // memory (3270 tasks ≈ 1.3 MB) — single-digit ms at that scale.
+  // bitsets make the same closure O(E·N/32) time over N²/8 bits
+  // (3270 tasks ≈ 1.3 MB) — single-digit ms at that scale.
   const ids = [...nodes.keys()]
-  const index = new Map<string, number>()
-  for (let i = 0; i < ids.length; i++) index.set(ids[i]!, i)
   const n = ids.length
-  const words = (n + 31) >>> 5
+  const index = new Map<string, number>()
+  for (let i = 0; i < n; i++) index.set(ids[i]!, i)
 
-  // Direct dependents as index lists + in-degree for the topo pass.
-  const directReverse: number[][] = Array.from({ length: n }, () => [])
+  // Direct dependents as one flat list (offsets per node) + in-degree.
+  const from: number[] = []
+  const to: number[] = []
+  const offset = new Int32Array(n + 1)
   const indegree = new Uint32Array(n)
-  for (const node of nodes.values()) {
-    const ni = index.get(node.id)!
-    for (const dep of node.deps) {
+  for (let ni = 0; ni < n; ni++) {
+    for (const dep of nodes.get(ids[ni]!)!.deps) {
       const di = index.get(dep)
       if (di === undefined) continue
-      directReverse[di]!.push(ni)
+      from.push(di)
+      to.push(ni)
+      offset[di + 1]!++
       indegree[ni]!++
     }
   }
+  for (let i = 0; i < n; i++) offset[i + 1]! += offset[i]!
+  const next = offset.slice(0, n)
+  const dependents = new Int32Array(from.length)
+  for (let e = 0; e < from.length; e++) dependents[next[from[e]!]!++] = to[e]!
 
   // Kahn topo order over dependency edges (deps before dependents).
   // Insertion order is topo today, but the closure's correctness
@@ -189,48 +207,84 @@ export function computeReverseDepCount(
   for (let i = 0; i < n; i++) if (indegree[i] === 0) topo[tail++] = i
   while (head < tail) {
     const v = topo[head++]!
-    for (const r of directReverse[v]!) {
+    for (let k = offset[v]!; k < offset[v + 1]!; k++) {
+      const r = dependents[k]!
       if (--indegree[r]! === 0) topo[tail++] = r
     }
   }
 
-  // Reverse-topo sweep: every direct dependent's closure is final
-  // before its dependency folds it in. closure[t] = bitset over topo
-  // POSITIONS of the node at position t's transitive dependents. A
-  // dependent sits after its dependency, so a closure holds only bits
-  // past its own position, and each OR starts at the dependent's word:
-  // half the words of indexing by insertion order on a layered graph.
+  // The same lists by topo POSITION. A dependent sits after its
+  // dependency, so a closure holds only bits past its own position.
   const pos = new Int32Array(n)
   for (let t = 0; t < tail; t++) pos[topo[t]!] = t
-  const mask = new Uint32Array(words)
-  if (counted === undefined) mask.fill(0xffffffff)
-  else
-    for (let t = 0; t < tail; t++) if (counted.has(ids[topo[t]!]!)) mask[t >>> 5]! |= 1 << (t & 31)
-  const closure = new Uint32Array(n * words)
-  const counts = new Map<string, number>()
-  for (let t = tail - 1; t >= 0; t--) {
+  const start = new Int32Array(tail + 1)
+  for (let t = 0; t < tail; t++) {
     const i = topo[t]!
-    const base = t * words
-    for (const ri of directReverse[i]!) {
-      const r = pos[ri]!
-      closure[base + (r >>> 5)]! |= 1 << (r & 31)
-      const rbase = r * words
-      for (let w = r >>> 5; w < words; w++) closure[base + w]! |= closure[rbase + w]!
-    }
-    let count = 0
-    for (let w = t >>> 5; w < words; w++) {
-      let v = closure[base + w]! & mask[w]!
-      v = v - ((v >>> 1) & 0x55555555)
-      v = (v & 0x33333333) + ((v >>> 2) & 0x33333333)
-      count += (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24
+    start[t + 1] = start[t]! + offset[i + 1]! - offset[i]!
+  }
+  const rev = new Int32Array(start[tail]!)
+  for (let t = 0; t < tail; t++) {
+    const i = topo[t]!
+    let k = start[t]!
+    for (let j = offset[i]!; j < offset[i + 1]!; j++) rev[k++] = pos[dependents[j]!]!
+  }
+  const words = (tail + 31) >>> 5
+  const masks = counted.map((only) => {
+    const mask = new Uint32Array(words)
+    if (only === undefined) mask.fill(0xffffffff)
+    else
+      for (let t = 0; t < tail; t++) if (only.has(ids[topo[t]!]!)) mask[t >>> 5]! |= 1 << (t & 31)
+    return mask
+  })
+
+  // Reverse-topo sweeps, one per block of `span` words: every node's
+  // closure restricted to the block's positions, its count summed over
+  // the blocks. All N rows of all words (9,603 tasks: 11.5 MB) missed
+  // the cache on nearly every OR, and the first call, the only one a run
+  // makes, took 77 ms; a block of ~256 KB took 37 (2026-10-29). A
+  // dependent past the block holds no bit in it, so its edge is skipped.
+  const span = Math.max(1, Math.min(words, Math.floor(65536 / Math.max(1, tail))))
+  const totals = masks.map(() => new Int32Array(tail))
+  const closure = new Uint32Array(tail * span)
+  for (let w0 = 0; w0 < words; w0 += span) {
+    const width = Math.min(words, w0 + span) - w0
+    const end = Math.min(tail, (w0 + width) << 5)
+    if (w0 > 0) closure.fill(0, 0, end * span)
+    for (let t = end - 1; t >= 0; t--) {
+      const base = t * span
+      for (let k = start[t]!; k < start[t + 1]!; k++) {
+        const r = rev[k]!
+        if (r >= end) continue
+        const rw = r >>> 5
+        if (rw >= w0) closure[base + rw - w0]! |= 1 << (r & 31)
+        const rbase = r * span
+        for (let w = rw > w0 ? rw - w0 : 0; w < width; w++)
+          closure[base + w]! |= closure[rbase + w]!
+      }
+      for (let m = 0; m < masks.length; m++) {
+        const mask = masks[m]!
+        let count = 0
+        for (let w = t >>> 5 > w0 ? (t >>> 5) - w0 : 0; w < width; w++) {
+          let v = closure[base + w]! & mask[w0 + w]!
+          if (v === 0) continue
+          v = v - ((v >>> 1) & 0x55555555)
+          v = (v & 0x33333333) + ((v >>> 2) & 0x33333333)
+          count += (((v + (v >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24
+        }
+        totals[m]![t]! += count
+      }
     }
-    counts.set(ids[i]!, count)
   }
-  // Cycle-stranded nodes (never topo-visited) can't occur — the graph
-  // builder rejects cycles — but a missing Map entry would silently
-  // sort as undefined, so default them defensively to 0.
-  for (const id of ids) if (!counts.has(id)) counts.set(id, 0)
-  return counts
+  const all = totals.map((total) => {
+    const counts = new Map<string, number>()
+    for (let t = 0; t < tail; t++) counts.set(ids[topo[t]!]!, total[t]!)
+    // Cycle-stranded nodes (never topo-visited) can't occur — the graph
+    // builder rejects cycles — but a missing Map entry would silently
+    // sort as undefined, so default them defensively to 0.
+    for (const id of ids) if (!counts.has(id)) counts.set(id, 0)
+    return counts
+  })
+  return all
 }
 
 /**

package/src/graph/scheduler.ts

@@ -5,8 +5,8 @@ import {
   isUserError,
   OUT_OF_FDS_HINT,
   thrownMessage,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import {
   computeReverseDepCount,
   mergePriorities,
@@ -89,7 +89,8 @@ export interface TaskOutcome {
    */
   artifactBytes?: number
   /**
-   * The raw bytes of a hit's outputs: the entry's files as restored.
+   * The raw bytes of the task's outputs: on a hit, the entry's files as
+   * restored; on a miss, the files its save stored (the row waits for it).
    */
   outputBytes?: number
   /** On a remote hit this run pulled: the download and its ingest. */
@@ -185,7 +186,7 @@ export interface TaskOutcome {
   serverExit?: number
   /**
    * The input that changed while the command ran, failing the task under
-   * `inputStability.severity: 'error'` (workspace-relative; '' when vx
+   * `inputs.stability.severity: 'error'` (workspace-relative; '' when vx
    * could not name it). The exit is vx's 1; the label reads this instead.
    */
   inputMoved?: string
@@ -230,6 +231,8 @@ export interface TaskOutcome {
   attempts?: number
   /** The attempts that failed and were run again, in order: when each ended (epoch ms) and how. */
   failedAttempts?: readonly { endedAt: number; exitCode: number; timedOut?: true }[]
+  /** Each of `failedAttempts`' output, as `failedOutput` encodes it: what `vx last --log` shows. */
+  attemptOutputs?: readonly string[]
   /**
    * Set when this run proved the task flaky: its key failed after it had
    * passed (this run's included) or it passed only on a retry. Its row carries it.
@@ -308,8 +311,7 @@ export interface ScheduleOptions {
    */
   onFailFast?: () => void
   execute: (node: TaskNode, upstream: TaskOutcome[]) => Promise<TaskOutcome>
-  /** `queuedMs`: how long the task waited ready for a slot, when it did. */
-  onStart?: (node: TaskNode, queuedMs?: number) => void
+  onStart?: (node: TaskNode) => void
   onFinish?: (outcome: TaskOutcome) => void
   /**
    * Where the line naming a rejected `execute` goes, before its failed
@@ -355,6 +357,11 @@ export interface ScheduleOptions {
    * Undefined or `most-work` is the reverse-deps count above.
    */
   strategy?: ScheduleStrategy
+  /**
+   * The `most-work` baseline already counted (`computeReverseDepCount`, read
+   * back with the graph): asked only when that baseline is the one used.
+   */
+  reverseDeps?: () => ReadonlyMap<string, number>
   /**
    * Restore-tier task ids: confirmed stable-key LOCAL cache hits (the
    * local short-circuit). A restore-tier task:
@@ -598,7 +605,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
       ? strategyPriorities(nodes, options.strategy)
       : options.restoreTier !== undefined && options.restoreTier.size > 0
         ? tieredReverseDepCount(nodes, options.restoreTier)
-        : computeReverseDepCount(nodes)
+        : (options.reverseDeps?.() ?? computeReverseDepCount(nodes))
   const priority: ReadonlyMap<string, number> = options.priorities
     ? mergePriorities(baseline, options.priorities)
     : baseline
@@ -964,10 +971,9 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
         return undefined
       }
     }
-    const started = (node: TaskNode, queuedMs = 0): void => {
+    const started = (node: TaskNode): void => {
       try {
-        if (queuedMs > 0) onStart?.(node, queuedMs)
-        else onStart?.(node)
+        onStart?.(node)
       } catch (err) {
         const m = thrownMessage(err)
         ui.say('warn', `[vx] onStart observer threw for ${node.id}: ${m}\n`)
@@ -1106,7 +1112,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
         const settle = settleInPlace(node, upstream)
         let now: TaskOutcome | undefined
         if (settle !== undefined) {
-          if (!demoted.has(id)) started(node, queuedMs)
+          if (!demoted.has(id)) started(node)
           try {
             now = settle()
           } catch {
@@ -1136,7 +1142,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
         // the dispatch loop (it would strand the tick with the slot held).
         // A demoted task's second dispatch is the same task, already started,
         // as is one whose settle threw.
-        if (!demoted.has(id) && settle === undefined) started(node, queuedMs)
+        if (!demoted.has(id) && settle === undefined) started(node)
 
         // `.then(onFulfilled, onRejected)` — NOT `.then(f).catch(g)`. The
         // rejection arm handles ONLY `execute()` rejecting; a throw from

package/src/graph/task-graph.ts

@@ -294,7 +294,7 @@ export interface BuildGraphOptions {
    */
   undeclaredDeps?: (taskId: string, name: string) => void
   /**
-   * The workspace root, where `cache.outputs.workspaceFiles` is anchored.
+   * The workspace root, where `outputs.workspaceFiles` is anchored.
    * Given, a root-anchored output is also compared with every project's
    * `files` outputs (item 1088); absent (a graph built for a unit row), only
    * with other root-anchored ones.
@@ -335,6 +335,31 @@ export function undeclaredDepsError(
   )
 }
 
+/**
+ * The `pkg#task` to offer for a cross-project miss: the task nearest
+ * `task` in the project named, or in the one nearest `project` — or the
+ * one whose path ends in it, since a project is named by its path unless
+ * named, and `a#build` is how a `packages/a` is first typed.
+ */
+function nearestTarget(
+  projects: ReadonlyMap<string, ProjectEntry>,
+  project: string,
+  task: string,
+): string | undefined {
+  const holder =
+    projects.get(project) ??
+    projects.get(nearest(project, projects.keys()) ?? '') ??
+    onlyOne([...projects.values()].filter((p) => p.name.endsWith(`/${project}`)))
+  if (holder === undefined) return undefined
+  const tasks = Object.keys(holder.config.tasks ?? {})
+  const name = tasks.includes(task) ? task : nearest(task, tasks)
+  return name === undefined ? undefined : taskId(holder.name, name)
+}
+
+function onlyOne<T>(list: readonly T[]): T | undefined {
+  return list.length === 1 ? list[0] : undefined
+}
+
 /** One task mid-expansion in `buildTaskGraph`'s walk. */
 interface Frame {
   node: TaskNode
@@ -656,8 +681,9 @@ export function buildTaskGraph(options: BuildGraphOptions): Map<string, TaskNode
             `${id}: dependsOn //#${spec.task}, the workspace root's task, but the root declares no such task: add a vx.config at the root declaring it and run \`vx lock\``,
             'VX_E_DEPENDS_ON',
           )
+        const meant = nearestTarget(projects, spec.project, spec.task)
         throw new UserError(
-          `${id}: dependsOn ${taskId(spec.project, spec.task)} but no such project or task is declared`,
+          `${id}: dependsOn ${taskId(spec.project, spec.task)} but no such project or task is declared${meant === undefined ? '' : `. Did you mean ${meant}?`}`,
           'VX_E_DEPENDS_ON',
         )
       }
@@ -1248,7 +1274,7 @@ function detectOutputCollisions(
   const byProject = new Map<string, TaskNode[]>()
   const wsDeclarers: TaskNode[] = []
   for (const n of nodes.values()) {
-    const outs = n.config.cache?.outputs
+    const outs = n.config.outputs
     if ((outs?.files?.length ?? 0) > 0) {
       const bucket = byProject.get(n.projectName)
       if (bucket) bucket.push(n)
@@ -1264,9 +1290,9 @@ function detectOutputCollisions(
   const positiveOf = (globs: readonly string[] | undefined): readonly string[] | undefined =>
     globs === undefined ? undefined : splitNegations(globs).positive
   const filesOf = (n: TaskNode): readonly string[] | undefined =>
-    positiveOf(n.config.cache?.outputs.files)
+    positiveOf(n.config.outputs?.files)
   const wsFilesOf = (n: TaskNode): readonly string[] | undefined =>
-    positiveOf(n.config.cache?.outputs.workspaceFiles)
+    positiveOf(n.config.outputs?.workspaceFiles)
   for (const bucket of byProject.values()) {
     // Most projects hold one task with outputs, and a call per project
     // cost the cold build a measured 0.4 ms at 1,000 projects.
@@ -1320,7 +1346,7 @@ function detectOutputCollisions(
  * captures, so the pair cannot collide there.
  */
 function takenBackOf(n: TaskNode, field: 'files' | 'workspaceFiles'): string[] {
-  return splitNegations(n.config.cache?.outputs[field] ?? []).negative
+  return splitNegations(n.config.outputs?.[field] ?? []).negative
 }
 
 /**
@@ -1348,9 +1374,9 @@ function collideAcross(
       if (!outputsOverlap(ga, gb) || outputTakenBack(gb, wsBack) || outputTakenBack(ga, filesBack))
         continue
       const head =
-        `${ws.id} declares the output ${JSON.stringify(ga)} in cache.outputs.workspaceFiles, ` +
+        `${ws.id} declares the output ${JSON.stringify(ga)} in outputs.workspaceFiles, ` +
         `inside ${files.id}'s ${JSON.stringify(gb.slice(rel === '' ? 0 : rel.length + 1))} in ` +
-        `cache.outputs.files — vx cleans a task's declared outputs before it runs and before a ` +
+        `outputs.files — vx cleans a task's declared outputs before it runs and before a ` +
         `cache-hit restore, so whichever of these runs second DELETES the other's output`
       if (exclusive && (reaches(files.id, ws.id) || reaches(ws.id, files.id))) {
         throw new UserError(`${head}. ${EXCLUSIVE_OUTPUTS_FIX}`, 'VX_E_OUTPUT_OVERLAP')
@@ -1374,7 +1400,7 @@ function collideAcross(
         const outside = wsGlobs[own.indexOf(null)]!
         throw new UserError(
           `${head}. ${ws.id} depends on ${files.id}, but adding to its output needs every ` +
-            `cache.outputs.workspaceFiles entry inside ${rel === '' ? 'the workspace root' : rel}, ` +
+            `outputs.workspaceFiles entry inside ${rel === '' ? 'the workspace root' : rel}, ` +
             `and ${JSON.stringify(outside)} is not. Give each task its own output path.`,
           'VX_E_OUTPUT_OVERLAP',
         )
@@ -1614,7 +1640,7 @@ function collide(
       const head =
         `${a.id} and ${b.id} both declare the output ${JSON.stringify(ga)}` +
         (ga === gb ? '' : ` / ${JSON.stringify(gb)}`) +
-        ` in cache.outputs.${field} — vx cleans a task's declared outputs before it runs and ` +
+        ` in outputs.${field} — vx cleans a task's declared outputs before it runs and ` +
         `before a cache-hit restore, so whichever of these runs second DELETES the other's ` +
         `output`
       // An overlap WITH an edge is the addition shape (item 588): the
@@ -1626,7 +1652,7 @@ function collide(
       const [up, down] = reaches(b.id, a.id) ? [a, b] : reaches(a.id, b.id) ? [b, a] : []
       const parts = {
         headline: `${a.id} and ${b.id} both write ${ga === gb ? ga : `${ga} / ${gb}`}`,
-        ...(field === 'files' ? {} : { what: ['in cache.outputs.workspaceFiles'] }),
+        ...(field === 'files' ? {} : { what: ['in outputs.workspaceFiles'] }),
         why: "vx clears a task's outputs before it runs, so one deletes the other's",
       }
       if (up !== undefined && exclusive)
@@ -1639,9 +1665,8 @@ function collide(
         )
       if (up !== undefined && down !== undefined) {
         const downGlobs = splitNegations(
-          (field === 'files'
-            ? down.config.cache?.outputs.files
-            : down.config.cache?.outputs.workspaceFiles) ?? [],
+          (field === 'files' ? down.config.outputs?.files : down.config.outputs?.workspaceFiles) ??
+            [],
         ).positive
         ;(down.addsToOutputsOf ??= []).push(up.id)
         ;(up.outputsAddedToBy ??= []).push(...(downGlobs ?? []))
@@ -1680,13 +1705,13 @@ export function outputTakenBack(output: string, negatives: readonly string[]): b
  * and its key read nothing (hunt 8). Always refused, whatever the rules.
  */
 function refuseSelfClean(node: TaskNode): void {
-  const cache = node.config.cache
+  const declaredOutputs = node.config.outputs
   const declared = node.config.inputs
-  if (cache === undefined || declared === undefined) return
+  if (declaredOutputs === undefined || declared === undefined) return
   for (const field of ['files', 'workspaceFiles'] as const) {
-    if (!coversAny(declared[field], cache.outputs[field])) continue
+    if (!coversAny(declared[field], declaredOutputs[field])) continue
     const inputs = splitNegations(declared[field] ?? [])
-    const out = splitNegations(cache.outputs[field] ?? [])
+    const out = splitNegations(declaredOutputs[field] ?? [])
     const outputs = out.positive
     if (outputs.length === 0) continue
     const roots = outputs.map((g) => rootless(staticPrefix(g)))
@@ -1797,11 +1822,11 @@ function detectInputOverlaps(nodes: Map<string, TaskNode>, workspaceRoot?: strin
     return list
   }
   for (const n of nodes.values()) {
-    const cache = n.config.cache
+    const declaredOutputs = n.config.outputs
     const inputs = n.config.inputs
     if (inputs === undefined) continue
-    const outFiles = positives(cache?.outputs.files ?? [])
-    const outWs = positives(cache?.outputs.workspaceFiles ?? [])
+    const outFiles = positives(declaredOutputs?.files ?? [])
+    const outWs = positives(declaredOutputs?.workspaceFiles ?? [])
     if (outFiles.length > 0) {
       const anchor = workspaceRoot === undefined ? undefined : relPosix(workspaceRoot, n.projectDir)
       bucket(n.projectName).push({ node: n, globs: outFiles, reads: false, anchor })
@@ -1869,7 +1894,7 @@ function readsRootedOutputs(
   if (workspaceRoot !== undefined) {
     for (const node of filesWriters) {
       const rel = relPosix(workspaceRoot, node.projectDir)
-      const globs = positives(node.config.cache!.outputs.files).map((g) =>
+      const globs = positives(node.config.outputs!.files).map((g) =>
         rel === '' ? g : `${rel}/${g}`,
       )
       rooted.push({ node, globs, reads: false, rel })
@@ -1999,14 +2024,16 @@ function takenBack(
   let tb = memo.bySide.get(reader)
   if (tb === undefined) {
     const inputs = reader.node.config.inputs!
-    const cache = reader.node.config.cache
+    const declaredOutputs = reader.node.config.outputs
     // A reader rebased to the root (X-135) speaks in its project's terms.
     const at = reader.rel === undefined || reader.rel === '' ? '' : `${reader.rel}/`
     // What the reader's key never reads: its `!` entries and its own outputs.
     const list = [
       ...splitNegations(field === 'files' ? inputs.files : (inputs.workspaceFiles ?? [])).negative,
       ...splitNegations(
-        field === 'files' ? (cache?.outputs.files ?? []) : (cache?.outputs.workspaceFiles ?? []),
+        field === 'files'
+          ? (declaredOutputs?.files ?? [])
+          : (declaredOutputs?.workspaceFiles ?? []),
       ).positive,
     ].map((g) => at + g)
     const key = list.join('\0')

package/src/handoff.ts

@@ -223,15 +223,19 @@ export async function handOff(bin: string, args: readonly string[]): Promise<nev
   // hides the env on every verb, is never reached here. Imported here:
   // a start that hands off nothing pays nothing.
   await (await import('./util/index.js')).hideEnvFromTasks()
-  const child = Bun.spawn([bin, ...args], {
-    stdio: ['inherit', 'inherit', 'inherit'],
-    env: { ...process.env, VX_HANDED_OFF: process.execPath },
-  })
+  // The handlers come first: a signal landing between the spawn and them
+  // killed this vx and left the local one running, orphaned (main
+  // dc9d49c). A handler runs on the event loop, after the spawn returned.
+  let child: Bun.Subprocess | undefined
   for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) {
     process.on(sig, () => {
-      if (!inForeground()) child.kill(sig)
+      if (!inForeground()) child?.kill(sig)
     })
   }
+  child = Bun.spawn([bin, ...args], {
+    stdio: ['inherit', 'inherit', 'inherit'],
+    env: { ...process.env, VX_HANDED_OFF: process.execPath },
+  })
   const code = await child.exited
   const signal = child.signalCode
   if (signal === null) process.exit(code)
@@ -240,8 +244,7 @@ export async function handOff(bin: string, args: readonly string[]): Promise<nev
   // SIGINT, and an exit 130 ran the script's next line. The code below is
   // the rest, and the fallback should the signal not land.
   if (signal === 'SIGINT' || signal === 'SIGTERM' || signal === 'SIGHUP') {
-    process.removeAllListeners(signal)
-    process.kill(process.pid, signal)
+    ;(await import('./util/index.js')).dieOf(signal)
   }
   if (typeof signal === 'number') process.exit(128 + signal)
   const { constants } = await import('node:os')

package/src/history/failure-mode.ts

@@ -30,7 +30,7 @@ export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
  * `status`, `cache_hit`, `cached` columns) with how often it failed, how often it
  * passed — an executed success or a cache hit, which replays a success —
  * and how often it failed AFTER its first pass (`relapses`). A task with
- * no cache block keys on its config alone and runs every time, so its key
+ * no `cache: true` keys on its config alone and runs every time, so its key
  * says nothing about its inputs: no reader counts it, as no run's row
  * calls it flaky. Nor is a row that names a `blocked_by`: it ran behind a
  * failure (`--continue=always`), on bytes its key never named, so its
@@ -198,6 +198,29 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   return out
 }
 
+/**
+ * Whether a task that just failed on `hash` is known to be flaky: this key
+ * passed before (the failure itself is the flake), or the retained history
+ * holds a key of the task that failed after it passed, or a pass that took
+ * a retry. Asked only after a failure, so a green run never reads it.
+ */
+export function knownFlaky(db: Database, project: string, task: string, hash: string): boolean {
+  const passed = db
+    .query(
+      `SELECT 1 FROM ${OUTCOMES} WHERE hash = ? AND project = ? AND task = ?
+       AND (status = 'success' OR status IN ${HIT_STATUSES}) LIMIT 1`,
+    )
+    .get(hash, project, task)
+  if (passed !== null) return true
+  const flaked = db
+    .query(
+      `SELECT 1 FROM (${keyOutcomesSql(OUTCOMES, ' AND project = ? AND task = ?')})
+       WHERE relapses > 0 OR retried_failures > 0 LIMIT 1`,
+    )
+    .get(project, task)
+  return flaked !== null
+}
+
 /** One task the recorded history shows failing on a key that had passed. */
 export interface FlakyTask {
   /** `project#task`. */

package/src/history/history.ts

@@ -311,6 +311,11 @@ export class LocalHistoryProvider implements LocalHistory {
    * against 4 for the executed successes' durations alone.
    */
   async p50sFor(taskIds: readonly string[]): Promise<ReadonlyMap<string, number>> {
+    return this.p50sNow(taskIds)
+  }
+
+  /** `p50sFor`, at once: a row drawn now reads it (the rows' `usual`). */
+  p50sNow(taskIds: readonly string[]): ReadonlyMap<string, number> {
     if (taskIds.length === 0) return new Map()
     return this.forecasts(new Set(taskIds))
   }

package/src/history/index.ts

@@ -16,6 +16,7 @@ export {
 } from './history.js'
 export {
   detectFlaky,
+  knownFlaky,
   type FailureMode,
   type FlakyCandidate,
   type FlakyFinding,

package/src/history/metrics.ts

@@ -39,7 +39,7 @@ export interface RunSummaryRow {
   cacheHit: boolean | null
   /** On a hit: true when outputs were restored, false when up-to-date (v31); null otherwise. */
   restored: boolean | null
-  /** Whether the task declared a `cache` block; null on rows older than the column. */
+  /** Whether the task declared `cache: true`; null on rows older than the column. */
   cached: boolean | null
   hash: string
   cpuMs: number | null
@@ -50,6 +50,10 @@ export interface RunSummaryRow {
   avgRssBytes: number | null
   /** Where an executor ran it (`small#1`, v44); null = here. */
   placement: string | null
+  /** The bytes of its outputs: what its save stored, or its hit restored (v51). */
+  outputBytes: number | null
+  /** How many tasks were downstream of it (v51). */
+  blocks: number | null
   // High-precision spans relative to run start. Decimal strings on the wire
   // (bigints aren't JSON-safe); use BigInt or Number on the client.
   wallclockStartNs: string | null
@@ -65,6 +69,8 @@ export interface RunSummaryRow {
   remoteError: string | null
   /** The attempts a retried task took (>1, v23); null when it ran once. */
   attempts: number | null
+  /** Milliseconds it waited, ready, for a slot (v51); null when it never queued. */
+  queuedMs: number | null
 }
 
 export interface ListRunsArgs {
@@ -123,10 +129,12 @@ export function listRuns(db: Database, args: ListRunsArgs = {}): RunSummaryRow[]
               cache_hit AS cacheHit, restored, cached, hash,
               cpu_ms AS cpuMs, peak_rss_bytes AS peakRssBytes,
               peak_cores AS peakCores, avg_rss_bytes AS avgRssBytes, placement,
+              output_bytes AS outputBytes, blocks,
               wallclock_start_ns AS wallclockStartNs, wallclock_end_ns AS wallclockEndNs,
               blocked_by AS blockedBy, timed_out AS timedOut,
               sandbox_violations AS sandboxViolations, not_ready AS notReady,
-              forward_args IS NOT NULL AS forwarded, remote_error AS remoteError, attempts
+              forward_args IS NOT NULL AS forwarded, remote_error AS remoteError, attempts,
+              queued_ms AS queuedMs
        FROM runs ${clause} ORDER BY id DESC LIMIT ?`,
     )
     .all(...params, limit) as RawRow[]
@@ -374,7 +382,7 @@ export interface WhyDidThisRerun {
     cacheHit: boolean | null
     /** On a hit: outputs restored (true) or up-to-date (false); null otherwise. */
     restored: boolean | null
-    /** Whether the task declared a `cache` block; null on rows older than the column. */
+    /** Whether the task declared `cache: true`; null on rows older than the column. */
     cached: boolean | null
     startedAt: number
   }
@@ -606,9 +614,9 @@ export function whyDidThisRerun(db: Database, runId: string, taskId: string): Wh
           // one's is new each run, so every dependent misses: "folded by
           // dependents" read as if they could hit.
           this_.keylessBy === null
-          ? 'this task declares no `cache` block — it runs on every invocation; its key is folded by dependents only'
+          ? 'this task declares no `cache: true` — it runs on every invocation; its key is folded by dependents only'
           : this_.keylessBy === taskId
-            ? 'this task declares no `cache` block — it runs on every invocation; it declares no `inputs` either, so each run derives a new key and every task that depends on it misses; declare its `inputs`'
+            ? 'this task declares no `cache: true` — it runs on every invocation; it declares no `inputs` either, so each run derives a new key and every task that depends on it misses; declare its `inputs`'
             : `this task declares no \`cache\` block — it runs on every invocation; its key includes ${this_.keylessBy}, which declares no \`inputs\`, so each run derives a new key and every task that depends on it misses; declare inputs on ${this_.keylessBy}`
         : this_.keylessBy !== null
           ? keylessNote(taskId, this_.keylessBy)
@@ -881,7 +889,7 @@ export function cacheKeyDiff(db: Database, runId: string, taskId: string): Cache
         this_.cached === 0
           ? // The verdict already says the task is uncached; this line says
             // why no input can be named.
-            'with no `cache` block it saves no entry, so no input fingerprints are kept to say which of its `inputs` moved its key; with no `inputs`, every run gives it a new key'
+            'without `cache: true` it saves no entry, so no input fingerprints are kept to say which of its `inputs` moved its key; with no `inputs`, every run gives it a new key'
           : unsaved !== null
             ? `cache key changed but input fingerprints are unavailable — ${unsaved} and saved no entry; only the key change is known`
             : 'cache key changed but input fingerprints are unavailable — the entry was pruned (or the row predates the `cached` column); only the key change is known',