@vzn/vx 0.0.649 → 0.0.651

package/src/orchestrator/prepare.ts

@@ -20,6 +20,7 @@ import {
   UserError,
 } from '../util/index.js'
 import {
+  indexDb,
   Cache,
   type CacheLayer,
   applyCacheFlags,
@@ -38,6 +39,7 @@ import {
   gitPathspecs,
   MAX_SCOPED_PATHSPECS,
   startGitEnumeration,
+  checkBlobSizes,
   lazyGitEnumeration,
   measureFsClockLag,
   DEFAULT_STORE,
@@ -51,6 +53,7 @@ import {
   lockDigest,
   PROJECT_CONFIG_FILENAMES,
   readClaimedFiles,
+  readDependenciesLock,
   resolveCacheDir,
   resolveStoreRoot,
   type ProjectEntry,
@@ -75,6 +78,7 @@ import {
   teardownPlugins,
   type ScheduleRun,
 } from './plugin-host.js'
+import { lockedFiles } from './locked-digests.js'
 import {
   discoverProjects,
   gitOfDiscovery,
@@ -381,6 +385,16 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   const fingerprintsAt = Date.now()
   const claimed = [...fingerprintClaims(plugins).keys()]
   const claimedBytes = await readClaimedFiles(workspaceRoot, claimed, reads)
+  // What `vx lock` recorded of them: a run keys from it (locked-digests.ts).
+  const dependenciesLock = claimed.length > 0 ? readDependenciesLock(workspaceRoot, reads) : null
+  dependenciesLock?.catch(() => {})
+  // A whole-tree run's blob-size check starts with the cache it reads its
+  // verdict from, beside the config load and graph build: after them, a cold
+  // 100-package run waited 40-50 ms on it before its first task (2026-11-03).
+  if (git.started !== undefined) {
+    localCache.holdBlobSizes()
+    git.started.then((e) => checkBlobSizes(e, localCache)).catch(() => {})
+  }
   mark('open cache')
 
   // Configs load FROM .vx/projects.lock.json with no evaluation and no check of
@@ -775,6 +789,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     // 1,000 projects when it ran before the spawn.
     const settleIgnored = askIgnoredOutputs(gatedOutputs(nodes, workspaceRoot), workspaceRoot)
     const enumeration = await enumerating
+    localCache.holdBlobSizes()
     await applyGitEnumeration(
       enumeration,
       workspaceRoot,
@@ -799,7 +814,8 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       }
     }
     if (hasHook(plugins, 'key')) {
-      await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: warnOf(log) })
+      const locked = lockedFiles(workspaceRoot, claimed, claimedBytes, await dependenciesLock)
+      await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: warnOf(log), locked })
     }
     refuseFiltersThroughGroups(nodes)
     const exclude = options.excludeDependencies
@@ -834,7 +850,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       let own = pluginCaches.get(plugin)
       if (own === undefined) {
         own = pluginCache(plugin, {
-          db: localCache.dbHandle(),
+          db: indexDb(localCache),
           policy,
           remotes,
           scope: cacheScope,

package/src/orchestrator/projects.ts

@@ -370,8 +370,11 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
         }
         continue
       }
-      const config: ProjectConfig =
+      const frozen: ProjectConfig =
         meta.configPath === null ? { tasks: {} } : (loaded[next++] as ProjectConfig)
+      // The lock shares a task two projects declare alike: an edit in place
+      // works on this project's own copy.
+      const config = projectStage ? structuredClone(frozen) : frozen
       if (projectStage) {
         // The `project` stage edits the validated object in place; core
         // re-validates after EACH plugin so a plugin can only produce what

package/src/orchestrator/run-context.ts

@@ -30,7 +30,7 @@ import type { RunContextRecord } from './telemetry.js'
 export interface GitContext {
   /** `git rev-parse HEAD`, or null outside a repo / on failure. */
   commitSha: string | null
-  /** `git rev-parse --abbrev-ref HEAD`, or null. */
+  /** The branch HEAD names (`refs/heads/` stripped), with or without a commit; null when detached. */
   branch: string | null
   /** True if `git status --porcelain` was non-empty; null on failure. */
   dirty: boolean | null
@@ -61,9 +61,11 @@ export interface HostContext {
 
 /**
  * One short `git` spawn per run (not per task), behind try/catch.
- * `git rev-parse HEAD --abbrev-ref HEAD` returns the commit on line 1
- * and the branch on line 2 in a SINGLE invocation — half the spawns of
- * two separate `rev-parse` calls. `dirty` is NOT probed here: the run's
+ * `git rev-parse HEAD --symbolic-full-name HEAD` returns the commit on
+ * line 1 and the ref on line 2 in a SINGLE invocation — half the spawns
+ * of two separate `rev-parse` calls. The full name, not `--abbrev-ref`:
+ * a tag named like the branch made that answer `heads/main`
+ * (vercel/turborepo#13882). `dirty` is NOT probed here: the run's
  * `GitFilesCache` populate already ran `git status --porcelain` for
  * input enumeration, so the orchestrator passes that aggregate in
  * (`dirty`) rather than paying for a second status spawn. Pass
@@ -95,7 +97,7 @@ export function captureGitContext(
         workspaceRoot,
         'rev-parse',
         'HEAD',
-        '--abbrev-ref',
+        '--symbolic-full-name',
         'HEAD',
       ],
       env: gitEnv(),
@@ -107,15 +109,19 @@ export function captureGitContext(
       const sha = lines[0]?.trim()
       const br = lines[1]?.trim()
       if (sha) commitSha = sha
-      // `--abbrev-ref HEAD` answers the literal string `HEAD` when nothing is
-      // checked out. Recording that verbatim INVENTS a branch: every detached
+      // A detached HEAD answers the literal string `HEAD`, never `refs/heads/…`.
+      // Recording that verbatim INVENTS a branch: every detached
       // run shares a pseudo-branch "HEAD", which is how `actions/checkout`
       // leaves a pull_request build. The trust boundary (`branch ===
       // defaultBranch`) means it is at least never mistaken for trunk, but
       // every PR collapses into one scope — so one PR's timings feed another's
       // baseline, cross-branch regression detection counts them as a single
       // branch, and a consumer grouping runs by branch reads "HEAD".
-      if (br && br !== 'HEAD') branch = br
+      if (br?.startsWith('refs/heads/')) branch = br.slice('refs/heads/'.length)
+    } else {
+      // No commit yet: `rev-parse HEAD` fails, yet HEAD already names the
+      // branch the first commit lands on (`git branch --show-current`).
+      branch = unbornBranch(workspaceRoot)
     }
   } catch {
     // git unavailable / non-repo: both fields stay null.
@@ -129,6 +135,18 @@ export function captureGitContext(
   return { commitSha, branch, dirty }
 }
 
+/** The branch HEAD names, asked of git only after `rev-parse HEAD` failed. */
+function unbornBranch(workspaceRoot: string): string | null {
+  const proc = Bun.spawnSync({
+    cmd: [executablePath('git'), '-C', workspaceRoot, 'symbolic-ref', '--quiet', 'HEAD'],
+    env: gitEnv(),
+    stdout: 'pipe',
+    stderr: 'ignore',
+  })
+  const ref = proc.exitCode === 0 ? new TextDecoder().decode(proc.stdout).trim() : ''
+  return ref.startsWith('refs/heads/') ? ref.slice('refs/heads/'.length) : null
+}
+
 /**
  * `HEAD`'s commit and branch from the `.git` files, or null when anything
  * about the layout is unfamiliar (the caller then spawns git). Handles a
@@ -138,7 +156,7 @@ export function captureGitContext(
  */
 function readHeadDirect(
   workspaceRoot: string,
-): { commitSha: string; branch: string | null } | null {
+): { commitSha: string | null; branch: string | null } | null {
   try {
     const dirs = refDirsOf(workspaceRoot)
     if (dirs === null) return null
@@ -166,7 +184,8 @@ function readHeadDirect(
         }
       }
     }
-    return null
+    // Neither a loose nor a packed ref: the branch has no commit yet.
+    return { commitSha: null, branch }
   } catch {
     return null
   }

package/src/orchestrator/run-failures.ts

@@ -1,19 +1,14 @@
 // A failed run's task output and the files it names, so an agent reads why
-// a task failed without the terminal (`vx last --format json`). One file per failed run, `<cacheDir>/failures/<runId>.json`,
-// the newest 50 kept: files, not cache.db, so the index layout (and every
-// shared store under it) stays as it was.
+// a task failed without the terminal (`vx last --format json`). Rows of
+// cache.db's `failures` (cache/run-notes.ts), the newest 50 failed runs kept.
 
 import type { Database } from 'bun:sqlite'
-import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
+import { indexDb, type Cache, keepRunNotes, keptFailures } from '../cache/index.js'
 import { isGroupTask, type TaskOutcome } from '../graph/index.js'
 import { decodeOutputLog } from './output-log.js'
 import { PASS_STATUSES } from '../history/index.js'
-import { isFsRefusal, maskedLine, splitTaskId } from '../util/index.js'
-import { fileLocations, fileMemo, type OutputLocation } from '../report/index.js'
-
-/** Failed runs whose output is kept; run ids are UUIDv7, so names sort by age. */
-const KEPT = 50
+import { maskedLine, splitTaskId } from '../util/index.js'
+import { fileLocations, fileMemo, type OutputLocation } from '../ui/index.js'
 
 /** A failed task of a run and what it said. */
 export interface TaskFailure {
@@ -36,17 +31,19 @@ export interface RunFailures {
   tasks: TaskFailure[]
 }
 
-interface StoredFailure extends TaskFailure {
-  project: string
-  task: string
-}
-
-const dirOf = (cacheDir: string): string => path.join(cacheDir, 'failures')
-
-/** Each failed outcome's output as plain text and the files it names. */
-function failuresOf(outcomes: readonly TaskOutcome[]): StoredFailure[] {
+/**
+ * Keep the run's failures, when any outcome carries output. A refused write
+ * (a full disk) costs only this output: `warn` says so and the run's
+ * verdict stands.
+ */
+export function writeRunFailures(
+  cache: Cache,
+  runId: string,
+  outcomes: readonly TaskOutcome[],
+  warn: (message: string) => void,
+): void {
   const isFile = fileMemo()
-  const out: StoredFailure[] = []
+  const failures = []
   for (const o of outcomes) {
     // A task failed by a moved input may have printed nothing: the input
     // is still why, and an agent reads it here.
@@ -60,76 +57,30 @@ function failuresOf(outcomes: readonly TaskOutcome[]): StoredFailure[] {
               .map((c) => c.text)
               .join(''),
           )
-    out.push({
+    failures.push({
       taskId: o.node.id,
-      project: o.node.projectName,
-      task: o.node.taskName,
-      exitCode: o.exitCode,
-      ...(o.timedOut === true ? { timedOut: true as const } : {}),
       ...(o.inputMoved !== undefined ? { inputMoved: o.inputMoved } : {}),
       output,
       locations: fileLocations(output, o.node.projectDir, isFile),
       ...(o.sandboxFix !== undefined ? { sandboxFix: o.sandboxFix } : {}),
     })
   }
-  return out
-}
-
-/**
- * Write the run's failures, when any outcome carries output, and drop all
- * but the newest `KEPT` files. Atomic: a reader sees the whole file or none.
- * A refused write (a full disk, a read-only cache dir) costs only this
- * output: `warn` says so and the run's verdict stands.
- */
-export function writeRunFailures(
-  cacheDir: string,
-  runId: string,
-  outcomes: readonly TaskOutcome[],
-  warn: (message: string) => void,
-): void {
-  const tasks = failuresOf(outcomes)
-  if (tasks.length === 0) return
+  if (failures.length === 0) return
   try {
-    keep(cacheDir, runId, tasks)
+    keepRunNotes(indexDb(cache), runId, { failures })
   } catch (err) {
-    if (!isFsRefusal(err)) throw err
-    warn(`[vx] failed tasks' output not kept: ${err.message} — the verdict above stands`)
+    const message = err instanceof Error ? err.message : String(err)
+    warn(`[vx] failed tasks' output not kept: ${message} — the verdict above stands`)
   }
 }
 
-function keep(cacheDir: string, runId: string, tasks: TaskFailure[]): void {
-  const dir = dirOf(cacheDir)
-  mkdirSync(dir, { recursive: true })
-  const file = path.join(dir, `${runId}.json`)
-  const tmp = `${file}.${process.pid}.tmp`
-  writeFileSync(tmp, JSON.stringify({ runId, tasks }))
-  renameSync(tmp, file)
-  trimKept(dir, KEPT)
-}
-
-/**
- * Keep the newest `kept` runs' files in `dir`, and the temp files of runs
- * no older: a writer that crashed between its write and its rename left
- * `<runId>.json.<pid>.tmp`, which the trim of `.json` names never took. A
- * live writer's temp is of a run newer than every kept one.
- */
-export function trimKept(dir: string, kept: number): void {
-  const all = readdirSync(dir)
-  const names = all.filter((n) => n.endsWith('.json')).sort()
-  for (const n of names.slice(0, -kept)) rmSync(path.join(dir, n), { force: true })
-  if (names.length < kept) return
-  const oldest = names[names.length - kept]!
-  for (const n of all)
-    if (n.endsWith('.tmp') && n.slice(0, n.lastIndexOf('.json.') + 5) < oldest)
-      rmSync(path.join(dir, n), { force: true })
-}
-
 /**
  * The failed tasks of `runId`, or of the latest failed run when omitted;
- * null when there is no such run. A failed task the file lacks (an older
- * run, a write the disk refused) reads `output: ''`, `locations: []`.
+ * null when there is no such run. A failed task with no kept row (a run
+ * past the newest 50, a write the disk refused) reads `output: ''`,
+ * `locations: []`.
  */
-export function runFailures(cacheDir: string, db: Database, runId?: string): RunFailures | null {
+export function runFailures(db: Database, runId?: string): RunFailures | null {
   const id =
     runId ??
     (
@@ -138,7 +89,7 @@ export function runFailures(cacheDir: string, db: Database, runId?: string): Run
         .get() as { run_id: string } | null
     )?.run_id
   if (id === undefined) return null
-  const kept = storedFailures(cacheDir, id)
+  const kept = keptFailures(db, id)
   const rows = db
     .query(
       `SELECT r.project, r.task, r.exit_code AS exitCode, r.timed_out AS timedOut,
@@ -165,41 +116,16 @@ export function runFailures(cacheDir: string, db: Database, runId?: string): Run
         ...(r.timedOut === 1 ? { timedOut: true as const } : {}),
         ...(k?.inputMoved !== undefined ? { inputMoved: k.inputMoved } : {}),
         output: k?.output ?? '',
-        locations: k?.locations ?? [],
-        ...(k?.sandboxFix !== undefined ? { sandboxFix: k.sandboxFix } : {}),
+        locations: (k?.locations ?? []) as OutputLocation[],
+        ...(k?.sandboxFix !== undefined
+          ? { sandboxFix: k.sandboxFix as NonNullable<TaskOutcome['sandboxFix']> }
+          : {}),
         ...(r.fixedIn !== null ? { fixedIn: r.fixedIn } : {}),
       }
     }),
   }
 }
 
-/** What `runId`'s failures file holds, by task id; empty when the run kept none. */
-function storedFailures(cacheDir: string, runId: string): Map<string, StoredFailure> {
-  const kept = new Map<string, StoredFailure>()
-  // A run id the caller typed names a file in failures/ only.
-  if (path.basename(runId) !== runId || runId === '..') return kept
-  let text: string
-  try {
-    text = readFileSync(path.join(dirOf(cacheDir), `${runId}.json`), 'utf8')
-  } catch (err) {
-    // No file: the run kept no output.
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err
-    return kept
-  }
-  // A file the disk left torn (a rename that landed before its data, on
-  // power loss) is output the run did not keep: it threw on every `vx last`
-  // until 50 newer runs rotated it out.
-  let stored: unknown
-  try {
-    stored = JSON.parse(text)
-  } catch {
-    return kept
-  }
-  const tasks = (stored as { tasks?: unknown } | null)?.tasks
-  if (Array.isArray(tasks)) for (const t of tasks as StoredFailure[]) kept.set(t.taskId, t)
-  return kept
-}
-
 /** One task's output in a recorded run, as `vx last --log` and getTaskLog read it. */
 export interface TaskLog {
   runId: string
@@ -219,12 +145,7 @@ export interface TaskLog {
  * `taskId`'s output in `runId`, or in the latest run that recorded the
  * task when omitted; null when no such run recorded it.
  */
-export function taskLog(
-  cacheDir: string,
-  db: Database,
-  taskId: string,
-  runId?: string,
-): TaskLog | null {
+export function taskLog(db: Database, taskId: string, runId?: string): TaskLog | null {
   const [project, task] = splitTaskId(taskId)
   if (project === '' || task === '') return null
   const row = db
@@ -241,9 +162,9 @@ export function taskLog(
   if (row === null) return null
   const base = { runId: row.runId, taskId, status: row.status }
   if (row.status === 'failed') {
-    // Only the file: runFailures reads `output: ''` for a task it lacks, as
-    // if the task printed nothing, when the run is past the newest 50.
-    const kept = storedFailures(cacheDir, row.runId).get(taskId)
+    // Only the kept row: runFailures reads `output: ''` for a task it lacks,
+    // as if the task printed nothing, when the run is past the newest 50.
+    const kept = keptFailures(db, row.runId).get(taskId)
     if (kept !== undefined) return { ...base, source: 'failure', output: kept.output }
   } else if (row.hash !== '') {
     const stored = db.query('SELECT stdout FROM entry_stdout WHERE hash = ?').get(row.hash) as {

package/src/orchestrator/run-records.ts

@@ -38,6 +38,8 @@ export interface RunRecordsInput {
   host: HostContext
   /** Build the telemetry mirror; a run with no sink allocates none. */
   withTelemetry: boolean
+  /** Each task's count of the tasks and groups downstream of it (the scheduler's): the rows' `blocks`. */
+  blocks?: ReadonlyMap<string, number>
   /** The run's remote failures by key, so far (`Cache.traffic`). */
   remoteTraffic?: ReadonlyMap<string, { failures: readonly string[] }>
 }
@@ -124,6 +126,14 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     if (o.whereCores !== undefined) r.placementCores = o.whereCores
     if (o.whereMemoryBytes !== undefined) r.placementMemoryBytes = o.whereMemoryBytes
     if (o.cpuShare !== undefined) r.cpuShare = o.cpuShare
+    if (o.queuedMs !== undefined) r.queuedMs = o.queuedMs
+    if (o.outputBytes !== undefined) r.outputBytes = o.outputBytes
+    const blocks = input.blocks?.get(o.node.id)
+    if (blocks !== undefined) r.blocks = blocks
+    if (o.flaky !== undefined) {
+      r.flakyPasses = o.flaky.passes
+      r.flakyFailures = o.flaky.failures
+    }
     if (o.wallclockStartNs !== undefined) r.wallclockStartNs = o.wallclockStartNs
     if (o.wallclockEndNs !== undefined) r.wallclockEndNs = o.wallclockEndNs
     if (hit) r.restored = o.restored === true