@vzn/vx 0.0.649 → 0.0.651

package/src/orchestrator/run.ts

@@ -8,11 +8,13 @@ import { EMPTY_LOCK, inputStabilityEnv, LOCK_INVALID, lockEntryBroken } from '..
 import { realpathSync } from 'node:fs'
 import path from 'node:path'
 import {
+  indexDb,
   Cache,
   type CachePolicy,
   cachesNothing,
   formatCachePolicy,
   networkConcurrency,
+  keepRunNotes,
   stopRuntimeProbes,
   sweepStaging,
 } from '../cache/index.js'
@@ -37,11 +39,12 @@ import {
   type TaskNode,
   type TaskOutcome,
 } from '../graph/index.js'
+import { graphCounts } from './graph-memo.js'
 import {
   mark,
   stageTimes,
   MAX_TIMEOUT_MS,
-  printTimings,
+  timingLines,
   ulid,
   isLiteralPattern,
   listed,
@@ -51,12 +54,17 @@ import {
   secretMask,
   isFsRefusal,
   isUserError,
-  detectColors,
-  type ColorSupport,
   SecretBroker,
   thrownMessage,
-  type ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
+
+/** The stage table `VX_DEBUG_TIMING=1` asks for, on stderr. */
+function printTimings(): void {
+  const lines = timingLines()
+  if (lines !== undefined) ui.print('err', ui.trace(lines))
+}
+import { detectColors, type ColorSupport } from '../ui/index.js'
 import { keyedProjects } from './keyed-projects.js'
 import { isDefaultBuild } from '../graph/index.js'
 import { commandWriteReach, prepareSandbox } from './sandbox-request.js'
@@ -66,6 +74,7 @@ import { settleProbedHit, unkeyedGroupOutcome, type ExecuteArgs } from './execut
 import { executeArgsOf, type RunScope } from './execute-args.js'
 import { excludedTaint } from './excluded-keys.js'
 import { dependedOn, keyUpstream } from './upstream.js'
+import { createLiveUsage } from './live-usage.js'
 import {
   busLogger,
   createEventBus,
@@ -93,7 +102,6 @@ import {
 } from './plugin-host.js'
 import { createSteps } from './steps.js'
 import { liveSocketOf, serveLive } from './run-live.js'
-import { writeRunSteps, writeRunWarnings } from './run-steps.js'
 import { subscribeTelemetry, type TelemetryHandle } from './telemetry-host.js'
 import { claimOutput, guardedOutput } from './output-host.js'
 import { assembleRunSummary } from './telemetry.js'
@@ -353,6 +361,11 @@ export async function run(options: RunOptions): Promise<RunSummary> {
   const detach = (): void => {
     unsubscribeTerminal()
     unsubscribeWarned()
+    // A run refused or thrown before its tasks (an unknown task, a plugin
+    // stage that threw) never reached the end that takes the live region
+    // down: a load slow enough to show its step left `vx:load running`
+    // on screen, and the CLI's refusal was written onto its last line.
+    terminal?.runDone?.()
     terminal?.settle()
   }
   // A plugin's `output` renders the run from its start; core's renderer
@@ -910,7 +923,40 @@ async function runOnBus(
     const fault = executorFaults(warnOf(log))
     const footers = executors.filter((e) => e.footer !== undefined)
     const placers = executors.filter((e) => e.running !== undefined)
+    // The scheduler's dependents count, and every row's `blocks` (the live
+    // list's and the results'): one closure over the graph, built on the
+    // first that asks.
+    let counted: ReadonlyMap<string, number> | undefined
+    const blocksNow = (): ReadonlyMap<string, number> =>
+      (counted ??= graphCounts(nodes, hashCache.folds, hashCache.graph))
+    // Every row's `usual` and the forecast's timings: history read once, on
+    // the first row that asks, so a run that executes nothing never reads
+    // it. It was read only a second into a live run, so rows before that,
+    // a short run's and every log's showed none (2026-10-29).
+    let p50s: ReadonlyMap<string, number> | undefined
+    const p50sNow = (): ReadonlyMap<string, number> => {
+      if (p50s !== undefined) return p50s
+      const ids: string[] = []
+      for (const n of nodes.values()) if (!isGroupTask(n)) ids.push(n.id)
+      try {
+        p50s = new LocalHistoryProvider(
+          indexDb(prepared.localCache),
+          undefined,
+          prepared.branch(),
+          taskDefinitions(nodes.values()),
+        ).p50sNow(ids)
+      } catch {
+        // History is observability: an unreadable one knows no task.
+        p50s = new Map()
+      }
+      return p50s
+    }
+    // The live rows' `cpu` and `mem`; it looks only once the live list asks.
+    const liveUsage = createLiveUsage()
     const runContext = {
+      blocks: blocksNow,
+      usual: (id: string) => p50sNow().get(id),
+      usage: liveUsage.usage,
       ...(footers.length > 0
         ? { executorRows: () => footers.flatMap((e) => executorFooter(e, fault)) }
         : {}),
@@ -967,18 +1013,8 @@ async function runOnBus(
     // history's only if the region is still up a second in, so a warm run
     // never reads history.
     terminal?.forecast(
-      () => createForecast(nodes, new Map(), concurrency),
-      async () => {
-        const ids: string[] = []
-        for (const n of nodes.values()) if (!isGroupTask(n)) ids.push(n.id)
-        const p50s = await new LocalHistoryProvider(
-          prepared.localCache.dbHandle(),
-          undefined,
-          prepared.branch(),
-          taskDefinitions(nodes.values()),
-        ).p50sFor(ids)
-        return createForecast(nodes, p50s, concurrency)
-      },
+      () => createForecast(nodes, new Map(), concurrency, blocksNow()),
+      async () => createForecast(nodes, p50sNow(), concurrency, blocksNow()),
     )
 
     // Remote-only: kick off background prefetches so remote-GET latency
@@ -1112,7 +1148,7 @@ async function runOnBus(
     // Why a task missed, for a sink: a read of the history per miss, so only
     // when a sink exists.
     const explainMiss =
-      telemetry === undefined ? undefined : createMissExplainer(prepared.localCache.dbHandle())
+      telemetry === undefined ? undefined : createMissExplainer(indexDb(prepared.localCache))
     const lateProbes = probesAfterWrites(nodes, workspaceRoot)
     // The scheduler's fail-fast stop, as the retry loop of a task already
     // in flight sees it.
@@ -1143,7 +1179,15 @@ async function runOnBus(
     if (options.retries !== undefined) scope.retries = options.retries
     if (taskTimeoutDefault !== undefined) scope.timeout = taskTimeoutDefault
     if (cleanOutputs !== undefined) scope.cleanOutputs = cleanOutputs
-    if (telemetry?.track !== undefined) scope.track = telemetry.track
+    const sinkTrack = telemetry?.track
+    scope.track = (taskId, pid) => {
+      const untrack = liveUsage.track(taskId, pid)
+      const sunk = sinkTrack?.(taskId, pid)
+      return () => {
+        untrack()
+        return sunk?.()
+      }
+    }
     if (explainMiss !== undefined) scope.explainMiss = explainMiss
     if (keepRun !== undefined) scope.keepRun = keepRun
     if (sandboxArmer !== null) scope.armSandbox = () => sandboxArmer.arm()
@@ -1215,7 +1259,7 @@ async function runOnBus(
     // rows land, so the row that prints next carries the verdict: nothing
     // prints below the footer. A hit or a skip asks nothing; a green miss
     // is one probe of the failed-row index.
-    const historyDb = prepared.localCache.dbHandle()
+    const historyDb = indexDb(prepared.localCache)
     const cacheOff = cachesNothing(policy)
     const judgeFlaky = (o: TaskOutcome): void => {
       const candidates = flakyCandidates([o], taintedRan)
@@ -1249,10 +1293,12 @@ async function runOnBus(
       }
     }
     let lockBroken: boolean | undefined
+    prepared.localCache.storeHeldBlobSizes()
     const outcomes = await runGraph({
       nodes,
       concurrency,
       restoreConcurrency: options.restoreConcurrency ?? 2 * concurrency,
+      reverseDeps: blocksNow,
       settledOf: (o) => deferredSaves.get(o.node.id),
       ...(hasPooledExecutor(executors) ? { poolOf: poolOfPlacement(placements) } : {}),
       ...(admit !== undefined ? { admit } : {}),
@@ -1361,6 +1407,9 @@ async function runOnBus(
     const hold =
       options.holdPersistent === true &&
       (!stop.signal.aborted || stop.signal.reason === CYCLE_INTERRUPT)
+    // A stop already signalled every server once and waits out its grace:
+    // a SIGTERM here, while a server ran its cleanup, cut it short.
+    if (stop.signal.aborted) await stop.aborting?.catch(() => {})
     const { keepAlive, crashed: crashedPersistent } = await disposeServers({
       registry: persistentRegistry,
       nodes,
@@ -1469,6 +1518,7 @@ async function runOnBus(
         ci: ciContext,
         host: hostContext,
         withTelemetry: telemetry !== undefined,
+        blocks: blocksNow(),
         remoteTraffic: prepared.localCache.traffic.keys,
       })
     const records = recordsOf(list, ok)
@@ -1492,8 +1542,11 @@ async function runOnBus(
     // A cache directory this user cannot write keeps none of the run's
     // records: the run's one notice said so.
     const keeps = prepared.localCache.readOnlyNotice() === null
-    const recordFailures = (final: readonly TaskOutcome[]): void => {
-      if (keeps) writeRunFailures(prepared.cacheDir, runId, final, warnOf(log))
+    const recordFailures = (
+      final: readonly TaskOutcome[],
+      into: Cache = prepared.localCache,
+    ): void => {
+      if (keeps) writeRunFailures(into, runId, final, warnOf(log))
     }
     if (stop.stoppedBy === undefined && !historyAfterWait) {
       stepSync('vx:history', () => {
@@ -1535,8 +1588,18 @@ async function runOnBus(
       await Promise.all([cache.drainUploads?.(), keeper?.settled()])
     })
     if (keeps) {
-      writeRunSteps(prepared.cacheDir, runId, steps.ended, warnOf(log))
-      writeRunWarnings(prepared.cacheDir, runId, warned, warnOf(log))
+      // Beside the run's rows (cache/run-notes.ts); a refused write costs only them.
+      try {
+        keepRunNotes(indexDb(prepared.localCache), runId, {
+          steps: steps.ended,
+          warnings: warned.map((w) => Bun.stripANSI(w)),
+        })
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err)
+        warnOf(log)(
+          `[vx] background steps and warnings not kept: ${message} — the verdict above stands`,
+        )
+      }
     }
     // An upload that failed after the rows went in: its row says so too.
     if (prepared.localCache.uploads.failed > 0 && stop.stoppedBy === undefined && !historyAfterWait)
@@ -1670,11 +1733,11 @@ async function runOnBus(
           const local = new Cache(prepared.cacheDir, undefined, prepared.workspaceRoot)
           try {
             local.recordRunBundle(recordsOf(final, ok && !crashed))
+            recordFailures(final, local)
           } finally {
             local.close()
           }
         })
-        recordFailures(final)
       }
       return { ok: ok && !crashed, outcomes: final }
     }
@@ -1789,7 +1852,7 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
       // inspection command, so the history read's cost is fine here even
       // though it stays OFF the default run path.
       history: new LocalHistoryProvider(
-        prepared.localCache.dbHandle(),
+        indexDb(prepared.localCache),
         undefined,
         prepared.branch(),
         taskDefinitions(prepared.nodes.values()),

package/src/orchestrator/sandbox-request.ts

@@ -446,8 +446,8 @@ export function withheldLinkLine(taskId: string, w: WithheldLink): string {
   return (
     `vx: ${taskId} read \`${w.target}\` through \`${w.link}\`, and its key includes no task of ` +
     `${w.name}, so an edit there would not re-run it. Add a \`dependsOn\` edge that ` +
-    `reaches one (\`^build\` where ${w.name}#build keys its sources, or a \`source\` task: ` +
-    `\`${w.name}#source\`), or grant and key the files yourself (\`allow.read\` plus ` +
+    `reaches one (\`^build\`, where ${w.name}#build keys its sources), or grant and key ` +
+    `the files yourself (\`allow.read\` plus ` +
     `\`inputs.workspaceFiles\`).`
   )
 }

package/src/orchestrator/signals.ts

@@ -14,7 +14,13 @@
 // them to the runner around every spawn.
 
 import { signalExitCode } from '../exec/index.js'
-import { claimExitForSignal, hangupIgnored, killGraceMs, settleWithin } from '../util/index.js'
+import {
+  claimExitForSignal,
+  dieOf,
+  hangupIgnored,
+  killGraceMs,
+  settleWithin,
+} from '../util/index.js'
 import {
   holdGroups,
   killTree,
@@ -154,10 +160,7 @@ export function forwardSignals(args: {
     // and a 130 exit ran the script's next line. The code stays the
     // fallback should the signal not land.
     if (args.handsTerminal !== true) {
-      process.once('exit', () => {
-        process.removeAllListeners(signal)
-        process.kill(process.pid, signal)
-      })
+      process.once('exit', () => dieOf(signal))
     }
     process.exit(signalExitCode(signal))
   }

package/src/orchestrator/steps.ts

@@ -6,9 +6,9 @@
 //
 // A run shows only the steps it waits on, before its first task or its end
 // (2026-10-16). One that runs beside the tasks (`vx:prefetch`) is a
-// `background` step: never shown, and kept for `vx last` (run-steps.ts).
+// `background` step: never shown, and kept for `vx last` (cache/run-notes.ts).
 import type { Logger } from '../report/index.js'
-import type { RunStep } from './run-steps.js'
+import type { RunStep } from '../cache/index.js'
 
 export interface Steps {
   /** Time `work` as step `id` when steps show; else run it as it is. */

package/src/orchestrator/task-hash.ts

@@ -519,9 +519,23 @@ function hashableConfig(cfg: TaskConfig): unknown {
   // Keys sorted: moving `cache` above `exec`, or a `define` in another
   // order, missed every key of the task, and a `project` or `graph` plugin
   // writes a config the lock never sorted (2026-10-25).
-  if (cfg.exec?.remote === undefined) return keysSorted(cfg)
-  const { remote: _remote, ...execRest } = cfg.exec
-  return keysSorted({ ...cfg, exec: execRest })
+  const env = cfg.inputs?.env
+  const pass = cfg.exec?.env?.passThrough
+  if (cfg.exec?.remote === undefined && sortedNames(env) && sortedNames(pass))
+    return keysSorted(cfg)
+  const { remote: _remote, ...execRest } = cfg.exec ?? ({} as NonNullable<TaskConfig['exec']>)
+  // Env names are sets: each value is read by its name, so their order
+  // keys nothing (conformance env/declared-order-irrelevant).
+  if (!sortedNames(pass)) execRest.env = { ...execRest.env, passThrough: [...pass!].sort() }
+  const out: TaskConfig = cfg.exec === undefined ? { ...cfg } : { ...cfg, exec: execRest }
+  if (!sortedNames(env)) out.inputs = { ...cfg.inputs!, env: [...env!].sort() }
+  return keysSorted(out)
+}
+
+function sortedNames(names: readonly string[] | undefined): boolean {
+  if (names === undefined) return true
+  for (let i = 1; i < names.length; i++) if (names[i - 1]! > names[i]!) return false
+  return true
 }
 
 /**

package/src/report/forecast.ts

@@ -12,8 +12,6 @@ export interface LiveForecast {
   critical?: string
   /** 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
@@ -21,9 +19,9 @@ export interface LiveForecast {
    */
   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
+   * Each running task's count of what is downstream of it, the
+   * scheduler's own count (`computeReverseDepCount`): its row's `blocks`
+   * cell, why they are not running. A node downstream of two running tasks
    * counts under both.
    */
   blockedBy: ReadonlyMap<string, number>
@@ -53,6 +51,8 @@ export function createForecast(
   nodes: ReadonlyMap<string, TaskNode>,
   p50s: ReadonlyMap<string, number>,
   concurrency: number,
+  /** Every node's dependents count, the scheduler's baseline and the rows' `blocks`; computed here when absent. */
+  rank: ReadonlyMap<string, number> = computeReverseDepCount(nodes),
 ): Forecast {
   // Dependencies before dependents, once: each call is one pass over it.
   const order: TaskNode[] = []
@@ -84,38 +84,16 @@ export function createForecast(
     if (p !== undefined) cost.set(n.id, p)
   }
   const workers = Math.max(1, concurrency)
-  // The scheduler's own baseline ranking, most dependents first, ties in
-  // graph order: once per run, as the scheduler computes it.
-  const rank = computeReverseDepCount(nodes)
+  // The scheduler's own baseline ranking (`rank`), most dependents first,
+  // ties in graph order.
   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)!
   }
 
   return (finished, running, nowMs) => {
-    const expected = new Map<string, number>()
     let waiting = 0
-    for (const id of running.keys()) {
-      const p = cost.get(id)
-      if (p !== undefined) expected.set(id, p)
-    }
     const end = new Map<string, number>()
     // The running task each node's longest chain waits on.
     const head = new Map<string, string>()
@@ -144,8 +122,6 @@ export function createForecast(
         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) {
@@ -167,13 +143,16 @@ export function createForecast(
       }
       work += own
     }
-    if (!known) return { waiting, expected, blocked: held, blockedBy }
+    for (const id of running.keys()) {
+      const d = rank.get(id)
+      if (d !== undefined && d > 0) blockedBy.set(id, d)
+    }
+    if (!known) return { waiting, blocked: held, blockedBy }
     const critical = chainEnd === undefined ? undefined : head.get(chainEnd)
     return {
       etaMs: Math.max(chain, work / workers),
       ...(critical !== undefined ? { critical } : {}),
       waiting,
-      expected,
       blocked: held,
       blockedBy,
     }