@vzn/vx 0.0.650 → 0.0.652

package/src/cache/inputs.ts

@@ -17,7 +17,15 @@
 // be a git work tree; non-git environments are not supported.
 
 import path from 'node:path'
-import { lstatSync, readdirSync, realpathSync, rmdirSync, rmSync, statSync } from 'node:fs'
+import {
+  type Dirent,
+  lstatSync,
+  readdirSync,
+  realpathSync,
+  rmdirSync,
+  rmSync,
+  statSync,
+} from 'node:fs'
 import { rm, rmdir } from 'node:fs/promises'
 import type { InputsConfig, TaskConfig } from '../config.js'
 import {
@@ -101,6 +109,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/**',
 ]
@@ -834,15 +845,23 @@ export async function resolveOutputTree(args: {
   projectDir: string
   outputs: readonly string[]
   nestedProjectDirs: string[]
-}): Promise<{ files: string[]; emptyDirs: string[] }> {
+  /** Also list the FIFOs, sockets and devices the globs name (a save refuses them). */
+  special?: boolean
+}): Promise<{ files: string[]; emptyDirs: string[]; special: string[] }> {
   const emptyDirs = new Set<string>()
-  const { files } = await scanOutputs(args, emptyDirs)
-  return { files, emptyDirs: containedIn(args.projectDir, [...emptyDirs]).sort() }
+  const special = args.special === true ? new Set<string>() : undefined
+  const { files } = await scanOutputs(args, emptyDirs, special)
+  return {
+    files,
+    emptyDirs: containedIn(args.projectDir, [...emptyDirs]).sort(),
+    special: special === undefined ? [] : containedIn(args.projectDir, [...special]).sort(),
+  }
 }
 
 async function scanOutputs(
   args: { projectDir: string; outputs: readonly string[]; nestedProjectDirs: string[] },
   emptyDirs?: Set<string>,
+  special?: Set<string>,
 ): Promise<{ files: string[] }> {
   const { positive, negative } = splitNegations(args.outputs)
   if (positive.length === 0) return { files: [] }
@@ -856,6 +875,7 @@ async function scanOutputs(
       args.projectDir,
       inNestedProject(args.projectDir, args.nestedProjectDirs),
       emptyDirs,
+      special,
     )),
   ]
   // Containment, enforced HERE and not only at the loader. `cleanOutputs`
@@ -1255,7 +1275,7 @@ export async function stampOutputs(args: {
   return stampFiles(await resolveOutputs(args))
 }
 
-/** `stampOutputs` for root-anchored `cache.outputs.workspaceFiles` (A-43). */
+/** `stampOutputs` for root-anchored `outputs.workspaceFiles` (A-43). */
 export async function stampWorkspaceOutputs(args: {
   workspaceRoot: string
   outputs: readonly string[]
@@ -1295,7 +1315,7 @@ export async function ownOutputsSince(
   return changedSince(await resolveOutputs(args), before)
 }
 
-/** `ownOutputsSince` for root-anchored `cache.outputs.workspaceFiles` (A-43). */
+/** `ownOutputsSince` for root-anchored `outputs.workspaceFiles` (A-43). */
 export async function ownWorkspaceOutputsSince(
   args: { workspaceRoot: string; outputs: readonly string[] },
   before: ReadonlyMap<string, OutputStamp>,
@@ -1524,6 +1544,7 @@ export async function resolveWorkspaceOutputs(
     outputs: readonly string[]
   },
   emptyDirs?: Set<string>,
+  special?: Set<string>,
 ): Promise<string[]> {
   const { positive, negative } = splitNegations(args.outputs)
   if (positive.length === 0) return []
@@ -1531,7 +1552,7 @@ export async function resolveWorkspaceOutputs(
   const trees = asTrees(positive)
   refuseDirLinkedOut(args.workspaceRoot, trees, 'workspace')
   const scanned = [
-    ...(await scanUnion(trees, excludeGlobs, args.workspaceRoot, undefined, emptyDirs)),
+    ...(await scanUnion(trees, excludeGlobs, args.workspaceRoot, undefined, emptyDirs, special)),
   ]
   // Same containment as the project twin, anchored one level out. These globs
   // deliberately ignore PROJECT boundaries — that is the escape hatch — but
@@ -1544,10 +1565,17 @@ export async function resolveWorkspaceOutputs(
 export async function resolveWorkspaceOutputTree(args: {
   workspaceRoot: string
   outputs: readonly string[]
-}): Promise<{ files: string[]; emptyDirs: string[] }> {
+  /** As `resolveOutputTree`'s. */
+  special?: boolean
+}): Promise<{ files: string[]; emptyDirs: string[]; special: string[] }> {
   const emptyDirs = new Set<string>()
-  const files = await resolveWorkspaceOutputs(args, emptyDirs)
-  return { files, emptyDirs: containedIn(args.workspaceRoot, [...emptyDirs]).sort() }
+  const special = args.special === true ? new Set<string>() : undefined
+  const files = await resolveWorkspaceOutputs(args, emptyDirs, special)
+  return {
+    files,
+    emptyDirs: containedIn(args.workspaceRoot, [...emptyDirs]).sort(),
+    special: special === undefined ? [] : containedIn(args.workspaceRoot, [...special]).sort(),
+  }
 }
 
 /**
@@ -1962,7 +1990,7 @@ export function declaresInput(
     // A changed path under the task's own outputs is a committed file
     // (`git diff` lists only what git tracks) or a stray `git status`
     // lists: either way it may be an input, so it counts.
-    const plan = filesPlan(inputs.files, task.cache?.outputs.files ?? [])
+    const plan = filesPlan(inputs.files, task.outputs?.files ?? [])
     if (plan !== null && (inPlan(plan, projectRel) || ownOnly(plan, projectRel))) return true
     if (plan !== null && dirLink && plan.mayHold(projectRel) && !plan.isExcluded(projectRel)) {
       return true
@@ -1992,8 +2020,7 @@ export function workspaceFilesReachInto(task: TaskConfig, dir: string): boolean
  */
 export function namedOutright(task: TaskConfig): { files: string[]; workspaceFiles: string[] } {
   const inputs = task.inputs
-  const plan =
-    inputs === undefined ? null : filesPlan(inputs.files, task.cache?.outputs.files ?? [])
+  const plan = inputs === undefined ? null : filesPlan(inputs.files, task.outputs?.files ?? [])
   const ws = inputs?.workspaceFiles ?? []
   return {
     files: plan === null ? [] : outright(plan),
@@ -2239,7 +2266,7 @@ function listingFor(
 function refuseUndecodableOutput(abs: string): void {
   if (!undecodableOnDisk(abs)) return
   throw new UserError(
-    `cache.outputs matched ${JSON.stringify(abs)}: the name is not valid UTF-8 (shown with ` +
+    `outputs matched ${JSON.stringify(abs)}: the name is not valid UTF-8 (shown with ` +
       `\ufffd), and vx cannot save a file by it. Rename it, or keep it out of the outputs.`,
   )
 }
@@ -2453,13 +2480,19 @@ async function scanUnion(
   cwd: string,
   nested: (rel: string) => boolean = () => false,
   emptyDirs?: Set<string>,
+  special?: Set<string>,
 ): Promise<Set<string>> {
   const matches = new Set<string>()
   const links: string[] = []
+  // Directories the walk entered: Bun's scan skips a FIFO, socket or
+  // device outright, so `special` is found by listing them.
+  const walked = special === undefined ? undefined : new Set<string>()
   const take = (rel: string): void => {
     if (nested(rel) || excludeGlobs.some((g) => g.match(rel))) return
     const abs = path.resolve(cwd, rel)
+    walked?.add(path.dirname(abs))
     const st = lstatSync(abs, { throwIfNoEntry: false })
+    if (walked !== undefined && st?.isDirectory() === true) walked.add(abs)
     if (st !== undefined && (st.isFile() || st.isSymbolicLink())) {
       matches.add(abs)
       if (st.isSymbolicLink()) links.push(abs)
@@ -2484,17 +2517,22 @@ async function scanUnion(
   ) {
     const any = anyTaskGlob(patterns)
     for (const rel of WHOLE_TREE.scanSync(opts)) if (any(rel)) take(rel)
+    if (special !== undefined) findSpecial(walked!, cwd, any, excludeGlobs, nested, special)
     return matches
   }
   for (const pattern of patterns) {
     if (absentPrefix(cwd, pattern)) continue
     const from = scanRoot(cwd, pattern)
     if (from === null) continue
+    walked?.add(from === undefined ? cwd : from.dir)
     if (from === undefined) for (const rel of globFor(pattern).scanSync(opts)) take(rel)
     else
       for (const rel of globFor(from.rest).scanSync({ ...opts, cwd: from.dir }))
         take(`${from.prefix}/${rel}`)
   }
+  if (special !== undefined) {
+    findSpecial(walked!, cwd, anyTaskGlob(patterns), excludeGlobs, nested, special)
+  }
   // A literal names the path and its tree (`dist`, `dist/**`), and a tree
   // whose head is a directory link is walked through it: the link and the
   // files under it were one artifact holding `dist` as a file and a
@@ -2510,6 +2548,31 @@ async function scanUnion(
   return matches
 }
 
+/** The FIFOs, sockets and devices in `dirs` that the output globs name. */
+function findSpecial(
+  dirs: ReadonlySet<string>,
+  cwd: string,
+  any: (rel: string) => boolean,
+  excludeGlobs: readonly Bun.Glob[],
+  nested: (rel: string) => boolean,
+  into: Set<string>,
+): void {
+  for (const dir of dirs) {
+    let entries: Dirent[]
+    try {
+      entries = readdirSync(dir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const e of entries) {
+      if (e.isFile() || e.isDirectory() || e.isSymbolicLink()) continue
+      const abs = path.join(dir, e.name)
+      const rel = path.relative(cwd, abs).split(path.sep).join('/')
+      if (any(rel) && !nested(rel) && !excludeGlobs.some((g) => g.match(rel))) into.add(abs)
+    }
+  }
+}
+
 /** `pattern`'s static directory passes through a symlink under `cwd`. */
 function headLinked(cwd: string, pattern: string): boolean {
   const prefix = staticPrefix(pattern)

package/src/cache/layer.ts

@@ -199,7 +199,7 @@ export interface RunRecord {
   restored?: boolean
   attempts?: number // >1 when the task retried; the direct within-run flaky signal
   /**
-   * Whether the task declared a `cache` block. An uncached task executes
+   * Whether the task declared `cache: true`. An uncached task executes
    * on every run and its key exists only for dependents to fold, so a
    * reader (`vx why`, `vx last`) must not present its re-run as a cache
    * decision. Absent on rows written before the column existed.
@@ -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
 }
 
 /**
@@ -349,7 +358,7 @@ export interface PruneResult {
 
 /**
  * Artifact + `output_files` namespace prefix for workspace-root-
- * anchored outputs (`cache.outputs.workspaceFiles`). Project outputs
+ * anchored outputs (`outputs.workspaceFiles`). Project outputs
  * keep their bare project-relative `path` rows; workspace rows store
  * the full `workspace-outputs/<rel-to-root>` tar entry name as the
  * discriminator — least-invasive row format, no schema change. A
@@ -458,7 +467,7 @@ export interface CacheGetContext {
   taskId: string
   command: string
   /**
-   * The task's declared `cache.outputs`. A remote artifact is ingested
+   * The task's declared `outputs`. A remote artifact is ingested
    * only when every file it carries is one of them: bytes off the network
    * named `outputs/src/in.txt` or `workspace-outputs/.git/hooks/…` wrote
    * an input and a git hook on a green `cache-hit-remote` (item 942).
@@ -795,9 +804,9 @@ export interface CacheLayer {
    */
   ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void>
   /**
-   * The ONE run-history write: a whole `vx run` atomically, the per-task
-   * `runs` rows and the one `invocations` header row — in a SINGLE
-   * transaction (one fsync). Input-fingerprint rows are NOT written here — they
+   * The run-history write at a run's end, atomically: the per-task `runs`
+   * rows (less the hits a `HistoryStream` already wrote) and the one
+   * `invocations` header row — in a SINGLE transaction (one fsync). Input-fingerprint rows are NOT written here — they
    * ride the entry-save transaction (`save`/`ingest`) so a warm
    * all-cache-hit run writes nothing.
    */
@@ -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

@@ -11,7 +11,8 @@
 import { Database } from 'bun:sqlite'
 import { existsSync } from 'node:fs'
 import path from 'node:path'
-import { closeDb, SCHEMA_VERSION, SQLITE_FCNTL_PERSIST_WAL } from './cache.js'
+import { closeDb, SCHEMA_VERSION } from './cache.js'
+import { SQLITE_FCNTL_PERSIST_WAL } from './schema.js'
 
 /** One claimant's parse of one lockfile's content. */
 export interface LockfileMemo {
@@ -21,7 +22,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 +79,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,23 +41,29 @@ 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 `
-const RUN_TUPLE = `(${RUN_COLUMNS.map(() => '?').join(', ')})`
-
-/** An INSERT of `n` `runs` rows. */
-function insertRunsSql(n: number): string {
-  return INSERT_RUNS + Array(n).fill(RUN_TUPLE).join(', ')
+/**
+ * An INSERT of `n` `runs` rows over the columns `kept` names (indexes into
+ * `RUN_COLUMNS`); a column it leaves out is NULL, as no `runs` column has
+ * a default.
+ */
+function insertRunsSql(kept: readonly number[], n: number): string {
+  const tuple = `(${kept.map(() => '?').join(', ')})`
+  return `INSERT INTO runs(${kept.map((i) => RUN_COLUMNS[i]).join(', ')}) VALUES ${Array(n).fill(tuple).join(', ')}`
 }
 
 /**
- * Rows per INSERT: as many as stay within 999 bound variables, the oldest
- * default ceiling, read off the column count (33 rows were sized for 30
- * columns and bound 1,023 at 31). A statement per row was 8.7 ms of 1,000
- * rows, 40 at a time 6.4 (2026-10-03).
+ * Bound variables per INSERT: within 999, the oldest default ceiling. A
+ * statement per row was 8.7 ms of 1,000 rows, 40 at a time 6.4
+ * (2026-10-03).
  */
-const RUNS_PER_INSERT = Math.floor(999 / RUN_COLUMNS.length)
+const VARIABLES_PER_INSERT = 999
 
 /** Rows per `task_durations` INSERT: 7 variables each, under 999. */
 const DURATIONS_PER_INSERT = 140
@@ -147,6 +153,21 @@ export class RunHistory {
       .immediate()
   }
 
+  /**
+   * Hits written while the run goes on (history-stream.ts): their rows and
+   * the flaky record's first hit of a key. A hit times nothing, so it
+   * leaves no `task_durations` row; IMMEDIATE, as `recordRunBundle` says.
+   */
+  recordHits(runs: readonly RunRecord[]): void {
+    if (runs.length === 0) return
+    this.db
+      .transaction(() => {
+        this.insertRuns(runs)
+        this.insertOutcomes(runs)
+      })
+      .immediate()
+  }
+
   /** One `task_durations` row per executed success, as if run alone: what a forecast reads. */
   private insertDurations(runs: readonly RunRecord[], source: string, sha: string | null): void {
     const done = runs.filter(
@@ -204,7 +225,13 @@ export class RunHistory {
     }
   }
 
-  /** `runs` as few INSERTs; each distinct forward-args list digested once. */
+  /**
+   * `runs` as few INSERTs; each distinct forward-args list digested once.
+   * Only the columns some row fills are bound: a hit leaves half of them
+   * NULL, and binding 18 of 36 took the 8,002 rows of a warm run from
+   * 31.7 to 24.0 ms alone, the whole record stage 86.8 to 83.3 ms (median
+   * of 15 interleaved runs, 2026-11-06).
+   */
   private insertRuns(runs: readonly RunRecord[]): void {
     const digests = new Map<string, string>()
     const digest = (value: string): string => {
@@ -212,12 +239,19 @@ export class RunHistory {
       if (d === undefined) digests.set(value, (d = this.digestValue(value)))
       return d
     }
-    for (let i = 0; i < runs.length; i += RUNS_PER_INSERT) {
-      const block = runs.slice(i, i + RUNS_PER_INSERT)
+    const bound = runs.map((r) => bindRun(r, digest))
+    const filled = RUN_COLUMNS.map(() => false)
+    for (const row of bound)
+      for (let c = 0; c < row.length; c++) if (row[c] !== null) filled[c] = true
+    const kept: number[] = []
+    for (let c = 0; c < filled.length; c++) if (filled[c]) kept.push(c)
+    const perInsert = Math.floor(VARIABLES_PER_INSERT / kept.length)
+    for (let i = 0; i < bound.length; i += perInsert) {
+      const block = bound.slice(i, i + perInsert)
       const params: SQLQueryBindings[] = []
-      for (const r of block) for (const v of bindRun(r, digest)) params.push(v)
+      for (const row of block) for (const c of kept) params.push(row[c] as SQLQueryBindings)
       // `query` caches by text: one statement for every full block.
-      this.db.query(insertRunsSql(block.length)).run(...params)
+      this.db.query(insertRunsSql(kept, block.length)).run(...params)
     }
   }
 
@@ -282,7 +316,7 @@ export class RunHistory {
   }
 }
 
-/** Bind a RunRecord to one `RUN_TUPLE`'s 29 positional parameters. */
+/** A RunRecord as one value per `RUN_COLUMNS` entry, in its 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 +355,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

@@ -6,6 +6,9 @@
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
 
+/** SQLite's file-control opcode (sqlite3.h). */
+export const SQLITE_FCNTL_PERSIST_WAL = 10
+
 /**
  * A statement prepared on its first `run` or `get`. A warm run executes few
  * of the index's statements, and preparing every one at the open cost each
@@ -84,7 +87,7 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       -- v23: attempts a retried task took (>1); NULL for a once-run task.
       -- The direct within-run flaky signal.
       attempts            INTEGER,
-      -- v25: 1 when the task declared a cache block, 0 when it runs every
+      -- v25: 1 when the task declared cache: true, 0 when it runs every
       -- time by design; NULL on rows older than the column.
       cached              INTEGER,
       -- v27: why a task failed or was skipped, as the run's own footer
@@ -119,7 +122,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 {
@@ -105,7 +105,7 @@ interface PruneArgs {
   format?: 'pretty' | 'json'
   /** `--cache-dir`: prune the cache a run with the same flag uses. */
   cacheDir?: string
-  /** `--global`: clear every repository's store under `~/.vx`. */
+  /** `--global`: clear every workspace's store under `~/.vx`. */
   global?: boolean
   error?: string
 }
@@ -181,7 +181,7 @@ export function parsePruneArgs(args: readonly string[]): PruneArgs {
   }
   if (out.global === true && (out.olderThanMs !== undefined || out.maxBytes !== undefined)) {
     return {
-      error: `--global clears every repository's store and takes no --older-than or --max-size${seeHelp('cache')}`,
+      error: `--global clears every workspace's store and takes no --older-than or --max-size${seeHelp('cache')}`,
     }
   }
   if (out.global === true && out.cacheDir !== undefined) {
@@ -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',

package/src/cli/completions.ts

@@ -6,7 +6,9 @@
 // Tab is the wrong price).
 
 import { acceptedFlags, CORE_VERBS, flagHint, refuse, seeHelp } from './help.js'
-import { nearest, sayNotice } from '../util/index.js'
+import { nearest } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import { setting } from '../settings.js'
 
 function enumValues(path: string): readonly string[] {
@@ -167,6 +169,6 @@ export async function completionsCmd(
   const verbs = [...CORE_VERBS.filter((v) => v !== 'help' && v !== 'version'), 'help', 'version']
   // No overlap to skip: the workspace load refuses a plugin verb named like a core one.
   verbs.push(...pluginVerbs)
-  process.stdout.write(completionScript(shell as CompletionShell, verbs))
+  ui.data('out', completionScript(shell as CompletionShell, verbs))
   return 0
 }