@vzn/vx 0.0.649 → 0.0.651

package/src/index.ts

@@ -66,8 +66,15 @@ export { run, planRun, prepareRun } from './orchestrator/index.js'
 // (`@vzn/vx-history` does; a plugin package reaches core only
 // through this façade, which is what put these here).
 export { currentBranch } from './orchestrator/index.js'
-export { LocalHistoryProvider } from './history/index.js'
-export type { HistoryProvider, HistoryTable, TaskHistory, TaskResources } from './history/index.js'
+export { localHistory } from './history/index.js'
+export type {
+  HistoryProvider,
+  HistoryTable,
+  LocalHistory,
+  LocalHistoryOptions,
+  TaskHistory,
+  TaskResources,
+} from './history/index.js'
 export type { PreparedRun } from './orchestrator/index.js'
 // `RunOptions.affected`: what `--affected`'s diff changed, per project.
 export type { AffectedChanges } from './workspace/index.js'
@@ -138,7 +145,7 @@ export {
   taskNameProblem,
 } from './workspace/index.js'
 // Output components: a plugin draws its lines with core's, so they look alike.
-export { ui } from './util/index.js'
+export { ui } from './ui/index.js'
 export type {
   ApplyMigrationArgs,
   MigrationFormat,
@@ -179,10 +186,12 @@ export type {
   CacheFacts,
   TaskArtifacts,
   FingerprintChange,
+  FingerprintDigests,
   FingerprintClaim,
   FingerprintContext,
   GraphHookContext,
   KeyHookContext,
+  LockedFile,
   PluginCommand,
   ProjectHookContext,
   ScheduleHookContext,

package/src/orchestrator/doctor.ts

@@ -7,7 +7,7 @@
 
 import os from 'node:os'
 import path from 'node:path'
-import { Cache, CACHE_VERSION, SCHEMA_VERSION } from '../cache/index.js'
+import { indexDb, Cache, CACHE_VERSION, SCHEMA_VERSION } from '../cache/index.js'
 import { PLUGIN_HOOKS, type WorkspaceConfig } from '../config.js'
 import {
   cgroupCpuQuota,
@@ -19,8 +19,8 @@ import {
   machineMemoryBytes,
   machineParallelism,
   treeBytes,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import { vxPath } from '../handoff.js'
 import { VERSION } from '../version.js'
 import { probeSandbox, resetSandbox, untracedReason } from '../exec/index.js'
@@ -245,7 +245,7 @@ async function collectWorkspaceInfo(
       indexStore = cache.storeDir
       stats = cache.stats()
       orphans = await cache.orphanStats()
-      flaky = flakyTasks(cache.dbHandle())
+      flaky = flakyTasks(indexDb(cache))
     } finally {
       cache.close()
     }

package/src/orchestrator/execute-task.ts

@@ -72,6 +72,7 @@ import {
   bracketLiteralHint,
   markUnsaved,
   saveMiss,
+  unsavedOutputBytes,
   type OutputDirSnapshot,
   type SaveFacts,
 } from './miss-save.js'
@@ -1347,6 +1348,8 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   let movedFails: string | undefined
   let own: Awaited<ReturnType<typeof ownOutputs>>
   let saved = false
+  // An unsaved miss's outputs, as a save's are counted: its row's `outputs`.
+  let unsavedBytes: number | undefined
   if (
     effectiveExitCode === 0 &&
     willSave &&
@@ -1408,7 +1411,17 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     // entry is in; without one, the save is taken as done.
     if (args.deferredSaves !== undefined) args.deferredSaves.set(node.id, landed)
     else saved = true
-  } else if (cfgCacheable && !remoteOnly && !deferralRequested && args.noDependants !== true) {
+  } else if (cfgCacheable && !remoteOnly && !deferralRequested && args.noDependants === true) {
+    // Nothing reads after it, so nothing to mark: only its row's `outputs`.
+    if (effectiveExitCode === 0)
+      unsavedBytes = await unsavedOutputBytes({
+        node,
+        workspaceRoot: args.workspaceRoot,
+        nestedProjectDirs: args.nestedProjectDirs,
+        outputs,
+        wsOutputs,
+      })
+  } else if (cfgCacheable && !remoteOnly && !deferralRequested) {
     // Ran here and saves nothing — failed, a read-only policy, a tainted
     // upstream, a key that no longer held — yet it wrote what a save would
     // have marked, and may have rewritten an input the re-check before a
@@ -1422,7 +1435,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     if (moved !== undefined) {
       forgetUndeclaredWrites(args, wsOutputs.length > 0 ? 'workspace' : 'project')
     } else {
-      await markUnsaved({
+      unsavedBytes = await markUnsaved({
         node,
         workspaceRoot: args.workspaceRoot,
         nestedProjectDirs: args.nestedProjectDirs,
@@ -1572,6 +1585,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     ...(unkeyed ? { unkeyed: true as const } : {}),
     ...(keylessBy !== undefined ? { keylessBy } : {}),
     ...(saved ? { saved: true as const } : {}),
+    ...(unsavedBytes !== undefined ? { outputBytes: unsavedBytes } : {}),
     ...(effectiveExitCode !== 0 && output !== undefined
       ? { failedOutput: failedOutputLog(output, willSave || args.keepRun !== undefined, storeMask) }
       : {}),

package/src/orchestrator/graph-memo.ts

@@ -12,7 +12,12 @@
 // it is never remembered.
 
 import type { FoldMemo } from '../cache/index.js'
-import { buildTaskGraph, declaredTask, type TaskNode } from '../graph/index.js'
+import {
+  buildTaskGraph,
+  computeReverseDepCount,
+  declaredTask,
+  type TaskNode,
+} from '../graph/index.js'
 import { xxh3hex } from '../util/index.js'
 import type { ProjectMeta } from '../workspace/index.js'
 import { codeIdentity } from './run-keys.js'
@@ -138,3 +143,47 @@ function rebuilt(
   }
   return nodes
 }
+
+/**
+ * The run's dependents count, the scheduler's baseline and every row's
+ * `blocks`, read back with the graph it was counted on: the closure over a
+ * 9,603-task graph (11k nodes) was ~100 ms of every warm run, the same each
+ * time (2026-10-29). `token` names the graph's edges (`memoGraph`, undefined
+ * once anything edited them), the node ids which of them this run kept
+ * (`--affected` prunes under the same token).
+ */
+export function graphCounts(
+  nodes: ReadonlyMap<string, TaskNode>,
+  folds: FoldMemo | undefined,
+  token: string | undefined,
+): Map<string, number> {
+  if (folds === undefined || token === undefined) return computeReverseDepCount(nodes)
+  // Not `counts`: those rows held a second count the rows no longer show.
+  const id = `\0dependents\0${token}`
+  const probe = xxh3hex([...nodes.keys()].join('\0'))
+  const row = folds.get(id, probe)
+  if (row !== undefined) {
+    const back = countsOf(row, nodes)
+    if (back !== undefined) return back
+  }
+  const counts = computeReverseDepCount(nodes)
+  folds.set(id, probe, JSON.stringify([...nodes.keys()].map((k) => counts.get(k)!)))
+  return counts
+}
+
+function countsOf(
+  row: string,
+  nodes: ReadonlyMap<string, TaskNode>,
+): Map<string, number> | undefined {
+  let all: number[]
+  try {
+    all = JSON.parse(row) as number[]
+  } catch {
+    return undefined
+  }
+  if (all?.length !== nodes.size) return undefined
+  const counts = new Map<string, number>()
+  let i = 0
+  for (const id of nodes.keys()) counts.set(id, all[i++]!)
+  return counts
+}

package/src/orchestrator/graph-stage.ts

@@ -29,6 +29,12 @@ export async function applyGraphStage(
   // keyed and cleaned its outputs there: past the hard project boundary.
   const dirs = new Map(args.projectMetas.map((m) => [m.name, path.resolve(m.dir)]))
   const shown = (dir: string): string => relPosix(args.workspaceRoot, dir) || '.'
+  // The lock shares a task config two tasks declare alike: an edit in place
+  // works on this node's own copy.
+  if (plugins.some((p) => p.graph !== undefined)) {
+    for (const n of nodes.values())
+      if (!isDefaultBuild(n.config)) n.config = structuredClone(n.config)
+  }
   await applyGraphHooks(
     plugins,
     nodes,

package/src/orchestrator/hit-restore.ts

@@ -458,6 +458,9 @@ function hitOutcome(restore: RestoreHitArgs, restored: boolean): TaskOutcome {
     ...(hit.cpuMs !== undefined ? { storedCpuMs: hit.cpuMs } : {}),
     ...(hit.peakRssBytes !== undefined ? { storedPeakRssBytes: hit.peakRssBytes } : {}),
     ...(hit.sizeBytes !== undefined ? { artifactBytes: hit.sizeBytes } : {}),
+    ...(hit.outputRows !== undefined
+      ? { outputBytes: hit.outputRows.reduce((n, r) => n + r.size, 0) }
+      : {}),
     ...(hit.fetchMs !== undefined ? { fetchMs: hit.fetchMs } : {}),
     hash,
     restored: restored || hit.source === 'remote',

package/src/orchestrator/index.ts

@@ -60,6 +60,7 @@ export {
   type CommandContext,
   type GraphHookContext,
   type KeyHookContext,
+  type LockedFile,
   type PluginCommand,
   type ProjectHookContext,
   type ScheduleHookContext,
@@ -78,6 +79,7 @@ export {
   type RunReport,
   type RunReportTask,
   type FingerprintChange,
+  type FingerprintDigests,
   type FingerprintClaim,
   type FingerprintContext,
   type VxPlugin,
@@ -95,6 +97,7 @@ export {
   applyScheduleHooks,
   claimedAffected,
   claimedExtraFiles,
+  claimedDigests,
   fingerprintClaims,
   hasHook,
   REMOTE_CACHE_METHODS,
@@ -146,7 +149,6 @@ export {
   type TaskLog,
   taskLog,
 } from './run-failures.js'
-export { type RunStep, runSteps, runWarnings } from './run-steps.js'
 export { resolveRunId, shortRunId } from './run-id.js'
 export { collectInfo, type CollectInfoOptions, type InfoFacts } from './doctor.js'
 export { localFloor, type LocalFloor } from './local-floor.js'

package/src/orchestrator/live-usage.ts

@@ -0,0 +1,98 @@
+// The live list's `cpu` and `mem`: each running task's process tree's
+// average cores since it started and its peak memory so far, the values
+// its results row shows once it ends (2026-10-29: the live row showed the
+// last half second's, and a task's row changed meaning as it finished).
+// Looked at on a timer only once the list asks for a row, so a run with
+// no live list (a pipe, CI) registers pids and reads nothing.
+// The look is async and off the dispatch path: a slow one skips a tick.
+
+import { sampleTrees, type TreeUsage } from '../exec/index.js'
+import type { LiveUsage } from '../report/index.js'
+
+/** How often a tracked tree is looked at while the live list shows. */
+const LOOK_MS = 500
+
+type Every = (ms: number, fn: () => Promise<void>) => () => void
+
+const everyInterval: Every = (ms, fn) => {
+  const timer = setInterval(() => void fn(), ms)
+  timer.unref()
+  return () => clearInterval(timer)
+}
+
+interface Tracked {
+  pid: number
+  startedAt: number
+  /** The most CPU time the tree has shown: a descendant that exits takes its share out of the sum. */
+  cpuMs: number
+  peakRssBytes: number
+  now?: LiveUsage
+}
+
+export function createLiveUsage(
+  opts: {
+    every?: Every
+    now?: () => number
+    sample?: (pids: number[]) => Promise<Map<number, TreeUsage>>
+  } = {},
+): {
+  track(taskId: string, pid: number): () => void
+  usage(taskId: string): LiveUsage | undefined
+} {
+  const every = opts.every ?? everyInterval
+  const now = opts.now ?? Date.now
+  const sample = opts.sample ?? sampleTrees
+  const tracked = new Map<string, Tracked>()
+  let asked = false
+  let looking = false
+  let stop: (() => void) | undefined
+
+  const look = async (): Promise<void> => {
+    if (looking) return
+    looking = true
+    try {
+      const entries = [...tracked]
+      const usage = await sample(entries.map(([, t]) => t.pid))
+      const ts = now()
+      for (const [id, t] of entries) {
+        const u = usage.get(t.pid)
+        if (u === undefined || tracked.get(id) !== t) continue
+        t.cpuMs = Math.max(t.cpuMs, u.cpuMs)
+        t.peakRssBytes = Math.max(t.peakRssBytes, u.rssBytes)
+        if (ts > t.startedAt) {
+          const cores = t.cpuMs / (ts - t.startedAt)
+          t.now = { cores: Math.round(cores * 100) / 100, rssBytes: t.peakRssBytes }
+        }
+      }
+    } catch {
+      // A failed look is a missing point, never a broken run.
+    } finally {
+      looking = false
+    }
+  }
+  const start = (): void => {
+    if (asked && stop === undefined && tracked.size > 0) stop = every(LOOK_MS, look)
+  }
+
+  return {
+    track(taskId, pid) {
+      const t: Tracked = { pid, startedAt: now(), cpuMs: 0, peakRssBytes: 0 }
+      tracked.set(taskId, t)
+      start()
+      return () => {
+        if (tracked.get(taskId) === t) tracked.delete(taskId)
+        if (tracked.size === 0 && stop !== undefined) {
+          stop()
+          stop = undefined
+        }
+      }
+    },
+    usage(taskId) {
+      if (!asked) {
+        asked = true
+        start()
+      }
+      return tracked.get(taskId)?.now
+    },
+  }
+}

package/src/orchestrator/locked-digests.ts

@@ -0,0 +1,63 @@
+// A run keys a claimed file from what `vx lock` recorded of it in
+// `.vx/dependencies.lock.json`, as it takes configs from the config lock:
+// the digests are read, never derived, so no run parses a lockfile for
+// its key. The record holds only while the file's bytes hash to what was
+// recorded: one that moved (an install) refuses the run before any key is
+// folded, naming the file and `vx lock`. A present file with no record,
+// or no lock at all, refuses when a claimant asks for it: an absent record
+// is never read as "no dependencies". The other files the digests read
+// (`extras`: a `link:` directory, a patch) are handed to the claimant with
+// their recorded hashes: a linked directory is edited with no install, so
+// one that moved is the claimant's to digest anew, not a refusal.
+
+import {
+  DEPENDENCIES_LOCK_NAME,
+  type DependenciesLock,
+  lockKey,
+  parseDependenciesLock,
+  recordedDigests,
+} from '../workspace/index.js'
+import { UserError, xxh3hex } from '../util/index.js'
+import type { KeyHookContext, LockedFile } from './plugin.js'
+
+const refused = (message: string): UserError => new UserError(message, 'VX_E_LOCK')
+
+/**
+ * `KeyHookContext.locked` for one run, over the claimed files' bytes as
+ * the run read them (`readClaimedFiles`; absent ones are missing) and the
+ * lock's bytes (null when there is none). Each recorded claimed file is
+ * checked first: one whose bytes moved, or that is gone, throws here.
+ */
+export function lockedFiles(
+  workspaceRoot: string,
+  claimed: readonly string[],
+  bytes: ReadonlyMap<string, Uint8Array>,
+  lockBytes: Uint8Array | null,
+): KeyHookContext['locked'] {
+  const lock: DependenciesLock | null = parseDependenciesLock(lockBytes)
+  const records = new Map<string, LockedFile>()
+  for (const file of claimed) {
+    const rec = lock === null ? undefined : recordedDigests(lock, file)
+    if (rec === undefined) continue
+    const now = bytes.get(file)
+    if (now === undefined || xxh3hex(now) !== rec.hash) {
+      throw refused(`${file} changed since \`vx lock\`: run \`vx lock\``)
+    }
+    records.set(file, {
+      extras: rec.extras,
+      digest(projectDir) {
+        const dir = lockKey(workspaceRoot, projectDir)
+        if (!rec.has(dir))
+          throw refused(`${dir} is not in ${DEPENDENCIES_LOCK_NAME}: run \`vx lock\``)
+        return rec.of(dir)
+      },
+    })
+  }
+  return async (file) => {
+    const rec = records.get(file)
+    if (rec !== undefined || !bytes.has(file)) return rec
+    if (lockBytes === null) throw refused(`no ${DEPENDENCIES_LOCK_NAME}: run \`vx lock\``)
+    if (lock === null) throw refused(`${DEPENDENCIES_LOCK_NAME} is invalid, run \`vx lock\``)
+    throw refused(`${file} is not in ${DEPENDENCIES_LOCK_NAME}: run \`vx lock\``)
+  }
+}