@vzn/vx 0.0.637 → 0.0.639

package/src/orchestrator/prepare.ts

@@ -19,6 +19,12 @@ import {
   parseCachePolicy,
   GitFilesCache,
   LayeredCache,
+  absentPluginCache,
+  pluginCache,
+  putRunEntry,
+  writesRunStore,
+  type PluginCache,
+  type ResolvedRemote,
   ScopedCache,
   applyGitEnumeration,
   gitPathspecs,
@@ -72,9 +78,10 @@ import { applyGraphStage } from './graph-stage.js'
 import { keyExcludedDependencies } from './excluded-keys.js'
 import { FingerprintWatch } from './fingerprint-watch.js'
 import type { VxPlugin } from './plugin.js'
+import { askIgnoredOutputs, gatedOutputs } from './stable-keys.js'
 import { currentBranch } from './run-context.js'
 import { createHashCache, type HashCache } from './task-hash.js'
-import type { Logger } from './logger.js'
+import { type Logger, warnOf } from '../report/index.js'
 import type { RunOptions } from './options.js'
 import { refuseFiltersThroughGroups } from './upstream.js'
 import { runRules } from '../settings.js'
@@ -116,6 +123,13 @@ export interface PreparedRun {
    * Learned on first ask, once per run.
    */
   branch: () => string | null
+  /** Each plugin's `ctx.cache`: the run's local store and remotes, under its policy and scope. */
+  cacheFor: (plugin: string) => PluginCache
+  /**
+   * Keep `bytes` of this run under `name` (run-store.ts); undefined when no
+   * remote takes the run's writes, and so core keeps nothing.
+   */
+  keepRunEntry: ((name: string, bytes: Uint8Array) => Promise<boolean>) | undefined
   nodes: Map<string, TaskNode>
   /**
    * The tasks `--exclude-dependencies` took out of the schedule: keyed as a
@@ -228,9 +242,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     (reused !== undefined ? gitOfDiscovery(reused.projects) : undefined) ??
     lazyGitEnumeration(workspaceRoot)
   if (wholeTree) void git.start()
-  const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, (m) =>
-    log.status(m),
-  )
+  const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, warnOf(log))
   mark('workspace config')
   let learnedBranch: string | null | undefined
   const branch = (): string | null =>
@@ -250,14 +262,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   const projectMetas =
     reused !== undefined
       ? reused.projects
-      : await discoverProjects(
-          workspaceRoot,
-          readLock,
-          plugins,
-          cacheDir,
-          (m) => log.status(m),
-          git,
-        )
+      : await discoverProjects(workspaceRoot, readLock, plugins, cacheDir, warnOf(log), git)
   mark('discover projects')
 
   // SCOPED config loading: configs are programs, and evaluating 1090
@@ -355,7 +360,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     projectMetas,
     packageGraph,
     configs: readLock,
-    warn: (m: string) => log.status(m),
+    warn: warnOf(log),
   }
   let loaded: LoadedProjects
   try {
@@ -451,26 +456,33 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // winning prevents double-wrapping when the workspace also declares a
   // cache plugin.
   let cache: CacheLayer
+  const remotes: ResolvedRemote[] = []
+  if (options.remoteCache) {
+    remotes.push({
+      remote: options.remoteCache,
+      read: policy.remoteRead,
+      write: policy.remoteWrite,
+      onError: (err) => warnOf(log)(`[vx] remote cache: ${err.message}`),
+    })
+  }
   try {
     cache = options.remoteCache
-      ? new LayeredCache(localCache, options.remoteCache, {
-          policy,
-          onRemoteError: (err) => log.status(`[vx] remote cache: ${err.message}`),
-        })
+      ? new LayeredCache(localCache, remotes)
       : await resolveCache(plugins, {
           workspaceRoot,
           cacheDir,
-          warn: (m) => log.status(m),
+          warn: warnOf(log),
           scope: cacheScope,
           localCache,
           policy,
+          remotes,
         })
   } catch (err) {
     // A cache plugin that throws or returns something off-contract is
     // refused by name; the local handle opened above must not leak with it,
     // nor what another plugin's factory opened: the factories have run
     // (C-4, item 1029's contract).
-    await teardownPlugins(plugins, (m) => log.status(m))
+    await teardownPlugins(plugins, warnOf(log))
     localCache.close()
     throw err
   }
@@ -509,8 +521,10 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       localCache,
       hasRemoteLayer,
       cachePolicy: policy,
+      keepRunEntry: undefined,
       priorities: () => Promise.resolve(new Map()),
       branch,
+      cacheFor: () => absentPluginCache,
       nodes: new Map(),
       keyOnly: new Map(),
       unresolvedTasks,
@@ -560,7 +574,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
         workspaceRoot,
         cacheDir,
         projectMetas,
-        warn: (m) => log.status(m),
+        warn: warnOf(log),
         rules: graphRules,
       })
     // `--affected` selects over the FINAL graph: an edge or an input a
@@ -657,11 +671,16 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       if ((n.config.cache?.inputs.workspaceFiles?.length ?? 0) > 0) usesWorkspaceInputs = true
     }
     const projectDirs = [...graphDirs]
-    const enumeration = await (git.started ??
+    const enumerating =
+      git.started ??
       startGitEnumeration(
         workspaceRoot,
         gitPathspecs(workspaceRoot, projectDirs, usesWorkspaceInputs),
-      ))
+      )
+    // While git walks: the gate's pass over every task cost 2-8 ms at
+    // 1,000 projects when it ran before the spawn.
+    const settleIgnored = askIgnoredOutputs(gatedOutputs(nodes, workspaceRoot), workspaceRoot)
+    const enumeration = await enumerating
     await applyGitEnumeration(
       enumeration,
       workspaceRoot,
@@ -670,6 +689,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       usesWorkspaceInputs,
       localCache,
     )
+    await settleIgnored(gitFilesCache)
     mark('git enumeration')
     if (hasGraphHook && !hooksFirst) await graphStage()
     // Args after `--` go to requested commands only; with none among them
@@ -685,7 +705,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       }
     }
     if (hasHook(plugins, 'key')) {
-      await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: (m) => log.status(m) })
+      await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: warnOf(log) })
     }
     refuseFiltersThroughGroups(nodes)
     const exclude = options.excludeDependencies
@@ -708,16 +728,35 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
         })
       }
     }
+    const pluginCaches = new Map<string, PluginCache>()
+    const cacheFor = (plugin: string): PluginCache => {
+      let own = pluginCaches.get(plugin)
+      if (own === undefined) {
+        own = pluginCache(plugin, {
+          db: localCache.dbHandle(),
+          policy,
+          remotes,
+          scope: cacheScope,
+        })
+        pluginCaches.set(plugin, own)
+      }
+      return own
+    }
     let scheduled: Promise<ReadonlyMap<string, number>> | undefined
     const priorities = (): Promise<ReadonlyMap<string, number>> =>
       (scheduled ??= hasHook(plugins, 'schedule')
-        ? applyScheduleHooks(plugins, nodes, {
-            workspaceRoot,
-            cacheDir,
-            warn: (m) => log.status(m),
-            localCache,
-            branch: branch(),
-          })
+        ? applyScheduleHooks(
+            plugins,
+            nodes,
+            {
+              workspaceRoot,
+              cacheDir,
+              warn: warnOf(log),
+              localCache,
+              branch: branch(),
+            },
+            cacheFor,
+          )
         : Promise.resolve(new Map()))
 
     return {
@@ -731,6 +770,10 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       cachePolicy: policy,
       priorities,
       branch,
+      cacheFor,
+      keepRunEntry: writesRunStore(remotes)
+        ? (name, bytes) => putRunEntry(remotes, cacheScope, name, bytes)
+        : undefined,
       nodes,
       keyOnly,
       unresolvedTasks,
@@ -746,7 +789,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       empty: nodes.size === 0 ? 'empty-graph' : null,
     }
   } catch (err) {
-    await teardownPlugins(plugins, (m) => log.status(m))
+    await teardownPlugins(plugins, warnOf(log))
     cache.close()
     throw err
   }

package/src/orchestrator/projects.ts

@@ -163,6 +163,8 @@ interface LoadProjectsBase {
    */
   configs: () => Promise<Lockfile>
   warn: (message: string) => void
+  /** `vx lock`'s audit: the `project` stage's `ctx.lock`. */
+  lock?: boolean
   /**
    * Entries a load in this same process already produced with the same
    * cache dir and lock (the CLI's selection pass, which stages every
@@ -323,6 +325,7 @@ export async function loadProjects(args: LoadProjectsArgs): Promise<LoadedProjec
             name: meta.name,
             dir: meta.dir,
             projects: args.projectMetas,
+            lock: args.lock === true,
           },
           (plugin) =>
             validateProjectConfig(

package/src/orchestrator/remote-prefetch.ts

@@ -12,8 +12,9 @@
 // GET per key.
 //
 // HARD SCOPE: this runs ONLY when a remote layer is configured. It
-// NEVER touches the local cache (no local get / no isOutputsCurrent /
-// no stat pass) — it derives keys and probes REMOTE only. Local-only
+// asks the local index only which keys it holds (no local get / no
+// isOutputsCurrent), and probes the remote for the rest: a run the local
+// cache answers makes no remote call (M, 2026-10-15). Local-only
 // runs are byte-identical to before; the caller gates on the layer's
 // own `hasRemote`, so a third-party remote layer gets the overlap too.
 // The two batch-probe hooks are OPTIONAL on the contract: a remote layer
@@ -40,6 +41,11 @@ export interface PrefetchArgs {
   concurrency: number
   /** When false (remote reads disabled), no prefetch fires. */
   remoteRead: boolean
+  /**
+   * With reads off and writes on (`--force`), the keys go to
+   * `probeBeforeUpload` instead, so a key a remote holds is not re-sent.
+   */
+  remoteWrite: boolean
 }
 
 /**
@@ -54,7 +60,15 @@ export interface PrefetchArgs {
  * is always correct.
  */
 export function startRemotePrefetch(args: PrefetchArgs): Promise<void> {
-  if (!args.remoteRead) return Promise.resolve()
+  if (!args.remoteRead) {
+    if (!args.remoteWrite || args.cache.probeBeforeUpload === undefined) return Promise.resolve()
+    const hashes = deriveStableKeys(args).then((keys) => [...new Set(keys.map((k) => k.hash))])
+    args.cache.probeBeforeUpload(hashes)
+    return hashes.then(
+      () => {},
+      () => {},
+    )
+  }
   // Detached from EXECUTION: the caller does NOT await this before
   // scheduling, so prefetch network latency overlaps the run. But the
   // caller DOES await the returned handle before closing the cache, so
@@ -75,8 +89,11 @@ async function runPrefetch(args: PrefetchArgs): Promise<void> {
   // would 404. When the remote can't batch (`null` — an older remote, reads
   // disabled, or a layer that doesn't implement the hook at all), fall back to
   // prefetching every stable key, exactly as before.
-  let toPrefetch = stableKeys
-  const uniqueHashes = [...new Set(stableKeys.map((k) => k.hash))]
+  const held =
+    (await args.cache.localHasMany?.([...new Set(stableKeys.map((k) => k.hash))])) ?? null
+  let toPrefetch = held === null ? stableKeys : stableKeys.filter((k) => !held.has(k.hash))
+  if (toPrefetch.length === 0) return
+  const uniqueHashes = [...new Set(toPrefetch.map((k) => k.hash))]
   const present = (await args.cache.remoteHasMany?.(uniqueHashes)) ?? null
   if (present !== null) {
     args.cache.markRemoteAbsent?.(uniqueHashes.filter((h) => !present.has(h)))
@@ -85,7 +102,7 @@ async function runPrefetch(args: PrefetchArgs): Promise<void> {
     // economy: deleting it alone GETs nothing extra, deleting both GETs
     // every absent key. What it decides is which hashes the pump asks
     // the layer for, and that is what the row pins (item 643, 645).
-    toPrefetch = stableKeys.filter((k) => present.has(k.hash))
+    toPrefetch = toPrefetch.filter((k) => present.has(k.hash))
     if (toPrefetch.length === 0) return
   }
 

package/src/orchestrator/run-artifacts.ts

@@ -1,182 +1,10 @@
-// Optional per-run output artifacts:
-//
-//   --summarize[=<path>] → JSON describing every task's outcome
-//                          (id, status, exit code, durations, hash,
-//                          cpu_ms, peak_rss_bytes, hrtime spans).
-//                          Default path: <cacheDir>/runs/<run_id>.json.
-//
-//   --profile[=<path>]   → Chrome-trace JSON of the run. Each task is
-//                          a single complete event (`ph: 'X'`) with
-//                          ts / dur in microseconds derived from the
-//                          hrtime spans the runner already captures.
-//                          Default path: profile.json (cwd-relative).
-//
-// Both are no-ops if the corresponding RunOptions field is undefined.
+// `--profile[=<path>]`: Chrome-trace JSON of the run. Each task is a single
+// complete event (`ph: 'X'`) with ts / dur in microseconds derived from the
+// hrtime spans the runner already captures. Default path: profile.json
+// (cwd-relative).
 
 import path from 'node:path'
-import { isGroupTask, type TaskOutcome } from '../graph/index.js'
-import { tallyOutcomes, type Tally } from './tally.js'
-import type { FlakyFinding } from './failure-mode.js'
-import { isCacheHit } from './telemetry.js'
-import { ranNoCache } from './events.js'
-
-export interface SummarizeArgs {
-  /** Empty string → default path; otherwise the explicit file path. */
-  target: string
-  cacheDir: string
-  cwd: string
-  runId: string
-  startedAtMs: number
-  endedAtMs: number
-  totalMs: number
-  /** The run's verdict — the same value the CLI turns into the exit code. */
-  ok: boolean
-  /** The process's exit code where it is not `ok ? 0 : 1`: a stopping signal's. */
-  exitCode?: number
-  outcomes: readonly TaskOutcome[]
-  /** What `detectFlaky` found this run; each row's flaky note, typed. */
-  flaky?: readonly FlakyFinding[]
-}
-
-/** One task of `--summarize`: the wire, stated by `schemas/summary.json`. */
-export interface SummaryTaskJson {
-  id: string
-  project: string
-  task: string
-  status: TaskOutcome['status']
-  exitCode: number
-  durationMs: number
-  hash: string | null
-  restored?: boolean
-  noCache?: true
-  flaky?: { passes: number; failures: number; attempts: number }
-  cpuMs?: number
-  peakRssBytes?: number
-  storedDurationMs?: number
-  storedCpuMs?: number
-  storedPeakRssBytes?: number
-  admissionHeldMs?: number
-  blockedBy?: string
-  timedOut?: true
-  sandboxViolations?: number
-  notReady?: 'timeout' | 'exited' | 'spawn'
-  wallclockStartNs?: string
-  wallclockEndNs?: string
-}
-
-/** The `--summarize` document. */
-export interface RunSummaryJson {
-  runId: string
-  ok: boolean
-  exitCode: number
-  startedAt: string
-  endedAt: string
-  totalMs: number
-  /** What the hits skipped: the sum of their `storedDurationMs`. */
-  savedMs: number
-  tasks: SummaryTaskJson[]
-  aborted: SummaryTaskJson[]
-  summary: Tally
-}
-
-/** One task's entry. Shared by `tasks` and `aborted` so they read alike. */
-function taskEntry(o: TaskOutcome, flaky?: FlakyFinding): SummaryTaskJson {
-  return {
-    id: o.node.id,
-    project: o.node.projectName,
-    task: o.node.taskName,
-    status: o.status,
-    exitCode: o.exitCode,
-    durationMs: o.durationMs,
-    hash: o.hash ?? null,
-    // On a hit: whether it restored outputs or found them up to date, as
-    // `summary`'s restoredLocal / restoredRemote / upToDate count it.
-    ...(isCacheHit(o.status) ? { restored: o.restored === true } : {}),
-    // A task with no `cache` block executes every run by design; without
-    // the flag a consumer computing a hit rate cannot tell a miss from a
-    // task that could never hit (its `hash` is still set — dependents fold
-    // it). Present only when true, so every other row is byte-identical.
-    ...(ranNoCache(o) ? { noCache: true } : {}),
-    // Present only when the run proved the task flaky: this exact key
-    // failed after it had passed (this run counted), or the task
-    // needed a retry. A consumer gating on `failed` can tell a break from a
-    // flake without the history; every other row is byte-identical.
-    ...(flaky !== undefined
-      ? { flaky: { passes: flaky.passes, failures: flaky.failures, attempts: flaky.attempts } }
-      : {}),
-    ...(o.cpuMs !== undefined ? { cpuMs: o.cpuMs } : {}),
-    ...(o.peakRssBytes !== undefined ? { peakRssBytes: o.peakRssBytes } : {}),
-    // A hit's row names what the PRODUCING execution used under its own
-    // keys, so a consumer never reads a remote worker's peak as this run's.
-    ...(o.storedDurationMs !== undefined ? { storedDurationMs: o.storedDurationMs } : {}),
-    ...(o.storedCpuMs !== undefined ? { storedCpuMs: o.storedCpuMs } : {}),
-    ...(o.storedPeakRssBytes !== undefined ? { storedPeakRssBytes: o.storedPeakRssBytes } : {}),
-    // Present only when an `admit` policy held the task with a worker free.
-    ...(o.admissionHeldMs !== undefined ? { admissionHeldMs: o.admissionHeldMs } : {}),
-    // A skipped row names the failed (or aborted) task at the root of what
-    // blocked it; a fail-fast skip has none.
-    ...(o.blockedBy !== undefined ? { blockedBy: o.blockedBy } : {}),
-    // A failure vx's own `timeout` killed; absent on every other row.
-    ...(o.timedOut === true ? { timedOut: true } : {}),
-    // The sandbox's violation count; present only on a task it recorded any for.
-    ...(o.sandboxViolations !== undefined ? { sandboxViolations: o.sandboxViolations } : {}),
-    // A persistent task that never became ready, and why.
-    ...(o.notReady !== undefined ? { notReady: o.notReady } : {}),
-    // hrtime spans are bigints → emit as strings so JSON.parse on
-    // the consumer side doesn't truncate the ns precision.
-    ...(o.wallclockStartNs !== undefined ? { wallclockStartNs: String(o.wallclockStartNs) } : {}),
-    ...(o.wallclockEndNs !== undefined ? { wallclockEndNs: String(o.wallclockEndNs) } : {}),
-  }
-}
-
-export async function writeRunSummary(args: SummarizeArgs): Promise<string> {
-  const outPath =
-    args.target === ''
-      ? path.join(args.cacheDir, 'runs', `${args.runId}.json`)
-      : path.resolve(args.cwd, args.target)
-  await Bun.write(outPath, JSON.stringify(runSummaryJson(args), null, 2))
-  return outPath
-}
-
-/** The `--summarize` document, which `vx run --format json` prints. */
-export function runSummaryJson(
-  args: Omit<SummarizeArgs, 'target' | 'cacheDir' | 'cwd'>,
-): RunSummaryJson {
-  // `tasks` and `summary` must describe the same population, or one artifact
-  // contradicts itself (a group task listed in `tasks` but absent from
-  // `summary.total`). `tallyOutcomes` owns the rule; mirror its filter here.
-  const counted = args.outcomes.filter((o) => !isGroupTask(o.node) && o.status !== 'aborted')
-  // A task killed by a shutdown signal is in no bucket and no total, yet it
-  // makes the run red. Listing it separately keeps `tasks.length ===
-  // summary.total` while leaving the artifact able to explain a non-zero
-  // exit — the terminal has said so in its Aborted section all along, and a
-  // parser must not be told less than a human is.
-  const aborted = args.outcomes.filter((o) => !isGroupTask(o.node) && o.status === 'aborted')
-  const flakyById = new Map((args.flaky ?? []).map((f) => [f.taskId, f]))
-  const exitCode = args.exitCode ?? (args.ok ? 0 : 1)
-  const payload: RunSummaryJson = {
-    runId: args.runId,
-    // The run-level verdict, first: a consumer gating on this artifact must
-    // not have to re-derive it by re-implementing the bucket rules.
-    ok: exitCode === 0,
-    exitCode,
-    startedAt: new Date(args.startedAtMs).toISOString(),
-    endedAt: new Date(args.endedAtMs).toISOString(),
-    totalMs: args.totalMs,
-    // The summary row's `saved`, by the same rule: hits only, groups aside.
-    savedMs: counted.reduce(
-      (ms, o) => (isCacheHit(o.status) ? ms + (o.storedDurationMs ?? 0) : ms),
-      0,
-    ),
-    tasks: counted.map((o) => taskEntry(o, flakyById.get(o.node.id))),
-    aborted: aborted.map((o) => taskEntry(o)),
-    // The FULL list: `tallyOutcomes` applies the same group/aborted
-    // exclusions internally, so every counted bucket is unchanged by passing
-    // it — but `summary.aborted` is only non-zero if it sees them.
-    summary: tallyOutcomes(args.outcomes),
-  }
-  return payload
-}
+import type { TaskOutcome } from '../graph/index.js'
 
 export interface ProfileArgs {
   target: string

package/src/orchestrator/run-context.ts

@@ -15,6 +15,8 @@ import os from 'node:os'
 import path from 'node:path'
 import { executablePath, gitEnv, relPosix, ulid, xxh3hex } from '../util/index.js'
 import { resolveSetting } from '../settings.js'
+import { VERSION } from '../version.js'
+import type { RunContextRecord } from './telemetry.js'
 
 export interface GitContext {
   /** `git rev-parse HEAD`, or null outside a repo / on failure. */
@@ -522,3 +524,56 @@ export function currentBranch(
   const set = resolveSetting('run.branch', workspace, flag, env).value as string | undefined
   return set ?? captureGitContext(workspaceRoot, null, env).branch
 }
+
+export interface TelemetryRunContextArgs {
+  runId: string
+  /** The invocation, already masked. */
+  command: string
+  requestedTasks: readonly string[]
+  cachePolicy: string
+  concurrency: number
+  flow: RunContextRecord['flow']
+  git: GitContext
+  ci: CiContext
+  host: HostContext
+  workspaceRoot: string
+  /** `remote.origin.url` as the run's enumeration read it; see `captureWorkspaceIdentity`. */
+  originUrl: string | null | undefined
+}
+
+/**
+ * The run-context record telemetry sinks receive: the invocation header's
+ * git/CI/host data shaped as the export contract. Paid only when a sink can
+ * exist: the workspace identity may write `.vx/cache/workspace-id`.
+ */
+export function telemetryRunContext(a: TelemetryRunContextArgs): RunContextRecord {
+  const ws = captureWorkspaceIdentity(a.workspaceRoot, a.originUrl)
+  const { ci } = a
+  return {
+    runId: a.runId,
+    vxVersion: VERSION,
+    command: a.command,
+    requestedTasks: [...a.requestedTasks],
+    cachePolicy: a.cachePolicy,
+    concurrency: a.concurrency,
+    flow: a.flow,
+    commitSha: a.git.commitSha,
+    branch: a.git.branch,
+    defaultBranch: captureDefaultBranch(process.env, a.workspaceRoot),
+    dirty: a.git.dirty,
+    ci: ci.ci,
+    ciProvider: ci.provider,
+    ...(ci.runUrl !== undefined ? { ciRunUrl: ci.runUrl } : {}),
+    ...(ci.change !== undefined ? { ciChange: ci.change } : {}),
+    ...(ci.pipeline !== undefined ? { ciPipeline: ci.pipeline } : {}),
+    ...(ci.job !== undefined ? { ciJob: ci.job } : {}),
+    ...(ci.attempt !== undefined ? { ciAttempt: ci.attempt } : {}),
+    host: a.host.host,
+    os: a.host.os,
+    arch: a.host.arch,
+    workspaceId: ws.id,
+    workspaceName: ws.name,
+    ...(ws.repository !== undefined ? { repository: ws.repository } : {}),
+    ...(ws.path !== undefined ? { workspacePath: ws.path } : {}),
+  }
+}

package/src/orchestrator/run-failures.ts

@@ -8,9 +8,9 @@ import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import path from 'node:path'
 import { isGroupTask, type TaskOutcome } from '../graph/index.js'
 import { decodeOutputLog } from './output-log.js'
-import { PASS_STATUSES } from './history.js'
-import { splitTaskId } from '../util/index.js'
-import { fileLocations, fileMemo, type OutputLocation } from './path-links.js'
+import { PASS_STATUSES } from '../history/index.js'
+import { isFsRefusal, 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
@@ -78,14 +78,26 @@ function failuresOf(outcomes: readonly TaskOutcome[]): StoredFailure[] {
 /**
  * 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
+  try {
+    keep(cacheDir, runId, tasks)
+  } catch (err) {
+    if (!isFsRefusal(err)) throw err
+    warn(`[vx] failed tasks' output not kept: ${err.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`)