@vzn/vx 0.0.652 → 0.0.653

package/src/orchestrator/run-keys.ts

@@ -15,10 +15,17 @@ import type { GitFilesCache } from '../cache/index.js'
 import type { TaskNode } from '../graph/index.js'
 import { xxh3hex } from '../util/index.js'
 import type { StableKey } from './stable-keys.js'
-import { hashTaskConfig, isKeyless, taskFilesToken, type HashCache } from './task-hash.js'
+import {
+  hashTaskConfig,
+  inputStrategiesOf,
+  isKeyless,
+  taskFilesToken,
+  workspaceCleanOf,
+  type HashCache,
+} from './task-hash.js'
 
 /** Moves every remembered run: bump it when what a token stands for changes. */
-const RUN_MEMO_VERSION = 'run-memo-v1'
+const RUN_MEMO_VERSION = 'run-memo-v2'
 
 export interface RunKeysArgs {
   nodes: Map<string, TaskNode>
@@ -64,6 +71,11 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
     JSON.stringify([...args.nestedDirsByProject]),
     // Which outputs git ignores decides which a reader may see (`readableOutputs`).
     [...args.gitFilesCache.ignoredOutputs].sort().join('\0'),
+    // Folded into a config's key; a remembered graph's token names the
+    // lock, not `.vx/workspace` or the variables.
+    String(workspaceCleanOf(args.hashCache)),
+    String(inputStrategiesOf(args.hashCache)?.run),
+    String(inputStrategiesOf(args.hashCache)?.workspace),
   ]
   // A remembered graph's token names every node's edges and config, so
   // each node adds only what may differ under it (4 of 8 ms at 1,206
@@ -75,7 +87,20 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
   // Tasks of one project mostly declare the same files and outputs, and the
   // token is a function of that declaration (`filesToken`): one walk each,
   // not one per task (5 of 12 ms at 1,206 tasks, 2026-10-23).
-  const tokens = new Map<string, string>()
+  // Keyed by the project, then by the declaration's text, and that text is
+  // taken once per config object: the lock shares a config among the tasks
+  // that declare it alike, and a stringify and a joined key per node were
+  // ~6 ms of 9,603 (2026-11-07).
+  const tokens = new Map<string, Map<string, string>>()
+  const declarations = new Map<TaskNode['config'], string>()
+  const declarationOf = (cfg: TaskNode['config']): string => {
+    let text = declarations.get(cfg)
+    if (text === undefined) {
+      text = JSON.stringify([cfg.inputs?.files, cfg.outputs?.files, cfg.outputs?.workspaceFiles])
+      declarations.set(cfg, text)
+    }
+    return text
+  }
   const filesAt: number[] = []
   for (const node of args.nodes.values()) {
     const cfg = node.config
@@ -84,24 +109,29 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
     if ((inputs?.runtime?.length ?? 0) > 0 || (inputs?.workspaceRuntime?.length ?? 0) > 0) {
       return undefined
     }
+    // A files token in full is a root, a declaration and a digest, ~200
+    // characters per node, joined and hashed again: 2 MB of token at 8,002
+    // tasks (2026-11-07). Each distinct one is hashed once instead, and the
+    // node names that hash, which is also what the delta compares.
     let files = ''
     if (inputs !== undefined) {
       if ((inputs.workspaceFiles?.length ?? 0) > 0) return undefined
       // No positive entry resolves no files (`filesPlan`).
       if (inputs.files === undefined || inputs.files.some((e) => !e.startsWith('!'))) {
-        const outputs = cfg.outputs
-        const declared = `${node.projectName}\0${JSON.stringify([inputs.files, outputs?.files, outputs?.workspaceFiles])}`
-        let token = tokens.get(declared)
+        const declared = declarationOf(cfg)
+        let byDeclared = tokens.get(node.projectName)
+        if (byDeclared === undefined) tokens.set(node.projectName, (byDeclared = new Map()))
+        let token = byDeclared.get(declared)
         if (token === undefined) {
-          token = taskFilesToken({
+          const full = taskFilesToken({
             node,
             workspaceRoot: args.workspaceRoot,
             nestedProjectDirs: args.nestedDirsByProject.get(node.projectName) ?? [],
             gitFilesCache: args.gitFilesCache,
-            hashCache: args.hashCache,
           })
-          if (token === undefined) return undefined
-          tokens.set(declared, token)
+          if (full === undefined) return undefined
+          token = xxh3hex(full)
+          byDeclared.set(declared, token)
         }
         files = token
       }
@@ -139,13 +169,9 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
     at.delta = () => {
       if (delta !== undefined) return delta
       const files = new Map<string, string>()
-      const hashed = new Map<string, string>()
       const rest = [...parts]
       filesAt.forEach((i, n) => {
-        const token = parts[i]!
-        let h = hashed.get(token)
-        if (h === undefined) hashed.set(token, (h = xxh3hex(token)))
-        files.set(ids[n]!, h)
+        files.set(ids[n]!, parts[i]!)
         rest[i] = ''
       })
       return (delta = { global: `${selection}\0${xxh3hex(rest.join('\0'))}`, files })
@@ -154,6 +180,21 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
   return at
 }
 
+/**
+ * A memo row: each stable and uncached key with its node's place in the
+ * run's node order. The token names every node id in that order, so a row
+ * read under it means the same nodes; by id, the row's JSON and a lookup
+ * per node were ~5 ms of 8,002 (2026-11-07).
+ */
+interface KeysRow {
+  /** Stable keys: node places, and their keys alike. */
+  s: number[]
+  h: string[]
+  /** Uncached keys: node places, and their keys alike. */
+  u: number[]
+  k: string[]
+}
+
 /** The keys remembered under `token`, mapped back onto this run's nodes. */
 export function readRunKeys(
   args: RunKeysArgs,
@@ -161,19 +202,28 @@ export function readRunKeys(
 ): RunKeys | undefined {
   const row = args.hashCache.folds?.get(at.id, at.token)
   if (row === undefined) return undefined
-  let parsed: { s: [string, string][]; u: [string, string][] }
+  let parsed: KeysRow
   try {
     parsed = JSON.parse(row)
   } catch {
     return undefined
   }
+  const { s, h, u, k } = parsed
+  if (s?.length !== h?.length || u?.length !== k?.length) return undefined
+  const nodes = [...args.nodes.values()]
   const stableKeys: StableKey[] = []
-  for (const [id, hash] of parsed.s) {
-    const node = args.nodes.get(id)
+  for (let i = 0; i < s.length; i++) {
+    const node = nodes[s[i]!]
+    if (node === undefined) return undefined
+    stableKeys.push({ hash: h[i]!, node })
+  }
+  const uncachedKeys = new Map<string, string>()
+  for (let i = 0; i < u.length; i++) {
+    const node = nodes[u[i]!]
     if (node === undefined) return undefined
-    stableKeys.push({ hash, node })
+    uncachedKeys.set(node.id, k[i]!)
   }
-  return { stableKeys, uncachedKeys: new Map(parsed.u) }
+  return { stableKeys, uncachedKeys }
 }
 
 /**
@@ -259,14 +309,23 @@ export function writeRunKeys(
   at: { id: string; token: string },
   keys: RunKeys,
 ): void {
-  args.hashCache.folds?.set(
-    at.id,
-    at.token,
-    JSON.stringify({
-      s: keys.stableKeys.map((k) => [k.node.id, k.hash]),
-      u: [...keys.uncachedKeys],
-    }),
-  )
+  if (args.hashCache.folds === undefined) return
+  const place = new Map<string, number>()
+  for (const id of args.nodes.keys()) place.set(id, place.size)
+  const row: KeysRow = { s: [], h: [], u: [], k: [] }
+  for (const key of keys.stableKeys) {
+    const n = place.get(key.node.id)
+    if (n === undefined) return
+    row.s.push(n)
+    row.h.push(key.hash)
+  }
+  for (const [id, key] of keys.uncachedKeys) {
+    const n = place.get(id)
+    if (n === undefined) return
+    row.u.push(n)
+    row.k.push(key)
+  }
+  args.hashCache.folds.set(at.id, at.token, JSON.stringify(row))
 }
 
 let identity: string | undefined

package/src/orchestrator/run-live.ts

@@ -43,6 +43,8 @@ export interface LiveTask {
   durationMs: number | null
 }
 
+type Ended = { status: OutcomeView['status']; startedAt: number | null; durationMs: number }
+
 /** What `vx last --live --format json` prints, the snapshot line. */
 export interface LiveSnapshot {
   live: { runId: string; command: string; pid: number; startedAt: number; elapsedMs: number }
@@ -113,11 +115,8 @@ export function serveLive(opts: {
   nodes: () => Iterable<TaskNode>
   warnings: () => readonly string[]
 }): { unlisten(): void; dispose(): void } {
-  const started = new Map<string, number>()
-  const ended = new Map<
-    string,
-    OutcomeView['status'] | { status: OutcomeView['status']; durationMs: number }
-  >()
+  // Each task's start, then its end: one map, not one for each.
+  const seen = new Map<string, number | Ended>()
   const peers = new Map<Socket<Peer>, Peer>()
   let followers = 0
 
@@ -155,12 +154,11 @@ export function serveLive(opts: {
     const tasks: LiveTask[] = []
     for (const node of opts.nodes()) {
       if (isGroupTask(node)) continue
-      const at = started.get(node.id) ?? null
-      const end = ended.get(node.id)
+      const at = seen.get(node.id)
       tasks.push(
-        end !== undefined && typeof end === 'object'
-          ? { taskId: node.id, status: end.status, startedAt: at, durationMs: end.durationMs }
-          : at !== null
+        typeof at === 'object'
+          ? { taskId: node.id, ...at }
+          : at !== undefined
             ? { taskId: node.id, status: 'running', startedAt: at, durationMs: null }
             : { taskId: node.id, status: 'waiting', startedAt: null, durationMs: null },
       )
@@ -184,10 +182,15 @@ export function serveLive(opts: {
   }
 
   const unsubscribe = opts.bus.subscribe((event) => {
-    if (event.kind === 'task:start') started.set(event.node.id, Date.now())
-    else if (event.kind === 'task:complete') {
-      ended.set(event.node.id, {
+    if (event.kind === 'task:start') {
+      const at = seen.get(event.node.id)
+      if (typeof at === 'object') at.startedAt = Date.now()
+      else seen.set(event.node.id, Date.now())
+    } else if (event.kind === 'task:complete') {
+      const at = seen.get(event.node.id)
+      seen.set(event.node.id, {
         status: event.outcome.status,
+        startedAt: typeof at === 'object' ? at.startedAt : (at ?? null),
         durationMs: event.outcome.durationMs,
       })
     }

package/src/orchestrator/run-lock.ts

@@ -5,7 +5,8 @@
 // run's restore is staging takes its files out from under it (item 215).
 // The cache itself is safe (SQLite waits, and an artifact lands by rename
 // inside its rows' transaction, A-3), across workspaces sharing one
-// `--cache-dir` too; the tree is not, and a run that finished "green" can
+// `--cache-dir` too (a clean of it waits for their runs, `holdCacheDir`);
+// the tree is not, and a run that finished "green" can
 // have had its restored outputs deleted by the other run's clean a moment
 // later. So a run takes this lock before it schedules and releases it with
 // its cache handle — before a persistent task's wait, so a dev server never
@@ -62,7 +63,7 @@
 // them and left by the last to release.
 
 import { chmodSync, lstatSync, mkdirSync, readFileSync, realpathSync } from 'node:fs'
-import { rmdirSync, unlinkSync } from 'node:fs'
+import { rmdirSync, rmSync, unlinkSync } from 'node:fs'
 import { mkdir, readdir, readFile, rename, rm, rmdir, unlink, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
@@ -79,6 +80,12 @@ const takers = new Map<string, string>()
  * must wait for it, not reclaim it as a dead run of this pid.
  */
 const placed = new Set<string>()
+/**
+ * Staging directories made and not yet renamed or removed: an exit between
+ * the mkdir and the rename left one, randomly named, in the lock root for
+ * good, no later taking knowing its name.
+ */
+const staged = new Set<string>()
 
 /**
  * A signal exit is `process.exit` (signals.ts): no finally runs and nothing
@@ -92,6 +99,13 @@ function releaseOnExit(): void {
   if (exitHooked) return
   exitHooked = true
   process.on('exit', () => {
+    for (const dir of staged) {
+      try {
+        rmSync(dir, { recursive: true, force: true })
+      } catch {
+        // best effort on the way out
+      }
+    }
     for (const [lockDir, entry] of takers) {
       // The entry may be gone already: a release under way unlinked it and
       // was still to remove the directory (item 867).
@@ -292,7 +306,15 @@ async function place(lockDir: string): Promise<string | null> {
   // start time, and a restarted container's pid 1 would meet the staging
   // directory a killed pid 1 left, and refuse every run after it.
   const staging = `${lockDir}.${entry}.${Math.random().toString(36).slice(2)}`
-  await mkdir(staging)
+  // Listed before the mkdir: the exit hook removes what it lists.
+  staged.add(staging)
+  releaseOnExit()
+  try {
+    await mkdir(staging)
+  } catch (err) {
+    staged.delete(staging)
+    throw err
+  }
   placed.add(entry)
   try {
     await writeFile(path.join(staging, entry), '')
@@ -304,6 +326,8 @@ async function place(lockDir: string): Promise<string | null> {
     const code = (err as NodeJS.ErrnoException).code
     if (code === 'ENOTEMPTY' || code === 'EEXIST') return null
     throw err
+  } finally {
+    staged.delete(staging)
   }
 }
 
@@ -384,7 +408,6 @@ export async function acquireRunLock(
       if (entry !== null) {
         heldHere.set(lockDir, 1)
         takers.set(lockDir, entry)
-        releaseOnExit()
         return held
       }
       h = await holder(lockDir)

package/src/orchestrator/run-records.ts

@@ -12,14 +12,10 @@ import { VERSION } from '../version.js'
 import type { CiContext, GitContext, HostContext } from './run-context.js'
 import { taskTelemetryOf, type TaskTelemetry } from './telemetry.js'
 import { isCacheHit } from '../graph/index.js'
+import { neverStarted } from '../report/index.js'
 
 export interface RunRecordsInput {
   outcomes: readonly TaskOutcome[]
-  /**
-   * Tasks that ran behind a failed dependency (`--continue=always`) or one
-   * `--exclude-dependencies` dropped, each with the task at the root of it.
-   */
-  tainted?: ReadonlyMap<string, string>
   runId: string
   /** Wall-clock ms at run start; every per-task ns offset is anchored to it. */
   startedAtMs: number
@@ -49,7 +45,7 @@ export interface RunRecordsInput {
 /** What a task's `runs` row reads besides its outcome. */
 export type RunRecordContext = Pick<
   RunRecordsInput,
-  'tainted' | 'runId' | 'startedAtMs' | 'endedAtMs' | 'forwardArgs' | 'blocks' | 'remoteTraffic'
+  'runId' | 'startedAtMs' | 'endedAtMs' | 'forwardArgs' | 'blocks' | 'remoteTraffic'
 >
 
 export interface RunRecords {
@@ -89,8 +85,13 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
   let restoredRemoteCount = 0
   for (const o of outcomes) {
     if (isGroupTask(o.node)) continue
-    // aborted (killed by a shutdown signal) isn't a real run.
-    if (o.status === 'aborted') continue
+    // aborted (killed by a shutdown signal) isn't a real run. One that
+    // started is still in the summary's task list, as the terminal lists it;
+    // one the stop reached first is only `notRunCount`.
+    if (o.status === 'aborted') {
+      if (input.withTelemetry && !neverStarted(o)) telemetryTasks.push(taskTelemetryOf(o))
+      continue
+    }
     if (input.withTelemetry) telemetryTasks.push(taskTelemetryOf(o))
     taskCount++
     if (input.landed?.has(o) !== true) runs.push(runRecordOf(o as RecordedOutcome, input))
@@ -141,7 +142,7 @@ export type RecordedOutcome = TaskOutcome & { status: RunRecord['status'] }
 /** One outcome's `runs` row. */
 export function runRecordOf(o: RecordedOutcome, input: RunRecordContext): RunRecord {
   const { runId, startedAtMs, endedAtMs } = input
-  const blockedBy = o.blockedBy ?? input.tainted?.get(o.node.id)
+  const blockedBy = o.blockedBy ?? o.taintedBy
   const remoteError = remoteErrorOf(input.remoteTraffic, o.hash)
   // Built field by field: a spread per optional field was ~2 µs of each
   // of a 1,200-hit warm run's rows.
@@ -168,9 +169,10 @@ export function runRecordOf(o: RecordedOutcome, input: RunRecordContext): RunRec
         ? startedAtMs + Math.round(Number(o.wallclockEndNs) / 1e6)
         : endedAtMs,
     runId,
-    cacheHit: hit,
     cached: o.node.config.cache === true,
   }
+  // A hit whose restore failed is neither: its `cache_hit` stays NULL.
+  if (o.restoreFailed !== true) r.cacheHit = hit
   if (o.hash !== undefined) r.hash = o.hash
   // A run forwards its args to the tasks it was asked for, never to a
   // dependency: the row says which ran with them.

package/src/orchestrator/run-report.ts

@@ -26,6 +26,7 @@ export type KeepRunEntry = (name: string, bytes: Uint8Array) => Promise<boolean>
 export interface RunKeeperArgs {
   readonly runId: string
   readonly workspaceRoot: string
+  /** Where each project's outputs stop (prepare.ts `outputWallsOf`). */
   readonly nestedDirsByProject: ReadonlyMap<string, string[]>
   readonly keep: KeepRunEntry
   /** Whether a failed task's log and outputs are kept (`cache.upload.failures`). */
@@ -44,7 +45,7 @@ export function keepsFailures(where: unknown, ci: boolean): boolean {
 const KEEP_CONCURRENCY = 8
 
 /** The files `node`'s declared outputs match on disk now, workspace-relative and sorted. */
-async function outputsLeft(
+export async function outputsLeft(
   node: TaskNode,
   workspaceRoot: string,
   nestedProjectDirs: string[],

package/src/orchestrator/run-stop.ts

@@ -18,6 +18,7 @@ import { hasEnded } from './persistent.js'
 import {
   forwardedSignal,
   forwardSignals,
+  type HeldSignals,
   SIGNAL_SHUTDOWN_GRACE_MS,
   type StopSignal,
   terminateChildren,
@@ -26,10 +27,11 @@ import {
 type Child = ReturnType<typeof Bun.spawn>
 
 /**
- * The abort reason that stops a run's own work and spares the servers it
- * was handed (`RunOptions.keep`), which it hands back. `vx watch` stops a
- * cycle waiting on a server that never becomes ready (WD-15); any other
- * stop took the unchanged servers down with it, and they restarted.
+ * The abort reason that stops a run's own work and spares its ready
+ * servers, handed in (`RunOptions.keep`) or made ready by the run, which
+ * it hands back. `vx watch` stops a cycle waiting on a server that never
+ * becomes ready (WD-15); any other stop took the unchanged servers down
+ * with it, and they restarted.
  */
 export const CYCLE_INTERRUPT = 'vx:cycle-interrupt'
 
@@ -77,25 +79,26 @@ export function runStop(args: {
   /** `RunOptions.handleSignals`. */
   handleSignals: boolean
   handsTerminal: boolean
+  /** What the run heard since it went for its lock (`holdSignals`). */
+  held: HeldSignals | undefined
   /** How many plugins have a teardown: each gets its own bound before a signal exits. */
   teardowns: number
   /** Called first when the run is stopped. */
   onStop: () => void
-  /** A server the run was handed: a `CYCLE_INTERRUPT` leaves it running. */
-  handed: (child: Child) => boolean
 }): RunStop {
   const { log, external } = args
   const liveChildren = new Set<Child>()
   // A server that ends on its own while the graph still runs is said at
   // once: its dependants were failing against it, and the end of the run
   // was the first word of it (C-69). Not once the graph is done (the end
-  // of the run and the keep-alive wait say it) nor under a stop.
+  // of the run and the keep-alive wait say it) nor under a stop, nor once
+  // the run took it out to stop it (no task left needed it).
   let graphDone = false
   const persistentRegistry = new (class extends Map<string, Child> {
     override set(id: string, child: Child): this {
       super.set(id, child)
       void child.exited.then((code) => {
-        if (code !== 0 && !graphDone && !controller.signal.aborted)
+        if (code !== 0 && !graphDone && !controller.signal.aborted && this.get(id) === child)
           warnOf(log)(`vx: ${id} exited with code ${code} while the run went on`)
       })
       return this
@@ -126,6 +129,7 @@ export function runStop(args: {
     },
     done: runLeft,
     handsTerminal: args.handsTerminal,
+    held: args.held,
     // The grace, then one flush and each teardown at their own bound, and
     // slack for the summary and the cache close.
     boundMs:
@@ -136,7 +140,11 @@ export function runStop(args: {
   const onAbort = (): void => {
     args.onStop()
     endedBeforeStop = new Set([...persistentRegistry.values()].filter(hasEnded))
-    const spare = controller.signal.reason === CYCLE_INTERRUPT ? args.handed : () => false
+    // Every ready server is in the registry, the handed ones included: the
+    // initial watch run is handed none, and its ready servers restarted.
+    const ready = new Set(persistentRegistry.values())
+    const spare = (c: Child): boolean =>
+      controller.signal.reason === CYCLE_INTERRUPT && ready.has(c)
     aborting = terminateChildren(
       () => [...liveChildren, ...persistentRegistry.values()].filter((c) => !spare(c)),
       forwardedSignal(controller.signal.reason),