@vzn/vx 0.0.651 → 0.0.652

package/src/orchestrator/keyed-projects.ts

@@ -63,3 +63,31 @@ export function keyedProjects(
     return below.get(root.id)!
   }
 }
+
+/**
+ * A run's lookup of the exec tasks whose outputs a sandboxed task may read:
+ * those its key folds, through a group to its members, never past an exec
+ * task. Their outputs are what their keys answer for, and this key folds
+ * those keys, so a read of them can never replay stale (the toolchain
+ * rule: a `tools` project builds Node, every dependant runs it). A
+ * dependency `inputs.tasks` leaves out is ordered, not read.
+ */
+export function readableDeps(
+  nodes: ReadonlyMap<string, TaskNode>,
+  keyOnly: ReadonlyMap<string, TaskNode> = new Map(),
+): (node: TaskNode) => readonly TaskNode[] {
+  const nodeOf = (id: string): TaskNode => nodes.get(id) ?? keyOnly.get(id)!
+  return (root) => {
+    const out = new Map<string, TaskNode>()
+    const seen = new Set<string>()
+    const stack = foldedDeps(root, nodeOf).map((c) => c.node)
+    while (stack.length > 0) {
+      const dep = stack.pop()!
+      if (seen.has(dep.id)) continue
+      seen.add(dep.id)
+      if (!isGroupTask(dep)) out.set(dep.id, dep)
+      else for (const { node } of foldedDeps(dep, nodeOf)) stack.push(node)
+    }
+    return [...out.values()]
+  }
+}

package/src/orchestrator/local-shortcircuit.ts

@@ -32,7 +32,7 @@
 //   - Only STABLE-key, cacheable, local-read tasks are classified. A
 //     stable miss stays in the normal (dep-gated) schedule; an unstable
 //     task is never probed here.
-//   - A task that declares `cache.outputs.workspaceFiles` (the
+//   - A task that declares `outputs.workspaceFiles` (the
 //     boundary-ignoring escape hatch) can write where a restore touches,
 //     so every task whose project directory a workspace-output glob's
 //     static prefix REACHES stays out of the restore tier, and so does
@@ -261,7 +261,7 @@ export function restoreTierExclusions(
   const prefixes: string[] = []
   let everything = false
   for (const node of nodes.values()) {
-    for (const raw of node.config.cache?.outputs.workspaceFiles ?? []) {
+    for (const raw of node.config.outputs?.workspaceFiles ?? []) {
       // A `!` entry needs no skip: its prefix (`!gen`) names no directory,
       // so it excludes nothing (A-44; the `continue` that stood here was
       // dropped in item 640).

package/src/orchestrator/miss-save.ts

@@ -109,7 +109,7 @@ export interface SaveMissArgs {
   workspaceRoot: string
   nestedProjectDirs: string[]
   gitFilesCache?: GitFilesCache | undefined
-  /** Declared `cache.outputs.files` / `.workspaceFiles`. */
+  /** Declared `outputs.files` / `.workspaceFiles`. */
   outputs: readonly string[]
   wsOutputs: readonly string[]
   /**
@@ -119,7 +119,7 @@ export interface SaveMissArgs {
    * would also take the upstream's files the task adds beside.
    */
   ownOutputFiles?: string[] | undefined
-  /** `ownOutputFiles` for `cache.outputs.workspaceFiles` (A-43). */
+  /** `ownOutputFiles` for `outputs.workspaceFiles` (A-43). */
   ownWsOutputFiles?: string[] | undefined
   /** The Tier-3 input fingerprint rows captured by the pre-exec describe. */
   captured: readonly TaskInputComponent[]
@@ -162,19 +162,38 @@ export async function saveMiss(a: SaveMissArgs): Promise<{ landed: Promise<SaveF
   // An additive task owns only the files it wrote (item 588), no directory.
   const tree =
     a.ownOutputFiles !== undefined
-      ? { files: a.ownOutputFiles, emptyDirs: [] }
+      ? { files: a.ownOutputFiles, emptyDirs: [], special: [] }
       : await resolveOutputTree({
           projectDir: node.projectDir,
           outputs: a.outputs,
           nestedProjectDirs: a.nestedProjectDirs,
+          special: true,
         })
   const outputFiles = tree.files
   const wsTree =
     a.ownWsOutputFiles !== undefined
-      ? { files: a.ownWsOutputFiles, emptyDirs: [] }
-      : await resolveWorkspaceOutputTree({ workspaceRoot: a.workspaceRoot, outputs: a.wsOutputs })
+      ? { files: a.ownWsOutputFiles, emptyDirs: [], special: [] }
+      : await resolveWorkspaceOutputTree({
+          workspaceRoot: a.workspaceRoot,
+          outputs: a.wsOutputs,
+          special: true,
+        })
   const wsOutputFiles = wsTree.files
   endResolve()
+  // A FIFO, socket or device holds no bytes to store (opening a FIFO waits
+  // for a writer, nx#35228), so it stays out of the entry; said, because a
+  // hit restores the tree without it.
+  const special = [
+    ...tree.special.map((p) => relPosix(node.projectDir, p)),
+    ...wsTree.special.map((p) => relPosix(a.workspaceRoot, p)),
+  ]
+  if (special.length > 0) {
+    warnOf(log)(
+      `[vx] ${node.id}: ${special.join(', ')} ${special.length === 1 ? 'is' : 'are'} not a regular file or symlink ` +
+        `(a FIFO, socket or device): vx does not cache ${special.length === 1 ? 'it' : 'them'}, so a hit restores the outputs without ${special.length === 1 ? 'it' : 'them'} ` +
+        `— emit a file there, or take ${special.length === 1 ? 'it' : 'them'} back with a '!' entry`,
+    )
+  }
   // The mirror of the input warning: declared outputs that resolve to
   // nothing save an empty artifact, and the next hit "restores" it —
   // the build that ran nowhere looks like a build that ran. `files: []`
@@ -191,14 +210,14 @@ export async function saveMiss(a: SaveMissArgs): Promise<{ landed: Promise<SaveF
     // (project dir === workspace root) the write SUCCEEDS into that
     // scratch and the task exits 0, so this warning is the only thing that
     // says the build produced nothing (item 444). A declared
-    // `cache.outputs` is not a write grant; `exec.sandbox.allow.write` is.
+    // `outputs` is not a write grant; `exec.sandbox.allow.write` is.
     const sandboxed = node.config.exec?.sandbox !== undefined
     const grantsWrite = (node.config.exec?.sandbox?.allow?.write?.length ?? 0) > 0
     // A `workspaceFiles` directory linked out of the workspace drops every
     // file (M-65); a project one is refused by the resolver (X-88).
     const linkedOut = outputDirLinkedOut(a.workspaceRoot, a.wsOutputs)
     warnOf(log)(
-      `[vx] ${node.id}: cache.outputs matched no files (${[...a.outputs, ...a.wsOutputs].join(', ')}) — ` +
+      `[vx] ${node.id}: outputs matched no files (${[...a.outputs, ...a.wsOutputs].join(', ')}) — ` +
         `an empty artifact is saved; a later hit restores nothing` +
         (linkedOut !== undefined
           ? ` — ${linkedOut.dir} is a symlink to ${linkedOut.target}, outside ${linkedOut.base}, and vx keeps only outputs inside it: make ${linkedOut.dir} a directory`
@@ -347,7 +366,7 @@ function sizeOf(base: string, files: readonly string[]): number {
  * these paths. On a 1000-package cold run this removes ~one synchronous
  * `git ls-files` spawn per project (the single largest cold-run cost —
  * 22% of CPU in profiling). Contract: outputs must be declared — an
- * executed task that writes files outside `cache.outputs.files` which a
+ * executed task that writes files outside `outputs.files` which a
  * same-project downstream task reads is undeclared behavior (the restore
  * path already assumes it).
  */

package/src/orchestrator/persistent-task.ts

@@ -19,6 +19,7 @@ import { warnOf } from '../report/index.js'
 import type { ExecuteArgs } from './execute-task.js'
 import {
   commandWriteReach,
+  dependencyReads,
   mayWriteFingerprint,
   type Placeholder,
   placeholderSweeper,
@@ -135,6 +136,7 @@ export async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutc
       undefined,
       args.nestedProjectDirs,
       args.cacheDir,
+      await dependencyReads(args.readableDeps?.(node) ?? [], args.workspaceRoot),
     )
     placeholders = sb.placeholders
     serverSandbox = sb.sandbox

package/src/orchestrator/placement.ts

@@ -337,7 +337,7 @@ export function placeTasks(
         projectDir: node.projectDir,
         command: node.config.exec!.command,
         pinnedLocal: pinned.has(node.id),
-        cacheable: node.config.cache !== undefined,
+        cacheable: node.config.cache === true,
       },
       executorLabel,
       (e) => pinsOf(e).has(node.id) || !routes(e),

package/src/orchestrator/plan.ts

@@ -25,7 +25,7 @@ export type CacheStatus =
   | 'hit-local' // entry exists in local cache
   | 'hit-remote' // entry exists in the remote layer (would be fetched)
   | 'miss' // caching enabled but no entry — would execute
-  | 'no-cache' // task opts out of caching (no `cache` block) or --no-cache
+  | 'no-cache' // task opts out of caching (no `cache: true`) or --no-cache
   | 'group' // no `exec`; just an aggregator
   | 'not-started' // a server every dependant of which restores early: the run never spawns it
   | 'skipped' // `exec.platforms` leave this machine out, or a task it depends on is skipped
@@ -186,7 +186,7 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
       // so nothing is probed. Whether that run is a miss or no cache at all
       // is the WRITE axes': `--force` and `--cache-policy=local:w` save what they
       // run, and the plan called them `no-cache`, the label a task with no
-      // `cache` block gets (item 991). The probe below routes through the
+      // `cache: true` gets (item 991). The probe below routes through the
       // policy-aware cache layer, which itself respects read gating.
       const policy = args.cachePolicy ?? FULL_CACHE_POLICY
       const reads = policy.localRead || policy.remoteRead

package/src/orchestrator/plugin-host.ts

@@ -521,6 +521,8 @@ export async function claimedExtraFiles(
 export interface ScheduleRun {
   readonly step?: <T>(id: string, work: () => Promise<T>) => Promise<T>
   readonly refined?: (merged: ReadonlyMap<string, number>) => void
+  /** Where `ctx.flaky` names go; none in a plan. */
+  readonly flaky?: (taskIds: Iterable<string>) => void
 }
 
 /**
@@ -533,7 +535,7 @@ export interface ScheduleRun {
 export async function applyScheduleHooks(
   plugins: readonly VxPlugin[],
   nodes: ReadonlyMap<string, TaskNode>,
-  ctx: Omit<ScheduleHookContext, 'cache' | 'refine' | 'onRefine' | 'refining'>,
+  ctx: Omit<ScheduleHookContext, 'cache' | 'refine' | 'onRefine' | 'refining' | 'flaky'>,
   cacheFor: (plugin: string) => PluginCache = () => absentPluginCache,
   run: ScheduleRun = {},
 ): Promise<ReadonlyMap<string, number>> {
@@ -586,7 +588,8 @@ export async function applyScheduleHooks(
     const onRefine = (listener: () => void): void => {
       if (run.refined !== undefined) listeners.push({ plugin, i, listener })
     }
-    const own = { ...ctx, cache: cacheFor(plugin.name), refine, onRefine, refining }
+    const flaky = (taskIds: Iterable<string>): void => run.flaky?.(taskIds)
+    const own = { ...ctx, cache: cacheFor(plugin.name), refine, onRefine, refining, flaky }
     const call = (): Promise<ReadonlyMap<string, number> | undefined> =>
       safe(plugin, 'schedule', () => plugin.schedule!(nodes, own))
     const weights = await (run.step === undefined
@@ -888,6 +891,7 @@ const EXECUTOR_HOOKS = [
   'footer',
   'machines',
   'idealMs',
+  'advice',
   'profile',
   'running',
 ] as const

package/src/orchestrator/plugin.ts

@@ -603,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/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-failures.ts

@@ -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

@@ -42,8 +42,16 @@ export interface RunRecordsInput {
   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
@@ -72,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
@@ -83,72 +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.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
-    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++
@@ -168,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,
@@ -190,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 }),