@vzn/vx 0.0.650 → 0.0.652

package/src/orchestrator/plugin.ts

@@ -27,9 +27,9 @@ import {
   type PluginSecrets,
   SecretBroker,
   thrownMessage,
-  ui,
   UserError,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import type { ProjectMeta } from '../workspace/index.js'
 import type { EventBus, Logger, RunStartInfo } from '../report/index.js'
 import type { CiContext } from './run-context.js'
@@ -460,7 +460,29 @@ export interface GraphHookContext extends BaseContext {
   readonly requested: readonly string[]
 }
 
-export interface KeyHookContext extends BaseContext {}
+export interface KeyHookContext extends BaseContext {
+  /**
+   * What `vx lock` recorded of the claimed `file` in
+   * `.vx/dependencies.lock.json` (`FingerprintClaim.digests`): a run keys
+   * from the record and never parses the file. Undefined when the file is
+   * absent and unrecorded. Refuses, naming `vx lock`, when the lock is
+   * absent or records no such present file; a recorded file whose bytes
+   * moved since refused the run before the key stage.
+   */
+  locked(file: string): Promise<LockedFile | undefined>
+}
+
+/** `KeyHookContext.locked`'s answer. */
+export interface LockedFile {
+  /**
+   * The other files the digests read → each one's hash then (`hashExtra`).
+   * Not checked by core: a `link:` directory is edited with no install,
+   * so a claimant whose extra file moved digests anew.
+   */
+  readonly extras: Readonly<Record<string, string>>
+  /** The project at `projectDir`'s digest; undefined when none. Refuses for a project the lock does not list. */
+  digest(projectDir: string): string | undefined
+}
 
 /** A plugin's claim on workspace-root files — see `VxPlugin.fingerprint`. */
 export interface FingerprintClaim {
@@ -491,6 +513,29 @@ export interface FingerprintClaim {
     bytes: Uint8Array,
     ctx: FingerprintContext,
   ): readonly string[] | Promise<readonly string[]>
+  /**
+   * Each project's digest of the claimed `file` as it is now, by project
+   * name, with `hash`, the xxh3 of the bytes they came from (`xxh3hex`),
+   * and `extras`, the other files they read. `vx lock` records them in
+   * `.vx/dependencies.lock.json` with each extra file's hash; a run keys
+   * from that record (`KeyHookContext.locked`), and `--affected`
+   * reads the base's copy there instead of asking `affected` to parse the
+   * base side, when its `hash` is the base file's xxh3. `undefined`:
+   * nothing to record.
+   */
+  digests?(
+    file: string,
+    ctx: FingerprintContext,
+  ): FingerprintDigests | undefined | Promise<FingerprintDigests | undefined>
+}
+
+/** `FingerprintClaim.digests`' answer. */
+export interface FingerprintDigests {
+  readonly hash: string
+  /** Project name → its digest of the file. */
+  readonly projects: Readonly<Record<string, string>>
+  /** Root-relative files besides `file` whose bytes the digests read (a `bun.lock` patch). */
+  readonly extras?: readonly string[]
 }
 
 export interface FingerprintChange {
@@ -558,6 +603,12 @@ export interface ScheduleHookContext extends BaseContext {
    * in a plan.
    */
   onRefine(listener: () => void): void
+  /**
+   * Name tasks a shared record knows as flaky (a history server's): one
+   * that fails gets the one retry a known flake gets, as the local
+   * record's do. Ids not in the run are ignored; ignored in a plan.
+   */
+  flaky(taskIds: Iterable<string>): void
 }
 
 /** A `cache` hook's context: the workspace and the run's scope, never the local store or the policy, which core owns. */

package/src/orchestrator/prepare.ts

@@ -39,6 +39,7 @@ import {
   gitPathspecs,
   MAX_SCOPED_PATHSPECS,
   startGitEnumeration,
+  checkBlobSizes,
   lazyGitEnumeration,
   measureFsClockLag,
   DEFAULT_STORE,
@@ -52,6 +53,7 @@ import {
   lockDigest,
   PROJECT_CONFIG_FILENAMES,
   readClaimedFiles,
+  readDependenciesLock,
   resolveCacheDir,
   resolveStoreRoot,
   type ProjectEntry,
@@ -76,6 +78,7 @@ import {
   teardownPlugins,
   type ScheduleRun,
 } from './plugin-host.js'
+import { lockedFiles } from './locked-digests.js'
 import {
   discoverProjects,
   gitOfDiscovery,
@@ -382,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
@@ -776,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,
@@ -800,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

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/remote-prefetch.ts

@@ -231,7 +231,7 @@ function fetchPool(
  * lookup, the other one that can reach a remote.
  */
 export function getContext(node: TaskNode, command: string) {
-  const outputs = node.config.cache?.outputs
+  const outputs = node.config.outputs
   let masked: string | undefined
   return {
     taskId: node.id,

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

@@ -8,7 +8,7 @@ import { isGroupTask, type TaskOutcome } from '../graph/index.js'
 import { decodeOutputLog } from './output-log.js'
 import { PASS_STATUSES } from '../history/index.js'
 import { maskedLine, splitTaskId } from '../util/index.js'
-import { fileLocations, fileMemo, type OutputLocation } from '../report/index.js'
+import { fileLocations, fileMemo, type OutputLocation } from '../ui/index.js'
 
 /** A failed task of a run and what it said. */
 export interface TaskFailure {
@@ -46,17 +46,16 @@ export function writeRunFailures(
   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.
-    if ((o.failedOutput === undefined && o.inputMoved === undefined) || isGroupTask(o.node))
+    // is still why, and an agent reads it here. A pass that took a retry
+    // keeps its failed attempts.
+    if (
+      (o.failedOutput === undefined &&
+        o.inputMoved === undefined &&
+        o.attemptOutputs === undefined) ||
+      isGroupTask(o.node)
+    )
       continue
-    const output =
-      o.failedOutput === undefined
-        ? ''
-        : Bun.stripANSI(
-            decodeOutputLog(o.failedOutput)
-              .map((c) => c.text)
-              .join(''),
-          )
+    const output = attemptsText(o)
     failures.push({
       taskId: o.node.id,
       ...(o.inputMoved !== undefined ? { inputMoved: o.inputMoved } : {}),
@@ -74,6 +73,40 @@ export function writeRunFailures(
   }
 }
 
+const plain = (log: string): string =>
+  Bun.stripANSI(
+    decodeOutputLog(log)
+      .map((c) => c.text)
+      .join(''),
+  )
+
+/** How attempt `n` of `of` ended, the line above its output. */
+const attemptHeading = (n: number, of: number, how: string): string =>
+  `── attempt ${n} of ${of} · ${how} ──\n`
+
+const ended = (a: { exitCode: number; timedOut?: true }): string =>
+  a.timedOut === true ? 'timed out' : `exit ${a.exitCode}`
+
+/**
+ * What a failure row keeps of `o`: its output, after each failed attempt's
+ * under a heading when it retried. A pass that retried keeps only the
+ * failed attempts: its own output is its cache entry's.
+ */
+function attemptsText(o: TaskOutcome): string {
+  const last = o.failedOutput === undefined ? '' : plain(o.failedOutput)
+  const before = o.attemptOutputs ?? []
+  if (before.length === 0) return last
+  const of = before.length + 1
+  let text = ''
+  before.forEach((log, i) => {
+    const out = plain(log)
+    text += attemptHeading(i + 1, of, ended(o.failedAttempts![i]!)) + out
+    if (out !== '' && !out.endsWith('\n')) text += '\n'
+  })
+  if (o.status === 'failed') text += attemptHeading(of, of, ended(o)) + last
+  return text
+}
+
 /**
  * The failed tasks of `runId`, or of the latest failed run when omitted;
  * null when there is no such run. A failed task with no kept row (a run
@@ -167,6 +200,19 @@ export function taskLog(db: Database, taskId: string, runId?: string): TaskLog |
     const kept = keptFailures(db, row.runId).get(taskId)
     if (kept !== undefined) return { ...base, source: 'failure', output: kept.output }
   } else if (row.hash !== '') {
+    // A pass that took a retry: its failed attempts, then its own output.
+    const before = keptFailures(db, row.runId).get(taskId)?.output
+    const tries = (
+      db
+        .query(
+          'SELECT attempts FROM runs WHERE run_id = ? AND project = ? AND task = ? ORDER BY id DESC LIMIT 1',
+        )
+        .get(row.runId, project, task) as { attempts: number | null } | null
+    )?.attempts
+    const prefix =
+      before === undefined || tries === null || tries === undefined
+        ? ''
+        : `${before}${attemptHeading(tries, tries, 'passed')}`
     const stored = db.query('SELECT stdout FROM entry_stdout WHERE hash = ?').get(row.hash) as {
       stdout: string
     } | null
@@ -182,12 +228,15 @@ export function taskLog(db: Database, taskId: string, runId?: string): TaskLog |
             .join(''),
         ),
       )
-      return { ...base, source: 'cache', output }
+      return { ...base, source: 'cache', output: prefix + output }
     }
     // An entry that printed nothing stores no stdout row: kept, and empty.
     if (db.query('SELECT 1 FROM entries WHERE hash = ?').get(row.hash) !== null) {
-      return { ...base, source: 'cache', output: '' }
+      return { ...base, source: 'cache', output: prefix }
     }
   }
+  // A pass with no entry that took a retry still kept its failed attempts.
+  const kept = row.status === 'failed' ? undefined : keptFailures(db, row.runId).get(taskId)
+  if (kept !== undefined) return { ...base, source: 'failure', output: kept.output }
   return { ...base, source: null, output: '' }
 }

package/src/orchestrator/run-keys.ts

@@ -89,7 +89,7 @@ export function runKeysToken(args: RunKeysArgs): RunKeysAt | undefined {
       if ((inputs.workspaceFiles?.length ?? 0) > 0) return undefined
       // No positive entry resolves no files (`filesPlan`).
       if (inputs.files === undefined || inputs.files.some((e) => !e.startsWith('!'))) {
-        const outputs = cfg.cache?.outputs
+        const outputs = cfg.outputs
         const declared = `${node.projectName}\0${JSON.stringify([inputs.files, outputs?.files, outputs?.workspaceFiles])}`
         let token = tokens.get(declared)
         if (token === undefined) {

package/src/orchestrator/run-records.ts

@@ -38,10 +38,20 @@ 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[] }>
+  /** Outcomes whose rows the history stream already wrote: counted, not written again. */
+  landed?: ReadonlySet<TaskOutcome>
 }
 
+/** What a task's `runs` row reads besides its outcome. */
+export type RunRecordContext = Pick<
+  RunRecordsInput,
+  'tainted' | 'runId' | 'startedAtMs' | 'endedAtMs' | 'forwardArgs' | 'blocks' | 'remoteTraffic'
+>
+
 export interface RunRecords {
   runs: RunRecord[]
   invocation: InvocationRecord
@@ -70,6 +80,7 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
   const { outcomes, runId, startedAtMs, endedAtMs } = input
   const runs: RunRecord[] = []
   const telemetryTasks: TaskTelemetry[] = []
+  let taskCount = 0
   let failedCount = 0
   let hitLocalCount = 0
   let hitRemoteCount = 0
@@ -81,64 +92,8 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     // aborted (killed by a shutdown signal) isn't a real run.
     if (o.status === 'aborted') continue
     if (input.withTelemetry) telemetryTasks.push(taskTelemetryOf(o))
-    const blockedBy = o.blockedBy ?? input.tainted?.get(o.node.id)
-    const remoteError = remoteErrorOf(input.remoteTraffic, o.hash)
-    // Built field by field: a spread per optional field was ~2 µs of each
-    // of a 1,200-hit warm run's rows.
-    const hit = isCacheHit(o.status)
-    const r: RunRecord = {
-      project: o.node.projectName,
-      task: o.node.taskName,
-      status: o.status,
-      exitCode: o.exitCode,
-      durationMs: o.durationMs,
-      // Anchor to the REAL per-task wall-clock window: run-start wall time +
-      // the task's ns offset (captured for hits and executed tasks alike).
-      // The `end - duration` fallback applies to outcomes without an offset —
-      // today only `skipped`, which the scheduler finishes synchronously with
-      // no span, so it collapses to a zero-width mark at the run's end. Using
-      // run-end-minus-duration for EVERYTHING was the old bug that piled every
-      // task at the right edge of the timeline.
-      startedAt:
-        o.wallclockStartNs !== undefined
-          ? startedAtMs + Math.round(Number(o.wallclockStartNs) / 1e6)
-          : endedAtMs - o.durationMs,
-      endedAt:
-        o.wallclockEndNs !== undefined
-          ? startedAtMs + Math.round(Number(o.wallclockEndNs) / 1e6)
-          : endedAtMs,
-      runId,
-      cacheHit: hit,
-      cached: o.node.config.cache !== undefined,
-    }
-    if (o.hash !== undefined) r.hash = o.hash
-    // A run forwards its args to the tasks it was asked for, never to a
-    // dependency: the row says which ran with them.
-    if (input.forwardArgs !== undefined && input.forwardArgs.length > 0 && o.node.requested)
-      r.forwardArgs = input.forwardArgs
-    if (o.cpuMs !== undefined) r.cpuMs = o.cpuMs
-    if (o.peakRssBytes !== undefined) r.peakRssBytes = o.peakRssBytes
-    if (o.peakCores !== undefined) r.peakCores = o.peakCores
-    if (o.avgRssBytes !== undefined) r.avgRssBytes = o.avgRssBytes
-    if (o.where !== undefined) r.placement = o.where
-    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.wallclockStartNs !== undefined) r.wallclockStartNs = o.wallclockStartNs
-    if (o.wallclockEndNs !== undefined) r.wallclockEndNs = o.wallclockEndNs
-    if (hit) r.restored = o.restored === true
-    if (o.attempts !== undefined) r.attempts = o.attempts
-    // A task that ran behind a failure names it too, so the flakiness
-    // projection counts its outcome on no key (failure-mode.ts).
-    if (blockedBy !== undefined) r.blockedBy = blockedBy
-    if (o.timedOut === true) r.timedOut = true
-    if (o.sandboxViolations !== undefined) r.sandboxViolations = o.sandboxViolations
-    if (o.notReady !== undefined) r.notReady = o.notReady
-    if (remoteError !== undefined) r.remoteError = remoteError
-    if (o.keylessBy !== undefined) r.keylessBy = o.keylessBy
-    const def = taskDefinition(o.node)
-    if (def !== undefined) r.def = def
-    runs.push(r)
+    taskCount++
+    if (input.landed?.has(o) !== true) runs.push(runRecordOf(o as RecordedOutcome, input))
     if (o.status === 'failed') failedCount++
     if (o.status === 'cache-hit') hitLocalCount++
     if (o.status === 'cache-hit-remote') hitRemoteCount++
@@ -158,7 +113,7 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
     startedAt: startedAtMs,
     endedAt: endedAtMs,
     totalDurationMs: Math.round(input.totalMs),
-    taskCount: runs.length,
+    taskCount,
     failedCount,
     hitCount: hitLocalCount + hitRemoteCount,
     hitLocalCount,
@@ -180,6 +135,80 @@ export function assembleRunRecords(input: RunRecordsInput): RunRecords {
   return { runs, invocation, telemetryTasks }
 }
 
+/** An outcome a `runs` row records: every status but `aborted`. */
+export type RecordedOutcome = TaskOutcome & { status: RunRecord['status'] }
+
+/** One outcome's `runs` row. */
+export function runRecordOf(o: RecordedOutcome, input: RunRecordContext): RunRecord {
+  const { runId, startedAtMs, endedAtMs } = input
+  const blockedBy = o.blockedBy ?? input.tainted?.get(o.node.id)
+  const remoteError = remoteErrorOf(input.remoteTraffic, o.hash)
+  // Built field by field: a spread per optional field was ~2 µs of each
+  // of a 1,200-hit warm run's rows.
+  const hit = isCacheHit(o.status)
+  const r: RunRecord = {
+    project: o.node.projectName,
+    task: o.node.taskName,
+    status: o.status,
+    exitCode: o.exitCode,
+    durationMs: o.durationMs,
+    // Anchor to the REAL per-task wall-clock window: run-start wall time +
+    // the task's ns offset (captured for hits and executed tasks alike).
+    // The `end - duration` fallback applies to outcomes without an offset —
+    // today only `skipped`, which the scheduler finishes synchronously with
+    // no span, so it collapses to a zero-width mark at the run's end. Using
+    // run-end-minus-duration for EVERYTHING was the old bug that piled every
+    // task at the right edge of the timeline.
+    startedAt:
+      o.wallclockStartNs !== undefined
+        ? startedAtMs + Math.round(Number(o.wallclockStartNs) / 1e6)
+        : endedAtMs - o.durationMs,
+    endedAt:
+      o.wallclockEndNs !== undefined
+        ? startedAtMs + Math.round(Number(o.wallclockEndNs) / 1e6)
+        : endedAtMs,
+    runId,
+    cacheHit: hit,
+    cached: o.node.config.cache === true,
+  }
+  if (o.hash !== undefined) r.hash = o.hash
+  // A run forwards its args to the tasks it was asked for, never to a
+  // dependency: the row says which ran with them.
+  if (input.forwardArgs !== undefined && input.forwardArgs.length > 0 && o.node.requested)
+    r.forwardArgs = input.forwardArgs
+  if (o.cpuMs !== undefined) r.cpuMs = o.cpuMs
+  if (o.peakRssBytes !== undefined) r.peakRssBytes = o.peakRssBytes
+  if (o.peakCores !== undefined) r.peakCores = o.peakCores
+  if (o.avgRssBytes !== undefined) r.avgRssBytes = o.avgRssBytes
+  if (o.where !== undefined) r.placement = o.where
+  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
+  if (o.attempts !== undefined) r.attempts = o.attempts
+  // A task that ran behind a failure names it too, so the flakiness
+  // projection counts its outcome on no key (failure-mode.ts).
+  if (blockedBy !== undefined) r.blockedBy = blockedBy
+  if (o.timedOut === true) r.timedOut = true
+  if (o.sandboxViolations !== undefined) r.sandboxViolations = o.sandboxViolations
+  if (o.notReady !== undefined) r.notReady = o.notReady
+  if (remoteError !== undefined) r.remoteError = remoteError
+  if (o.keylessBy !== undefined) r.keylessBy = o.keylessBy
+  const def = taskDefinition(o.node)
+  if (def !== undefined) r.def = def
+  return r
+}
+
 /**
  * The remote failures uploads met after the run's rows went in (the uploads
  * drain later): each row whose text is now short of its key's is rewritten.

package/src/orchestrator/run-report.ts

@@ -49,7 +49,7 @@ async function outputsLeft(
   workspaceRoot: string,
   nestedProjectDirs: string[],
 ): Promise<string[]> {
-  const declared = node.config.cache?.outputs
+  const declared = node.config.outputs
   if (declared === undefined) return []
   const [own, ws] = await Promise.all([
     resolveOutputs({ projectDir: node.projectDir, outputs: declared.files, nestedProjectDirs }),