@vzn/vx 0.0.650 → 0.0.651

package/src/cache/git-inputs.ts

@@ -8,11 +8,15 @@
 import os from 'node:os'
 import path from 'node:path'
 import {
+  closeSync,
   existsSync,
+  fstatSync,
   lstatSync,
   mkdtempSync,
+  openSync,
   readdirSync,
   readFileSync,
+  readSync,
   realpathSync,
   renameSync,
   rmSync,
@@ -892,7 +896,12 @@ export function fileIdentity(mode: string, oid: string): string {
 function parseLsFilesOutput(
   records: readonly string[],
   undecodableRecords: ReadonlySet<string>,
-  debug?: { sizes: readonly number[]; indexed: Map<string, { oid: string; size: number }> },
+  debug?: {
+    sizes: readonly number[]
+    ctimes: readonly number[]
+    mtimes: readonly number[]
+    indexed: Map<string, { oid: string; size: number; ctime: number; mtime: number }>
+  },
 ): GitLsResult {
   const files: string[] = []
   const oids = new Map<string, string>()
@@ -914,7 +923,12 @@ function parseLsFilesOutput(
     if ((mode === '100644' || mode === '100755' || mode === '120000') && stage === '0') {
       oids.set(filePath, fileIdentity(mode, m[3]!))
       if (debug !== undefined && mode !== '120000') {
-        debug.indexed.set(filePath, { oid: m[3]!, size: debug.sizes[i]! })
+        debug.indexed.set(filePath, {
+          oid: m[3]!,
+          size: debug.sizes[i]!,
+          ctime: debug.ctimes[i]!,
+          mtime: debug.mtimes[i]!,
+        })
       }
     } else if (mode === '160000') {
       gitlinks.add(filePath)
@@ -940,11 +954,15 @@ function parseLsFilesOutput(
 function splitLsDebug(run: GitRun): {
   records: string[]
   sizes: number[]
+  ctimes: number[]
+  mtimes: number[]
   undecodable: Set<string>
 } {
   const segs = run.stdout.split('\0')
   const records: string[] = []
   const sizes: number[] = []
+  const ctimes: number[] = []
+  const mtimes: number[] = []
   const undecodable = new Set<string>()
   let record = segs[0]!
   let recordRaw = record
@@ -952,12 +970,22 @@ function splitLsDebug(run: GitRun): {
     const seg = segs[i]
     let rest = ''
     let size = -1
+    let ctime = -1
+    let mtime = -1
     if (seg !== undefined) {
       let at = 0
       for (let k = 0; k < 5 && at >= 0; k++) {
         const nl = seg.indexOf('\n', at)
         if (nl < 0) at = -1
         else {
+          // `  ctime: <sec>:<nsec>`, then `  mtime: <sec>:<nsec>`.
+          if (k < 2) {
+            const n = parseInt(seg.slice(seg.indexOf(':', at) + 1, nl), 10)
+            if (!Number.isNaN(n)) {
+              if (k === 0) ctime = n
+              else mtime = n
+            }
+          }
           if (k === 4) {
             const field = seg.indexOf('size: ', at)
             if (field >= 0 && field < nl) {
@@ -973,12 +1001,14 @@ function splitLsDebug(run: GitRun): {
     if (record.length > 0) {
       records.push(record)
       sizes.push(size)
+      ctimes.push(ctime)
+      mtimes.push(mtime)
       if (run.undecodable.has(recordRaw)) undecodable.add(record)
     }
     record = rest
     recordRaw = seg ?? ''
   }
-  return { records, sizes, undecodable }
+  return { records, sizes, ctimes, mtimes, undecodable }
 }
 
 /**
@@ -998,6 +1028,8 @@ export interface IndexBlobs {
   paths: string[]
   oids: string[]
   sizes: number[]
+  /** Entries git cannot see a same-second rewrite of (`sameSecond`). */
+  sameSecond: string[]
 }
 
 /** What the blob-size check reads, lazily: the verdict's key, and the listing a miss needs. */
@@ -1010,6 +1042,31 @@ export interface IndexBlobCheck {
   rekey(): Promise<string | undefined>
 }
 
+/** At most `n` contiguous parts of `items`, none under `CAT_FILE_MIN`: a spawn costs more than a few lookups. */
+function chunks<T>(items: readonly T[], n: number): T[][] {
+  const parts = Math.min(n, Math.ceil(items.length / CAT_FILE_MIN))
+  const size = Math.ceil(items.length / Math.max(1, parts))
+  const out: T[][] = []
+  for (let at = 0; at < items.length; at += size) out.push(items.slice(at, at + size))
+  return out
+}
+const CAT_FILE_MIN = 256
+
+const sizeChecks = new WeakMap<GitEnumeration, Promise<void>>()
+/**
+ * `dropResizedOids` once per enumeration: a run starts it as soon as its
+ * cache opens, so the check runs beside the config load and graph build
+ * instead of after them, and `applyGitEnumeration` waits on the same one.
+ */
+export function checkBlobSizes(enumeration: GitEnumeration, memo?: BlobSizeMemo): Promise<void> {
+  let check = sizeChecks.get(enumeration)
+  if (check === undefined) {
+    check = dropResizedOids(enumeration, memo)
+    sizeChecks.set(enumeration, check)
+  }
+  return check
+}
+
 /**
  * Drop each trusted OID whose blob is not the size the index recorded for
  * the worktree file (A-60). A clean filter's blob differs from the file it
@@ -1026,6 +1083,8 @@ export interface IndexBlobCheck {
  * (racy) entry records 0 and is hashed from disk. An answer that cannot be
  * read trusts nothing. A filter that keeps the size (`tr a-z A-Z`) is not
  * caught: only a read of every trusted file would be (caching.md, step 12).
+ * The verdict also holds each entry git cannot see a same-second rewrite
+ * of (`sameSecond`), read from the same listing.
  */
 async function dropResizedOids(enumeration: GitEnumeration, memo?: BlobSizeMemo): Promise<void> {
   const { trusted, blobCheck } = enumeration
@@ -1033,31 +1092,47 @@ async function dropResizedOids(enumeration: GitEnumeration, memo?: BlobSizeMemo)
   const key = blobCheck.key
   let resized = key === undefined ? undefined : memo?.blobVerdict(key)
   if (resized === undefined) {
-    const blobs = await blobCheck.blobs()
+    // The sizes are asked beside the listing: both read the index the
+    // enumeration listed (the listing refuses one written since), so the
+    // OIDs are the listing's. One after the other, a cold 9,603-task run
+    // waited on the listing's 70-95 ms before the first spawn (2026-11-01).
+    const listing = blobCheck.blobs()
+    // Only what is still trusted: a path dropped already needs no size.
+    // Built here, not with the listing: a run whose verdict is memoized
+    // never needs it, and on 9,603 tasks it cost 17-35 ms (2026-11-01).
+    // A non-regular mode rides its value (`100755:<oid>`); cat-file takes the OID.
+    const oids = [...new Set(Array.from(trusted.values(), (v) => v.slice(v.lastIndexOf(':') + 1)))]
+    const sizes = memo?.knownBlobSizes(oids) ?? new Map<string, number>()
+    const unknown = oids.filter((oid) => !sizes.has(oid))
+    // One cat-file per core: a fresh clone's objects are loose, and one
+    // process opened and inflated 2,505 of them in 30 ms before the first
+    // task of a cold 100-package run; four took 14 (2026-11-03).
+    const asked = Promise.all(
+      chunks(unknown, Math.max(1, navigator.hardwareConcurrency)).map((part) =>
+        enumeration.catFile(part.join('\n') + '\n'),
+      ),
+    )
+    const [blobs, runs] = await Promise.all([listing, asked])
     if (blobs === null) {
       trusted.clear()
       return
     }
-    const unique = [...new Set(blobs.oids)]
-    const sizes = memo?.knownBlobSizes(unique) ?? new Map<string, number>()
-    const unknown = unique.filter((oid) => !sizes.has(oid))
-    if (unknown.length > 0) {
-      const run = await enumeration.catFile(unknown.join('\n') + '\n')
-      if (run === null || run.exitCode !== 0) {
-        trusted.clear()
-        return
-      }
-      const learned = new Map<string, number>()
-      for (const line of run.stdout.split('\n')) {
+    if (runs.some((run) => run === null || run.exitCode !== 0)) {
+      trusted.clear()
+      return
+    }
+    const learned = new Map<string, number>()
+    for (const run of runs) {
+      for (const line of run!.stdout.split('\n')) {
         const sp = line.indexOf(' ')
         const n = Number(line.slice(sp + 1))
         if (sp > 0 && line.slice(sp + 1) !== '' && Number.isInteger(n))
           learned.set(line.slice(0, sp), n)
       }
-      for (const [oid, n] of learned) sizes.set(oid, n)
-      memo?.rememberBlobSizes(learned)
     }
-    resized = []
+    for (const [oid, n] of learned) sizes.set(oid, n)
+    if (learned.size > 0) memo?.rememberBlobSizes(learned)
+    resized = [...blobs.sameSecond]
     for (let i = 0; i < blobs.oids.length; i++) {
       const size = sizes.get(blobs.oids[i]!)
       // The index keeps the low 32 bits of a size.
@@ -1626,6 +1701,19 @@ function hasRacyEntry(index: Uint8Array, mtimeSec: number, oidBytes: number): bo
   return false
 }
 
+/**
+ * git compares a file's ctime to the second only, and its racy rule reads
+ * mtime alone: a same-size rewrite that keeps (or restores) an older mtime,
+ * made in the second the index recorded the file, keeps every stat git
+ * compares, and `status` calls it clean. An entry whose recorded ctime, not
+ * its mtime, reaches the second its index was written can hide one; git
+ * re-hashes an entry racy by mtime. Its OID is not trusted. The stamps are
+ * git's own (`ls-files --debug`), judged once per index (the verdict).
+ */
+function sameSecond(ctimeSec: number, mtimeSec: number, writtenSec: number): boolean {
+  return ctimeSec < 0 || (ctimeSec >= writtenSec && mtimeSec < writtenSec)
+}
+
 /** A private copy a run older than this may still have handed to `status`. */
 const STALE_INDEX_MS = 60_000
 
@@ -1711,7 +1799,7 @@ export async function startGitEnumeration(
     stdin?: string,
     env?: Record<string, string>,
   ): Promise<GitRun | null> => {
-    const spawn = <Out extends 'pipe' | Bun.BunFile>(stdout: Out) =>
+    const spawn = <Out extends 'pipe' | number>(stdout: Out) =>
       Bun.spawn({
         // `status` refreshes the index when it can take `index.lock`, so
         // the user's own `git add` or `commit` failed on the lock while a
@@ -1728,23 +1816,30 @@ export async function startGitEnumeration(
     // loading configs while git lists, and a pipe held a 10 MB listing
     // until the thread came back to drain it 64 KiB at a time (~90 ms of
     // a warm 5,000-project run). In a directory of its own, so no link
-    // another user planted in a shared temp directory takes the bytes. A
-    // temp directory that takes none falls back to the pipe.
-    let dir: string | undefined
+    // another user planted in a shared temp directory takes the bytes, and
+    // the directory goes the moment the file is open: a run stopped
+    // mid-listing (a Ctrl-C before the run's signal handlers, or a kill)
+    // runs no `finally`, and each left a `vx-git-*` behind. A temp
+    // directory that takes none falls back to the pipe.
+    let fd: number | undefined
     try {
-      dir = mkdtempSync(path.join(os.tmpdir(), 'vx-git-'))
+      const dir = mkdtempSync(path.join(os.tmpdir(), 'vx-git-'))
+      try {
+        fd = openSync(path.join(dir, 'out'), 'w+', 0o600)
+      } finally {
+        rmSync(dir, { recursive: true, force: true })
+      }
     } catch {
-      dir = undefined
+      fd = undefined
     }
     try {
       let stdout: Uint8Array
       let stderr: string
       let exitCode: number
-      if (dir !== undefined) {
-        const out = path.join(dir, 'out')
-        const proc = spawn(Bun.file(out))
+      if (fd !== undefined) {
+        const proc = spawn(fd)
         ;[stderr, exitCode] = await Promise.all([new Response(proc.stderr).text(), proc.exited])
-        stdout = await Bun.file(out).bytes()
+        stdout = readWhole(fd)
       } else {
         const piped = spawn('pipe')
         ;[stdout, stderr, exitCode] = await Promise.all([
@@ -1758,7 +1853,7 @@ export async function startGitEnumeration(
     } catch {
       return null
     } finally {
-      if (dir !== undefined) rmSync(dir, { recursive: true, force: true })
+      if (fd !== undefined) closeSync(fd)
     }
   }
   const startedAtMs = Date.now()
@@ -1834,7 +1929,9 @@ export async function startGitEnumeration(
         bytes,
         hash,
         st,
-        key: `${hash}:${pathspecKey}`,
+        // The mtime too: which entries git can see a same-second rewrite
+        // of (`sameSecond`) turns on the second the index was written.
+        key: `${hash}:${pathspecKey}:${Math.floor(st.mtimeMs / 1000)}`,
         stamp: `${st.ino}:${st.ctimeMs}:${st.size}`,
       }
     } catch {
@@ -1863,10 +1960,16 @@ export async function startGitEnumeration(
       index === undefined ? undefined : { GIT_INDEX_FILE: index },
     )
   // An index with no racy entry is read as it is: `status` spawns now.
+  // The copy `status` read, when it read one: its stats are the ones the
+  // dirty set came from, so the blob check lists it too.
+  let statusCopy: string | undefined
   const statusRun =
     read === undefined || indexFile === undefined || !racyIndex(read, facts!.objectFormat)
       ? spawnStatus(undefined)
-      : refreshedIndex(indexFile, read, spawnGit).then(spawnStatus)
+      : refreshedIndex(indexFile, read, spawnGit).then((copy) => {
+          statusCopy = copy
+          return spawnStatus(copy)
+        })
   const running = Promise.all([listing, statusRun, varsRun])
   const gitPrefix = facts?.prefix ?? ''
   const gitDir = facts?.commonDir ?? ''
@@ -1888,6 +1991,17 @@ export async function startGitEnumeration(
   // the stamp moves with any write) and is still in place after it: a
   // `git add` between the listing and the read paired one index's verdict
   // with the other's entries. Otherwise this run asks for no verdict.
+  // A verdict read from the copy holds for that copy file only: a copy
+  // written again (a new inode) asks again.
+  const copyKey = (key: string): string | undefined => {
+    if (statusCopy === undefined) return key
+    try {
+      const st = lstatSync(statusCopy)
+      return `${key}:${st.ino}:${st.mtimeMs}`
+    } catch {
+      return undefined
+    }
+  }
   let indexKey: string | undefined
   if (
     read !== undefined &&
@@ -1895,7 +2009,7 @@ export async function startGitEnumeration(
   ) {
     try {
       const st = lstatSync(indexFile!)
-      if (`${st.ino}:${st.ctimeMs}:${st.size}` === read.stamp) indexKey = read.key
+      if (`${st.ino}:${st.ctimeMs}:${st.size}` === read.stamp) indexKey = copyKey(read.key)
     } catch {
       // gone: no key
     }
@@ -1997,24 +2111,47 @@ export async function startGitEnumeration(
     blobCheck: {
       key: indexKey,
       async blobs() {
-        const run = await spawnGit(['ls-files', '-s', '-v', '-z', '--debug', '--', ...pathspecs])
+        const listed = statusCopy ?? indexFile
+        let writtenSec = 0
+        try {
+          if (listed !== undefined) writtenSec = Math.floor(lstatSync(listed).mtimeMs / 1000)
+        } catch {
+          return null
+        }
+        const run = await spawnGit(
+          ['ls-files', '-s', '-v', '-z', '--debug', '--', ...pathspecs],
+          undefined,
+          statusCopy === undefined ? undefined : { GIT_INDEX_FILE: statusCopy },
+        )
         if (run === null || run.exitCode !== 0) return null
         // Sizes from an index written since the listing judge entries the
         // trusted OIDs did not come from: an add there rewrote a resized
         // entry to one that fits, and the listed OID stood (A-60).
         if (indexStamp() !== stampBefore) return null
         const debug = splitLsDebug(run)
-        const indexed = new Map<string, { oid: string; size: number }>()
-        parseLsFilesOutput(debug.records, debug.undecodable, { sizes: debug.sizes, indexed })
-        const blobs: IndexBlobs = { paths: [], oids: [], sizes: [] }
-        for (const [rel, { oid, size }] of indexed) {
+        const indexed = new Map<
+          string,
+          { oid: string; size: number; ctime: number; mtime: number }
+        >()
+        parseLsFilesOutput(debug.records, debug.undecodable, {
+          sizes: debug.sizes,
+          ctimes: debug.ctimes,
+          mtimes: debug.mtimes,
+          indexed,
+        })
+        const blobs: IndexBlobs = { paths: [], oids: [], sizes: [], sameSecond: [] }
+        for (const [rel, { oid, size, ctime, mtime }] of indexed) {
           blobs.paths.push(rel)
           blobs.oids.push(oid)
           blobs.sizes.push(size)
+          if (sameSecond(ctime, mtime, writtenSec)) blobs.sameSecond.push(rel)
         }
         return blobs
       },
-      rekey: async () => (await readIndex())?.key,
+      rekey: async () => {
+        const key = (await readIndex())?.key
+        return key === undefined ? undefined : copyKey(key)
+      },
     },
     // A missing blob is an answer ("missing"), never a fetch from a partial
     // clone's promisor remote.
@@ -2083,7 +2220,7 @@ export async function applyGitEnumeration(
   workspaceWide = false,
   memo?: BlobSizeMemo,
 ): Promise<void> {
-  await dropResizedOids(enumeration, memo)
+  await checkBlobSizes(enumeration, memo)
   const { all, trusted } = enumeration
   cache.setWorktreeDirty(enumeration.dirty)
   cache.setGitVars(enumeration.vars)
@@ -2218,3 +2355,15 @@ export async function applyGitEnumeration(
     cache.setWorkspaceRoot(workspaceRoot)
   }
 }
+
+/** The whole of a file held only by `fd`, from its start. */
+function readWhole(fd: number): Uint8Array {
+  const bytes = new Uint8Array(fstatSync(fd).size)
+  let at = 0
+  while (at < bytes.length) {
+    const n = readSync(fd, bytes, at, bytes.length - at, at)
+    if (n === 0) break
+    at += n
+  }
+  return at === bytes.length ? bytes : bytes.subarray(0, at)
+}

package/src/cache/index.ts

@@ -81,6 +81,7 @@ export {
   MAX_SCOPED_PATHSPECS,
   repoRootOf,
   startGitEnumeration,
+  checkBlobSizes,
   lazyGitEnumeration,
   type LazyGitEnumeration,
   type GitEnumeration,

package/src/cache/inputs.ts

@@ -101,6 +101,9 @@ const ALWAYS_IGNORE = [
   // must not select every `**` reader under --affected.
   '.vx/.gitattributes',
   '.vx/.gitignore',
+  // `vx lock`'s record of the dependency edges and digests: the key folds
+  // the digests through `fingerprint` already.
+  '.vx/dependencies.lock.json',
   // Where restores stage (archive.ts): vx's own, never an input.
   '.vx/tmp/**',
 ]

package/src/cache/layer.ts

@@ -232,6 +232,15 @@ export interface RunRecord {
   placementMemoryBytes?: number
   /** The share of a core each runnable thread got there (`ExecuteResult.machine.cpuShare`, v49). */
   cpuShare?: number
+  /** How long it waited ready for a slot (`TaskOutcome.queuedMs`, v51). */
+  queuedMs?: number
+  /** Its output files' bytes (`TaskOutcome.outputBytes`, v51). */
+  outputBytes?: number
+  /** The tasks and groups downstream of it in the run, the scheduler's count (v51). */
+  blocks?: number
+  /** The flaky record its row's note quoted (`TaskOutcome.flaky`, v51). */
+  flakyPasses?: number
+  flakyFailures?: number
 }
 
 /**
@@ -823,6 +832,8 @@ export interface CacheLayer {
   outputsPath(hash: string): string
   /** The stored artifact's compressed size, wherever it lives; undefined when none is stored. */
   artifactSize?(hash: string): number | undefined
+  /** The output files' bytes, uncompressed, of the entry this process just saved; asked once. */
+  outputBytes?(hash: string): number | undefined
   prune(options: PruneOptions): Promise<PruneResult>
   close(): void
 }

package/src/cache/layered-cache.ts

@@ -575,6 +575,10 @@ export class LayeredCache implements CacheLayer {
     return this.local.artifactSize(hash)
   }
 
+  outputBytes(hash: string): number | undefined {
+    return this.local.outputBytes(hash)
+  }
+
   hashFile(filePath: string): Promise<string> {
     return this.local.hashFile(filePath)
   }

package/src/cache/linked-inputs.ts

@@ -71,6 +71,9 @@ export async function behindLink(
     return NOTHING_BEHIND
   }
   if (seen.has(real)) return NOTHING_BEHIND
+  // A repository's own store, as a `.git/**` input names nothing: walked,
+  // every commit and index write re-keyed the task. Its target string keys.
+  if (real.split(path.sep).includes('.git')) return NOTHING_BEHIND
   if (st.isFile()) return `file\0${await hashFile(real).catch(absentOr)}`
   if (!st.isDirectory()) return 'special'
   const inner = new Set(seen).add(real)

package/src/cache/lockfile-memo.ts

@@ -21,7 +21,8 @@ export interface LockfileMemo {
   lock: string
   /** Each extra file the digests read → its content hash then. */
   extras: Record<string, string>
-  importers: Record<string, string>
+  /** Each importer's digest; null when the parse that wrote it left them out (a run's). */
+  importers: Record<string, string> | null
   edges: Record<string, unknown>
   /** Each importer's recorded dependency names; absent when the claimant reads none. */
   recorded?: Record<string, readonly string[]>
@@ -77,7 +78,7 @@ export function readLockfileMemo(
       version: row.version,
       lock: row.lock,
       extras: JSON.parse(row.extras) as Record<string, string>,
-      importers: JSON.parse(row.importers) as Record<string, string>,
+      importers: JSON.parse(row.importers) as Record<string, string> | null,
       edges: JSON.parse(row.edges) as Record<string, unknown>,
       ...(row.recorded !== null
         ? { recorded: JSON.parse(row.recorded) as Record<string, readonly string[]> }

package/src/cache/output-index.ts

@@ -143,17 +143,20 @@ export class OutputIndex {
   /**
    * Replace an entry's file rows. Called INSIDE the store's save transaction,
    * so an entry and its fingerprints land together (an UPDATE on the same
-   * hash refreshes rather than appends).
+   * hash refreshes rather than appends). Answers the files' bytes.
    */
-  replaceFileRows(hash: string, rows: ReadonlyArray<[string, number, number, number]>): void {
+  replaceFileRows(hash: string, rows: ReadonlyArray<[string, number, number, number]>): number {
     // A stamp taken for the rows this replaces describes their files, not these.
     this.held.delete(hash)
     this.pendingStamps.delete(hash)
     this.deleteOutputFiles.run(hash)
     this.deleteStamps.run(hash)
+    let bytes = 0
     for (const [rel, size, mode, mtime] of rows) {
       this.insertOutputFile.run(hash, rel, size, mode, mtime)
+      bytes += size
     }
+    return bytes
   }
 
   /** Hold a probe's rows for its restores (`held`), in place of the last probe's. */

package/src/cache/remote-lane.ts

@@ -4,7 +4,8 @@
 // class with the endpoint named. The order across remotes, the local store
 // and provenance are `LayeredCache`'s; nothing here knows another remote.
 
-import { machineParallelism, thrownMessage, ui } from '../util/index.js'
+import { machineParallelism, thrownMessage } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
 import type { ArtifactInfo, RemoteCacheLayer } from './layered-cache.js'
 

package/src/cache/run-history.ts

@@ -41,6 +41,11 @@ const RUN_COLUMNS = [
   'keyless_by',
   'def',
   'cpu_share',
+  'queued_ms',
+  'output_bytes',
+  'blocks',
+  'flaky_passes',
+  'flaky_failures',
 ]
 
 const INSERT_RUNS = `INSERT INTO runs(${RUN_COLUMNS.join(', ')}) VALUES `
@@ -282,7 +287,7 @@ export class RunHistory {
   }
 }
 
-/** Bind a RunRecord to one `RUN_TUPLE`'s 29 positional parameters. */
+/** Bind a RunRecord to one `RUN_TUPLE`'s positional parameters, in `RUN_COLUMNS` order. */
 function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBindings[] {
   return [
     // The ONE place the no-key sentinel is applied, so the column's
@@ -321,6 +326,11 @@ function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBi
     run.keylessBy ?? null,
     run.def ?? null,
     run.cpuShare ?? null,
+    run.queuedMs ?? null,
+    run.outputBytes ?? null,
+    run.blocks ?? null,
+    run.flakyPasses ?? null,
+    run.flakyFailures ?? null,
   ]
 }
 

package/src/cache/schema.ts

@@ -119,7 +119,17 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       def                 TEXT,
       -- v49: the share of a core each runnable thread got where it ran
       -- (ExecuteResult.machine.cpuShare); NULL = all it wanted.
-      cpu_share           REAL
+      cpu_share           REAL,
+      -- v51: the rest of the results row. How long the task waited ready
+      -- for a slot (NULL: it started at once); its output files' bytes,
+      -- uncompressed (a hit's restored, a miss's saved; NULL: no entry);
+      -- the tasks downstream of it in the run; the flaky record its note
+      -- quoted (NULL: not proven flaky).
+      queued_ms           INTEGER,
+      output_bytes        INTEGER,
+      blocks              INTEGER,
+      flaky_passes        INTEGER,
+      flaky_failures      INTEGER
     );
     -- Two whole-table indexes only, and both APPEND: every row of a run carries the
     -- same run_id and a started_at newer than everything before it, so

package/src/cli/cache.ts

@@ -11,8 +11,8 @@ import {
   parseSize,
   relPosix,
   treeBytes,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import { acquireRunLock } from '../orchestrator/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import {
@@ -270,9 +270,7 @@ function printPruned(
 ): void {
   if (json) {
     const { evicted, bytesFreed, orphans, orphanBytes } = result
-    process.stdout.write(
-      `${JSON.stringify({ dry: dry, evicted, bytesFreed, orphans, orphanBytes })}\n`,
-    )
+    ui.data('out', `${JSON.stringify({ dry: dry, evicted, bytesFreed, orphans, orphanBytes })}\n`)
     return
   }
   const plural = (n: number, one: string, many: string): string => `${n} ${n === 1 ? one : many}`
@@ -321,6 +319,25 @@ async function clear(
   storeRoot: string | null,
   parsed: PruneArgs,
 ): Promise<number> {
+  // A clear beside a run deletes what the run is restoring or saving; it
+  // waits for the run's lock, as a trim does, and only then reads what to
+  // delete: read first, what the run saved meanwhile went uncounted.
+  const release =
+    parsed.dry === true ? async () => {} : await acquireRunLock(root, { log: warnToStderr })
+  try {
+    return clearHeld(args, root, dir, storeRoot, parsed)
+  } finally {
+    await release()
+  }
+}
+
+function clearHeld(
+  args: readonly string[],
+  root: string,
+  dir: string,
+  storeRoot: string | null,
+  parsed: PruneArgs,
+): number {
   // The store the index recorded and today's (a changed HOME, an origin
   // added) both go; a directory with no index is not a vx cache to delete.
   const targets: string[] = []
@@ -376,23 +393,16 @@ async function clear(
         ? readdirSync(t).map((e) => path.join(t, e))
         : [t]
   const bytes = doomed.reduce((n, t) => n + entries(t).reduce((m, e) => m + treeBytes(e), 0), 0)
-  if (!dry && doomed.length > 0) {
-    // A clear beside a run deletes what the run is restoring or saving; it
-    // waits for the run's lock, as a trim does.
-    const release = await acquireRunLock(root, { log: warnToStderr })
-    try {
-      for (const t of doomed) {
-        for (const e of entries(t)) rmSync(e, { recursive: true, force: true })
-        if (t === named && readdirSync(t).length === 0) rmSync(t, { recursive: true })
-      }
-    } finally {
-      await release()
+  if (!dry) {
+    for (const t of doomed) {
+      for (const e of entries(t)) rmSync(e, { recursive: true, force: true })
+      if (t === named && readdirSync(t).length === 0) rmSync(t, { recursive: true })
     }
   }
   const shown = doomed.map((t) => (path.relative(root, t).startsWith('..') ? t : relPosix(root, t)))
   if (parsed.format === 'json') {
     const result: ClearResult = { dry: dry, cleared: shown, bytesFreed: bytes }
-    process.stdout.write(`${JSON.stringify(result)}\n`)
+    ui.data('out', `${JSON.stringify(result)}\n`)
   } else
     ui.print(
       'out',