@vzn/vx 0.0.650 → 0.0.651

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/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,

package/src/orchestrator/live-usage.ts

@@ -1,6 +1,9 @@
-// The live list's `cpu` and `mem`: what each running task's process tree
-// uses now. 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 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'
@@ -19,7 +22,10 @@ const everyInterval: Every = (ms, fn) => {
 
 interface Tracked {
   pid: number
-  last?: { ts: number; cpuMs: 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
 }
 
@@ -51,13 +57,12 @@ export function createLiveUsage(
       for (const [id, t] of entries) {
         const u = usage.get(t.pid)
         if (u === undefined || tracked.get(id) !== t) continue
-        // A descendant that exited takes its CPU out of the live sum, so
-        // an interval can read negative: none is shown below zero.
-        if (t.last !== undefined && ts > t.last.ts) {
-          const cores = Math.max(0, (u.cpuMs - t.last.cpuMs) / (ts - t.last.ts))
-          t.now = { cores: Math.round(cores * 100) / 100, rssBytes: u.rssBytes }
+        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 }
         }
-        t.last = { ts, cpuMs: u.cpuMs }
       }
     } catch {
       // A failed look is a missing point, never a broken run.
@@ -71,7 +76,7 @@ export function createLiveUsage(
 
   return {
     track(taskId, pid) {
-      const t: Tracked = { pid }
+      const t: Tracked = { pid, startedAt: now(), cpuMs: 0, peakRssBytes: 0 }
       tracked.set(taskId, t)
       start()
       return () => {

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\``)
+  }
+}

package/src/orchestrator/lockfile-claim.ts

@@ -7,11 +7,18 @@
 // fallback for a project the file does not list and the `--affected`
 // diff are one implementation here, so a third lockfile is a parser.
 //
-// The digests are memoised in cache.db (`lockfile_memos`, one row per
-// lockfile and claimant) by the file's xxh3, so a warm run pays one read +
-// hash + one row read, never a parse; within one process (a run, a watch cycle) the file's size,
-// mtime, ctime and inode gate even the read; and per run the read happens once (a WeakMap
-// on the context core hands every `key` call of a run).
+// A run's key reads each project's digest from `.vx/dependencies.lock.json`
+// (`KeyHookContext.locked`), never the file: only `vx lock` and
+// `--affected` digest it, and a run whose extra file (a `link:` directory,
+// edited with no install) moved since the lock, as the record is stale
+// for it then. What the `discover` and `project` stages read
+// (the edges, the recorded names) is memoised in cache.db
+// (`lockfile_memos`, one row per lockfile and claimant) by the file's xxh3,
+// so a warm run pays one read + hash + one row read, never a parse; within
+// one process (a run, a watch cycle) the file's size, mtime, ctime and
+// inode gate even the read. A run's read leaves the digests out (most of a
+// parse: 9-25 ms on this repo's bun.lock, against 4-13 for the text), and
+// `vx lock` adds them to the memo.
 
 import path from 'node:path'
 import { stat } from 'node:fs/promises'
@@ -104,21 +111,27 @@ export interface LockfileClaimHooks {
 }
 
 interface Digests {
-  /** xxh3 of the lockfile bytes; '' when the file is absent. */
+  /** xxh3 of the lockfile bytes and the extra files' hashes; '' when the file is absent. */
   readonly lock: string
-  readonly importers: ReadonlyMap<string, string>
+  /** xxh3 of the lockfile bytes alone. */
+  readonly bytes: string
+  /** The extra files the digests read. */
+  readonly extras: readonly string[]
+  /** Each importer's digest; undefined when the read that made this left them out. */
+  readonly importers: ReadonlyMap<string, string> | undefined
   readonly edges: ReadonlyMap<string, LockfileImporter>
   readonly recorded: ReadonlyMap<string, ReadonlySet<string>> | undefined
 }
 
 /**
- * A root-relative extra file's content hash, '' when absent; a path leaving
- * the root is never read. One there but unreadable (EACCES, a symlink loop)
- * refuses, as a settings file does: folded as '', it keyed as no file at all.
+ * A root-relative extra file's content hash, '' when absent. A path above
+ * the root is read too: a `file:` or `link:` directory beside the checkout
+ * is what a task imports, and left unread an edit in it moved no key. One
+ * there but unreadable (EACCES, a symlink loop) refuses, as a settings file
+ * does: folded as '', it keyed as no file at all.
  */
-async function hashExtra(workspaceRoot: string, rel: string): Promise<string> {
-  if (path.isAbsolute(rel) || rel.split(/[\\/]/).includes('..')) return 'outside-root'
-  const abs = path.join(workspaceRoot, rel)
+export async function hashExtra(workspaceRoot: string, rel: string): Promise<string> {
+  const abs = path.resolve(workspaceRoot, rel)
   try {
     return xxh3hex(await Bun.file(abs).bytes())
   } catch (err) {
@@ -168,7 +181,7 @@ function identityOf(st: { size: number; mtimeMs: number; ctimeMs: number; ino: n
 async function statsOf(workspaceRoot: string, rels: readonly string[]): Promise<string[]> {
   return Promise.all(
     rels.map((rel) =>
-      stat(path.join(workspaceRoot, rel)).then(
+      stat(path.resolve(workspaceRoot, rel)).then(
         (st) => (st.isDirectory() ? hashExtra(workspaceRoot, rel) : identityOf(st)),
         () => 'gone',
       ),
@@ -234,8 +247,17 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
   }
   // Per run: every `key` call of one run gets the same context object.
   const perRun = new WeakMap<object, Promise<Digests>>()
+  const lockedPerRun = new WeakMap<
+    object,
+    Promise<((dir: string) => string | undefined) | undefined>
+  >()
 
-  const load = async (workspaceRoot: string, cacheDir: string): Promise<Digests> => {
+  /** `withDigests`: each importer's digest too, which only `vx lock` and `--affected` read. */
+  const load = async (
+    workspaceRoot: string,
+    cacheDir: string,
+    withDigests: boolean,
+  ): Promise<Digests> => {
     const full = path.join(workspaceRoot, file)
     let identity: string
     try {
@@ -243,6 +265,8 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     } catch {
       const digests: Digests = {
         lock: '',
+        bytes: '',
+        extras: [],
         importers: new Map(),
         edges: new Map(),
         recorded: undefined,
@@ -251,7 +275,11 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
       return digests
     }
     const last = seen.get(workspaceRoot)
-    if (last !== undefined && last.identity === identity) {
+    if (
+      last !== undefined &&
+      last.identity === identity &&
+      (!withDigests || last.digests.importers !== undefined)
+    ) {
       const now = await statsOf(workspaceRoot, last.extras)
       if (now.every((s, i) => s === last.extraStats[last.extras[i]!])) {
         if (last.unsaved !== undefined && writeLockfileMemo(cacheDir, file, claimant, last.unsaved))
@@ -270,17 +298,19 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     let edges: ReadonlyMap<string, LockfileImporter> = new Map()
     let recorded: ReadonlyMap<string, readonly string[]> | undefined
     let unsaved: LockfileMemo | undefined
-    if (memo !== undefined) {
+    let served = false
+    if (memo !== undefined && (!withDigests || memo.importers !== null)) {
       const now = await hashExtras(workspaceRoot, Object.keys(memo.extras))
       if (Object.entries(memo.extras).every(([rel, h]) => now.hashes[rel] === h)) {
+        served = true
         extras = memo.extras
         extraStats = now.stats
-        importers = new Map(Object.entries(memo.importers))
+        importers = memo.importers === null ? undefined : new Map(Object.entries(memo.importers))
         edges = new Map(Object.entries(memo.edges as Record<string, LockfileImporter>))
         recorded = memo.recorded === undefined ? undefined : new Map(Object.entries(memo.recorded))
       }
     }
-    if (importers === undefined) {
+    if (!served) {
       const text = decode(bytes)
       const rels = [...new Set(options.extraFiles?.(text) ?? [])].sort()
       const now = await hashExtras(workspaceRoot, rels)
@@ -289,7 +319,9 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
       importers =
         scope === 'workspace'
           ? new Map<string, string>()
-          : digest(text, new Map(Object.entries(extras)))
+          : withDigests
+            ? digest(text, new Map(Object.entries(extras)))
+            : undefined
       edges = options.importers?.(text) ?? new Map()
       recorded = options.recorded?.(text)
       if (memoises) {
@@ -297,7 +329,7 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
           version,
           lock: lockHash,
           extras,
-          importers: Object.fromEntries(importers),
+          importers: importers === undefined ? null : Object.fromEntries(importers),
           edges: Object.fromEntries(edges),
           ...(recorded !== undefined ? { recorded: Object.fromEntries(recorded) } : {}),
         }
@@ -311,6 +343,8 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         : xxh3hex([lockHash, ...rels.map((r) => `${r}\0${extras[r]}`)].join('\0'))
     const digests: Digests = {
       lock,
+      bytes: lockHash,
+      extras: rels,
       importers,
       edges,
       recorded:
@@ -327,10 +361,36 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
     })
     return digests
   }
+  /**
+   * Each project's digest for this run: the lock's, unless an extra file
+   * it records moved since (then a digest of the file as it is now, as
+   * `vx lock` would record it); undefined when the file is absent.
+   */
+  const lockedOnce = (
+    ctx: KeyHookContext,
+  ): Promise<((dir: string) => string | undefined) | undefined> => {
+    let p = lockedPerRun.get(ctx)
+    if (p === undefined) {
+      p = (async () => {
+        const rec = await ctx.locked(file)
+        if (rec === undefined) return undefined
+        const rels = Object.keys(rec.extras)
+        const now = await Promise.all(rels.map((rel) => hashExtra(ctx.workspaceRoot, rel)))
+        if (now.every((h, i) => h === rec.extras[rels[i]!])) {
+          return (dir: string) => rec.digest(dir)
+        }
+        const digests = await load(ctx.workspaceRoot, ctx.cacheDir, true)
+        const importers = digests.importers!
+        return (dir: string) => digestFor(importers, importerOf(ctx.workspaceRoot, dir))
+      })()
+      lockedPerRun.set(ctx, p)
+    }
+    return p
+  }
   const loadOnce = (ctx: KeyHookContext): Promise<Digests> => {
     let p = perRun.get(ctx)
     if (p === undefined) {
-      p = load(ctx.workspaceRoot, ctx.cacheDir)
+      p = load(ctx.workspaceRoot, ctx.cacheDir, false)
       perRun.set(ctx, p)
     }
     return p
@@ -378,6 +438,24 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         }
         return names
       },
+      // What `vx lock` commits, so `--affected` reads the base's digests
+      // instead of parsing the base's file.
+      async digests(_file: string, ctx: FingerprintContext) {
+        if (scope === 'workspace') return undefined
+        const digests = await load(ctx.workspaceRoot, ctx.cacheDir, true)
+        if (digests.lock === '') return undefined
+        const importers = digests.importers!
+        return {
+          hash: digests.bytes,
+          projects: Object.fromEntries(
+            ctx.projects.map((p) => [
+              p.name,
+              digestFor(importers, importerOf(ctx.workspaceRoot, p.dir)),
+            ]),
+          ),
+          ...(digests.extras.length > 0 ? { extras: digests.extras } : {}),
+        }
+      },
       ...(options.extraFiles !== undefined
         ? {
             // The memo records which files these exact bytes name, for this
@@ -393,19 +471,20 @@ export function lockfileClaim(options: LockfileClaimOptions): LockfileClaimHooks
         : {}),
     },
     async key(task, ctx) {
-      const digests = await loadOnce(ctx)
-      if (digests.lock === '') return undefined
-      if (scope === 'workspace') return { [part]: digests.lock }
-      return {
-        [part]: digestFor(digests.importers, importerOf(ctx.workspaceRoot, task.projectDir)),
+      if (scope === 'project') {
+        const digestOf = await lockedOnce(ctx)
+        const digest = digestOf?.(task.projectDir)
+        return digest === undefined ? undefined : { [part]: digest }
       }
+      const digests = await loadOnce(ctx)
+      return digests.lock === '' ? undefined : { [part]: digests.lock }
     },
     async importers(ctx) {
-      const digests = await load(ctx.workspaceRoot, ctx.cacheDir)
+      const digests = await load(ctx.workspaceRoot, ctx.cacheDir, false)
       return digests.lock === '' ? undefined : digests.edges
     },
     async recorded(ctx) {
-      const digests = await load(ctx.workspaceRoot, ctx.cacheDir)
+      const digests = await load(ctx.workspaceRoot, ctx.cacheDir, false)
       return digests.lock === '' ? undefined : digests.recorded
     },
   }

package/src/orchestrator/miss-save.ts

@@ -146,6 +146,8 @@ export interface SaveMissArgs {
 export interface SaveFacts {
   saveMs?: number
   artifactBytes?: number
+  /** The saved files' bytes, as a hit's `outputBytes` counts them: the row's `outputs`. */
+  outputBytes?: number
   /** The entry landed: the outcome's `saved`, set only once it has. */
   saved?: true
 }
@@ -239,6 +241,8 @@ export async function saveMiss(a: SaveMissArgs): Promise<{ landed: Promise<SaveF
       },
     })
     endSave()
+    const bytes = cache.outputBytes?.(a.hash)
+    if (bytes !== undefined) facts.outputBytes = bytes
     if (a.measure === true) {
       facts.saveMs = Math.round(performance.now() - saveStart)
       // No local artifact (local writes off): no size to say.
@@ -294,9 +298,26 @@ export type UnsavedArgs = Pick<
  * A miss that ran here and saves nothing (it failed, the policy writes
  * nothing, an upstream failed, its key no longer held) still wrote its
  * outputs, and a same-project reader after it must see them as it sees a
- * save's: resolved and marked the same way.
+ * save's: resolved and marked the same way. Returns their bytes, the
+ * row's `outputs`: blank, an unsaved miss read as one that wrote nothing.
  */
-export async function markUnsaved(a: UnsavedArgs): Promise<void> {
+export async function markUnsaved(a: UnsavedArgs): Promise<number> {
+  const { outputFiles, wsOutputFiles } = await resolveUnsaved(a)
+  markWritten(a, outputFiles, wsOutputFiles)
+  return sizeOf(a.node.projectDir, outputFiles) + sizeOf(a.workspaceRoot, wsOutputFiles)
+}
+
+/** An unsaved miss nothing reads after: only the bytes of its outputs, its row's `outputs`. */
+export async function unsavedOutputBytes(
+  a: Pick<UnsavedArgs, 'node' | 'workspaceRoot' | 'nestedProjectDirs' | 'outputs' | 'wsOutputs'>,
+): Promise<number> {
+  const { outputFiles, wsOutputFiles } = await resolveUnsaved(a)
+  return sizeOf(a.node.projectDir, outputFiles) + sizeOf(a.workspaceRoot, wsOutputFiles)
+}
+
+async function resolveUnsaved(
+  a: Pick<UnsavedArgs, 'node' | 'workspaceRoot' | 'nestedProjectDirs' | 'outputs' | 'wsOutputs'>,
+): Promise<{ outputFiles: string[]; wsOutputFiles: string[] }> {
   const endResolve = span('miss: resolve outputs')
   const outputFiles = await resolveOutputs({
     projectDir: a.node.projectDir,
@@ -308,7 +329,14 @@ export async function markUnsaved(a: UnsavedArgs): Promise<void> {
     outputs: a.wsOutputs,
   })
   endResolve()
-  markWritten(a, outputFiles, wsOutputFiles)
+  return { outputFiles, wsOutputFiles }
+}
+
+/** The bytes of `files` (absolute, or under `base`); one gone since it was listed counts none. */
+function sizeOf(base: string, files: readonly string[]): number {
+  let n = 0
+  for (const f of files) n += statSync(path.resolve(base, f), { throwIfNoEntry: false })?.size ?? 0
+  return n
 }
 
 /**

package/src/orchestrator/persistent-task.ts

@@ -283,7 +283,9 @@ export async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutc
     const message = err instanceof Error ? err.message : String(err)
     // The task's OWN stream, not the process's: the frame is where a
     // reader looks for why a task failed, and a run with a custom logger
-    // (an embedder) never saw a bare stderr write at all.
+    // (an embedder) never saw a bare stderr write at all. What waited on
+    // an open line goes first.
+    ends.end()
     log.taskStderr(
       node,
       ends.own(`[vx] ${node.id}: persistent task failed to become ready: ${message}\n`),

package/src/orchestrator/plan.ts

@@ -225,7 +225,11 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
     )
     const dependents = new Map<string, string[]>()
     for (const node of args.nodes.values())
-      for (const dep of node.deps) dependents.set(dep, [...(dependents.get(dep) ?? []), node.id])
+      for (const dep of node.deps) {
+        const ds = dependents.get(dep)
+        if (ds === undefined) dependents.set(dep, [node.id])
+        else ds.push(node.id)
+      }
     for (const id of idleServers(args.nodes, dependents, restoreTier))
       cacheStatusById.set(id, 'not-started')
   }