@vzn/vx 0.0.16 → 0.0.21

package/src/orchestrator/predict.ts

@@ -1,106 +0,0 @@
-// Predictive scheduling — use HistoryTable to compute expected
-// remaining critical-path duration per node. Replaces the scheduler's
-// graph-counter heuristic priority for runs that opt in via
-// defineWorkspace({ predictive: true }) (predictive-execution-2026-06.md
-// Phase B + architecture-review-2026-06.md §8.4).
-//
-// Pure functions; no side effects; tested standalone. The scheduler
-// reads the priorities at queue time, picks the max.
-
-import type { TaskNode } from '../graph/index.js'
-import type { HistoryTable } from './history.js'
-
-/** Default duration when neither task history nor workspace median exists. */
-const DEFAULT_DURATION_MS = 1000
-
-/**
- * For each node, the expected remaining critical-path duration (its own
- * p50 + the max over its dependents). Cache hits are NOT modeled as
- * zero-cost here because predicting cache state requires knowing the
- * key + probing the layer — the run-time scheduler can flip the
- * priority once a hit is observed; the upfront estimate is "what if
- * everything ran."
- */
-export function computePredictedPriorities(
-  nodes: readonly TaskNode[],
-  history: HistoryTable,
-): ReadonlyMap<string, number> {
-  // Workspace-median fallback: across every history entry that has a
-  // p50, pick the median of those p50s. If history is sparse, fall
-  // back to DEFAULT_DURATION_MS.
-  const p50s: number[] = []
-  for (const h of history.values()) {
-    if (h.p50DurationMs !== undefined) p50s.push(h.p50DurationMs)
-  }
-  p50s.sort((a, b) => a - b)
-  const workspaceMedian =
-    p50s.length > 0
-      ? (p50s[Math.floor(p50s.length / 2)] ?? DEFAULT_DURATION_MS)
-      : DEFAULT_DURATION_MS
-
-  // Build a reverse-adjacency map so we can resolve dependents per
-  // node in O(1). The TaskNode graph carries dependsOn (upstream); we
-  // invert.
-  const dependentsOf = buildDependentsIndex(nodes)
-  const ownDuration = (n: TaskNode): number => {
-    const h = history.get(n.id)
-    return h?.p50DurationMs ?? workspaceMedian
-  }
-
-  // Memoized topo-DP. visit[id] = the expected critical path FROM this
-  // node down to a leaf. We compute bottom-up using a stack-based
-  // walker — iterative to avoid V8 stack-frame ceilings on deep graphs.
-  const memo = new Map<string, number>()
-  const nodeById = new Map<string, TaskNode>(nodes.map((n) => [n.id, n]))
-
-  const stack: TaskNode[] = nodes.slice()
-  // First pass: ensure deepest-first ordering via post-order traversal.
-  const order: TaskNode[] = []
-  const visited = new Set<string>()
-  while (stack.length > 0) {
-    const top = stack[stack.length - 1]!
-    if (visited.has(top.id)) {
-      stack.pop()
-      continue
-    }
-    const deps = dependentsOf.get(top.id) ?? []
-    let pushed = false
-    for (const d of deps) {
-      const n = nodeById.get(d)
-      if (n && !visited.has(n.id) && !stack.includes(n)) {
-        stack.push(n)
-        pushed = true
-        break
-      }
-    }
-    if (!pushed) {
-      visited.add(top.id)
-      order.push(top)
-      stack.pop()
-    }
-  }
-
-  for (const n of order) {
-    const own = ownDuration(n)
-    let downstream = 0
-    for (const dep of dependentsOf.get(n.id) ?? []) {
-      const d = memo.get(dep) ?? 0
-      if (d > downstream) downstream = d
-    }
-    memo.set(n.id, own + downstream)
-  }
-
-  return memo
-}
-
-function buildDependentsIndex(nodes: readonly TaskNode[]): Map<string, string[]> {
-  const out = new Map<string, string[]>()
-  for (const n of nodes) {
-    for (const upstreamId of n.deps) {
-      const list = out.get(upstreamId)
-      if (list) list.push(n.id)
-      else out.set(upstreamId, [n.id])
-    }
-  }
-  return out
-}

package/src/orchestrator/protocol.ts

@@ -1,156 +0,0 @@
-// The client↔service wire contract. A `vx run` client submits a
-// `RunRequest`; the service streams `WireEvent`s and returns a
-// `RunResult`. Transport-agnostic by design — the same messages travel a
-// local unix/ws hop today or a hosted `wss://` link tomorrow. Pure types +
-// the RunOptions⇄RunRequest mapping; no transport, no execution here.
-
-import type { CachePolicy } from '../cache/index.js'
-import type { ContinueMode } from '../graph/index.js'
-import type { OutcomeView, WireEvent } from './events.js'
-import type { RunOptions } from './options.js'
-
-/**
- * The serializable subset of `RunOptions` a client sends to the service.
- * Omits the non-serializable / host-side fields (`log`, `bus`,
- * `handleSignals`) — those are the service's concern.
- */
-export interface RunRequest {
-  tasks: readonly string[]
-  cwd: string
-  projects?: readonly string[]
-  concurrency?: number
-  cache?: CachePolicy
-  /** `--cache-dir <path>` override (cwd-relative). */
-  cacheDir?: string
-  continueMode?: ContinueMode
-  frozen?: boolean
-  /** Run-level retry default (`--retry <n>`); explicit `exec.retries` wins. */
-  retries?: number
-  /** Run-level task-timeout default (ms); per-task `exec.timeout` wins. */
-  timeout?: number
-  /** Explicit `--memory` budget (bytes) for `exec.resources` packing; the
-   *  default (executing side's os.totalmem()) resolves where tasks run. */
-  memory?: number
-  /** Cache-correctness verification (`--verify`); `allow` as an array (Sets
-   *  don't serialize). `fingerprint` is additive-optional — an old serve
-   *  ignores it, so a delegated `=fingerprint` run against an old serve
-   *  degrades to a harmless no-op verify. */
-  verify?: {
-    determinism: boolean
-    inputs: boolean
-    fingerprint?: boolean
-    allow: readonly string[]
-  }
-  flow?: 'focused' | 'broad'
-  outputLogs?: 'full' | 'errors-only' | 'none'
-  excludeDependencies?: 'all' | readonly string[]
-  forwardArgs?: readonly string[]
-  summarize?: string
-  profile?: string
-  /** Free-form key/value labels from `--tag`, persisted on the invocation row. */
-  tags?: Record<string, string>
-  /** The raw `vx run …` command string, recorded on the invocation row. */
-  command?: string
-}
-
-export interface RunResult {
-  ok: boolean
-  outcomes: OutcomeView[]
-}
-
-/**
- * Where a `vx run` executes. The client submits a serializable
- * `RunRequest` and gets back a `RunResult`; it neither knows nor cares
- * whether the work happened in-process or was delegated to a service.
- * This is the currency of the `backend` plugin capability — part of the
- * public wire contract (it lives here, not in `cli`, so a plugin can
- * reference it without a `cli` import).
- */
-export interface RunBackend {
-  run(request: RunRequest): Promise<RunResult>
-}
-
-/**
- * service → client. The submitter contract: an event stream, a final
- * result, or an error. The distributed-execution variants
- * (`task:assign`/`agent:refused`/`coord:drain`) live in a distribution
- * plugin's protocol module — its WS handler unions this with those.
- */
-export type ServerMessage =
-  | { t: 'event'; event: WireEvent }
-  | { t: 'result'; result: RunResult }
-  | { t: 'error'; message: string }
-
-/**
- * client → service. The submitter contract: a run submission. The
- * agent-side `agent:*` family lives in a distribution plugin's protocol
- * module.
- */
-export type ClientMessage = { t: 'run'; request: RunRequest }
-
-/** Project resolved `RunOptions` down to the serializable request. */
-export function optionsToRequest(options: RunOptions): RunRequest {
-  const req: RunRequest = { tasks: options.tasks, cwd: options.cwd }
-  if (options.projects !== undefined) req.projects = options.projects
-  if (options.concurrency !== undefined) req.concurrency = options.concurrency
-  if (options.cache !== undefined) req.cache = options.cache
-  if (options.cacheDir !== undefined) req.cacheDir = options.cacheDir
-  if (options.continueMode !== undefined) req.continueMode = options.continueMode
-  if (options.frozen !== undefined) req.frozen = options.frozen
-  if (options.retries !== undefined) req.retries = options.retries
-  if (options.timeout !== undefined) req.timeout = options.timeout
-  if (options.memory !== undefined) req.memory = options.memory
-  if (options.verify !== undefined)
-    req.verify = {
-      determinism: options.verify.determinism,
-      inputs: options.verify.inputs,
-      fingerprint: options.verify.fingerprint,
-      allow: [...options.verify.allow],
-    }
-  if (options.flow !== undefined) req.flow = options.flow
-  if (options.outputLogs !== undefined) req.outputLogs = options.outputLogs
-  if (options.excludeDependencies !== undefined)
-    req.excludeDependencies = options.excludeDependencies
-  if (options.forwardArgs !== undefined) req.forwardArgs = options.forwardArgs
-  if (options.summarize !== undefined) req.summarize = options.summarize
-  if (options.profile !== undefined) req.profile = options.profile
-  if (options.tags !== undefined) req.tags = options.tags
-  if (options.command !== undefined) req.command = options.command
-  return req
-}
-
-/**
- * Rebuild `RunOptions` from a request, for the side that actually executes
- * (the local backend, or the service). The caller adds the host-side
- * fields it needs (`bus`, `log`, `handleSignals`).
- */
-export function requestToOptions(request: RunRequest): RunOptions {
-  const options: RunOptions = { cwd: request.cwd, tasks: [...request.tasks] }
-  if (request.projects !== undefined) options.projects = [...request.projects]
-  if (request.concurrency !== undefined) options.concurrency = request.concurrency
-  if (request.cache !== undefined) options.cache = request.cache
-  if (request.cacheDir !== undefined) options.cacheDir = request.cacheDir
-  if (request.continueMode !== undefined) options.continueMode = request.continueMode
-  if (request.frozen !== undefined) options.frozen = request.frozen
-  if (request.retries !== undefined) options.retries = request.retries
-  if (request.timeout !== undefined) options.timeout = request.timeout
-  if (request.memory !== undefined) options.memory = request.memory
-  if (request.verify !== undefined)
-    options.verify = {
-      determinism: request.verify.determinism,
-      inputs: request.verify.inputs,
-      fingerprint: request.verify.fingerprint ?? false,
-      allow: new Set(request.verify.allow),
-    }
-  if (request.flow !== undefined) options.flow = request.flow
-  if (request.outputLogs !== undefined) options.outputLogs = request.outputLogs
-  if (request.excludeDependencies !== undefined) {
-    options.excludeDependencies = request.excludeDependencies
-  }
-  if (request.forwardArgs !== undefined) options.forwardArgs = request.forwardArgs
-  if (request.summarize !== undefined) options.summarize = request.summarize
-  if (request.profile !== undefined) options.profile = request.profile
-  if (request.tags !== undefined) options.tags = request.tags
-  if (request.command !== undefined) options.command = request.command
-  return options
-}

package/src/orchestrator/resources.ts

@@ -1,59 +0,0 @@
-// Resolve `exec.resources` declarations into absolute per-task costs the
-// scheduler's 2-D admission gate packs against. Pure and budget-
-// parameterized — percent forms resolve here, ONCE per run, so the
-// scheduler's inner loop only ever does a Map.get. The loader has already
-// validated every form (this module trusts internal code); an
-// unparseable value can't reach it from a real config.
-
-import type { ResourceCost, TaskNode } from '../graph/index.js'
-import { parseSize } from '../util/index.js'
-
-const PERCENT_RE = /^(\d+(?:\.\d+)?)%$/
-
-/**
- * `cpus` → CPU units. A number is itself (fractional ok); `"<n>%"` is
- * percent of the CPU budget, kept fractional (rounding is display-only).
- * Absent → 0 = reserve nothing.
- */
-export function resolveCpu(v: number | string | undefined, cpuBudget: number): number {
-  if (v === undefined) return 0
-  if (typeof v === 'number') return v
-  const m = v.match(PERCENT_RE)
-  if (m) return (Number(m[1]) / 100) * cpuBudget
-  return 0
-}
-
-/**
- * `memory` → bytes. A number is bytes; a size string goes through
- * `parseSize` (`"2GB"`, `"512MB"`); `"<n>%"` is percent of the memory
- * budget. Absent → 0 = reserve nothing.
- */
-export function resolveMem(v: number | string | undefined, memBudget: number): number {
-  if (v === undefined) return 0
-  if (typeof v === 'number') return v
-  const m = v.match(PERCENT_RE)
-  if (m) return (Number(m[1]) / 100) * memBudget
-  return parseSize(v) ?? 0
-}
-
-/**
- * Resolve the whole graph's declared reservations, OMITTING zero-cost
- * tasks: an empty map means "no reservations declared", the single gate
- * the scheduler (and run.ts's option threading) keys off to keep every
- * current run byte-identical.
- */
-export function resolveResourceCosts(
-  nodes: ReadonlyMap<string, TaskNode>,
-  cpuBudget: number,
-  memBudget: number,
-): Map<string, ResourceCost> {
-  const out = new Map<string, ResourceCost>()
-  for (const node of nodes.values()) {
-    const declared = node.config.exec?.resources
-    if (declared === undefined) continue
-    const cpu = resolveCpu(declared.cpus, cpuBudget)
-    const mem = resolveMem(declared.memory, memBudget)
-    if (cpu > 0 || mem > 0) out.set(node.id, { cpu, mem })
-  }
-  return out
-}

package/src/orchestrator/run-state.ts

@@ -1,145 +0,0 @@
-// The derived run aggregate — the single view-model every surface holds.
-// Raw RunEvents are the source of truth; this reduces them into the same
-// counters/per-task status the terminal summary already renders, so a
-// web/TUI/MCP surface can render reactively from one place instead of
-// re-deriving. A devframe shared-state holds a RunState and re-reduces on
-// each event; the terminal keeps its own inline counters (byte-identical,
-// untouched). See docs/design/event-stream-2026-06.md.
-
-import { isGroupTask, type TaskStatus } from '../graph/index.js'
-import type { RunEvent } from './events.js'
-
-/** Per-task lifecycle as seen by a surface. */
-export type TaskState = 'running' | TaskStatus
-
-export interface TaskRecord {
-  id: string
-  state: TaskState
-  /** Final duration once complete; absent while running. */
-  durationMs?: number
-  /** True for a persistent task left running after its outcome landed. */
-  persistent?: boolean
-}
-
-/** Cache-miss duration spread — the same numbers the final summary shows. */
-export interface Spread {
-  maxMs: number
-  minMs: number
-  sumMs: number
-  count: number
-}
-
-export interface RunState {
-  total: number
-  done: number
-  failed: number
-  succeeded: number
-  upToDate: number
-  restoredLocal: number
-  restoredRemote: number
-  skipped: number
-  /** Ids currently executing (a worker holds them). */
-  running: string[]
-  /** Per-task records, keyed by id. Group tasks are excluded (no work). */
-  tasks: Record<string, TaskRecord>
-  spread: Spread | null
-}
-
-export function initRunState(total = 0): RunState {
-  return {
-    total,
-    done: 0,
-    failed: 0,
-    succeeded: 0,
-    upToDate: 0,
-    restoredLocal: 0,
-    restoredRemote: 0,
-    skipped: 0,
-    running: [],
-    tasks: {},
-    spread: null,
-  }
-}
-
-/**
- * Fold one event into the aggregate, returning a NEW state (pure — never
- * mutates `prev`, so it's safe to feed a devframe `sharedState.mutate`
- * that diffs old vs new). Mirrors `defaultLogger`'s inline bookkeeping:
- * group tasks (no exec) are ignored, an `aborted` task reverts to pending
- * (freed, never counted), and the spread tracks success+failed only.
- */
-export function reduce(prev: RunState, event: RunEvent): RunState {
-  switch (event.kind) {
-    case 'run:start':
-      return initRunState(event.info.total)
-
-    case 'task:start': {
-      if (isGroupTask(event.node)) return prev
-      const id = event.node.id
-      return {
-        ...prev,
-        running: [...prev.running, id],
-        tasks: { ...prev.tasks, [id]: { id, state: 'running' } },
-      }
-    }
-
-    case 'task:complete': {
-      if (isGroupTask(event.node)) return prev
-      const id = event.node.id
-      const { status, durationMs } = event.outcome
-      const running = prev.running.filter((r) => r !== id)
-
-      // Aborted (killed by a shutdown signal): free the slot, count
-      // nothing, drop the record — the run is tearing down.
-      if (status === 'aborted') {
-        const tasks = { ...prev.tasks }
-        delete tasks[id]
-        return { ...prev, running, tasks }
-      }
-
-      const persistent = event.node.config.exec?.persistent !== undefined && status === 'success'
-      const next: RunState = {
-        ...prev,
-        done: prev.done + 1,
-        running,
-        tasks: {
-          ...prev.tasks,
-          [id]: { id, state: status, durationMs, ...(persistent ? { persistent: true } : {}) },
-        },
-      }
-      switch (status) {
-        case 'success':
-          next.succeeded = prev.succeeded + 1
-          break
-        case 'cache-hit':
-          if (event.outcome.restored === false) next.upToDate = prev.upToDate + 1
-          else next.restoredLocal = prev.restoredLocal + 1
-          break
-        case 'cache-hit-remote':
-          if (event.outcome.restored === false) next.upToDate = prev.upToDate + 1
-          else next.restoredRemote = prev.restoredRemote + 1
-          break
-        case 'failed':
-          next.failed = prev.failed + 1
-          break
-        case 'skipped':
-          next.skipped = prev.skipped + 1
-          break
-      }
-      if (status === 'success' || status === 'failed') {
-        const s = prev.spread
-        next.spread = {
-          maxMs: Math.max(s?.maxMs ?? 0, durationMs),
-          minMs: Math.min(s?.minMs ?? Infinity, durationMs),
-          sumMs: (s?.sumMs ?? 0) + durationMs,
-          count: (s?.count ?? 0) + 1,
-        }
-      }
-      return next
-    }
-
-    // stdout/stderr/status/end carry no aggregate signal.
-    default:
-      return prev
-  }
-}

package/src/orchestrator/verify.ts

@@ -1,164 +0,0 @@
-// Cache-correctness verification (Phase 1: determinism). Pure helpers for the
-// `vx run --verify` hook in execute-task.ts: content-fingerprint a task's
-// output tree (mtime-independent) and diff two runs' trees, so a task whose
-// outputs are NOT a pure function of its declared inputs — a non-hermetic task
-// whose cache entry would replay arbitrary past bytes — is caught and named.
-// See docs/design/cache-correctness-2026-07.md.
-
-import path from 'node:path'
-import type { OutputFingerprint, TaskOutcome, VerifyVerdict } from '../graph/index.js'
-import { xxh3hex } from '../util/index.js'
-
-/** An output file to fingerprint: absolute path + a stable, run-independent
- *  key (project-relative, or `workspace-outputs/<rel-to-root>` for workspace
- *  outputs — matching the cache artifact's namespace so the two never collide). */
-export interface OutputRef {
-  abs: string
-  key: string
-}
-
-/** Build the fingerprint key set from a task's resolved output paths. */
-export function outputRefs(
-  projectDir: string,
-  outputFiles: readonly string[],
-  workspaceRoot: string,
-  workspaceOutputFiles: readonly string[],
-): OutputRef[] {
-  const rel = (from: string, abs: string): string =>
-    path.relative(from, abs).split(path.sep).join('/')
-  return [
-    ...outputFiles.map((abs) => ({ abs, key: rel(projectDir, abs) })),
-    ...workspaceOutputFiles.map((abs) => ({
-      abs,
-      key: `workspace-outputs/${rel(workspaceRoot, abs)}`,
-    })),
-  ]
-}
-
-/** Content-fingerprint an output tree: key → xxh3 of the file's BYTES, read
- *  unconditionally from disk. Deliberately NOT `Cache.hashFile`: its
- *  mtime+size memo would return attempt 1's digest for a re-run output with
- *  equal size and mtime (e.g. a build that normalizes mtimes — standard
- *  reproducible-build practice), silently proving a divergent task
- *  deterministic. fp1/fp2 are only ever compared to each other, so any
- *  content hash works — and the proof must not trust a cache. */
-export async function hashOutputTree(refs: readonly OutputRef[]): Promise<Map<string, string>> {
-  const out = new Map<string, string>()
-  for (const r of refs) {
-    out.set(r.key, xxh3hex(new Uint8Array(await Bun.file(r.abs).arrayBuffer())))
-  }
-  return out
-}
-
-/** Per-file map cap on a shipped fingerprint (~40 KB at the cap). The tree
- *  digest always folds ALL entries, so detection never depends on the map. */
-export const FP_MAX_FILES = 500
-
-/** Roll an output-tree fingerprint map into the shippable `OutputFingerprint`
- *  payload (Phase 4, cross-machine diff): a tree digest over ALL sorted
- *  entries folded `key\0hash\n` (\0 boundaries so parts can't alias), plus
- *  the first-`cap` pairs — deterministic truncation, so two machines'
- *  truncated maps cover the same key subset and stay diffable. */
-export function foldFingerprint(fp: Map<string, string>, cap = FP_MAX_FILES): OutputFingerprint {
-  const keys = [...fp.keys()].sort()
-  let folded = ''
-  for (const k of keys) folded += `${k}\0${fp.get(k)!}\n`
-  return {
-    tree: xxh3hex(folded),
-    fileCount: keys.length,
-    files: keys.slice(0, cap).map((k) => [k, fp.get(k)!] as const),
-    ...(keys.length > cap ? { truncated: true } : {}),
-  }
-}
-
-/** The output keys whose content OID differs between two fingerprints
- *  (added, removed, or changed), sorted. */
-export function diffOutputTrees(a: Map<string, string>, b: Map<string, string>): string[] {
-  const changed: string[] = []
-  for (const k of new Set([...a.keys(), ...b.keys()])) {
-    if (a.get(k) !== b.get(k)) changed.push(k)
-  }
-  return changed.sort()
-}
-
-/** Turn a determinism diff into a verdict, honoring the `--verify-allow`
- *  escape hatch (an allowed divergence is reported but never fails the run). */
-export function classifyDeterminism(changed: readonly string[], allowed: boolean): VerifyVerdict {
-  if (changed.length === 0) return { kind: 'proven-deterministic' }
-  return allowed
-    ? { kind: 'allowed-nondeterministic', changed }
-    : { kind: 'nondeterministic', changed }
-}
-
-/** Extract the workspace-relative paths a task read outside its declared inputs
- *  (Phase 2, `--verify=inputs`). A strace-derived violation line carries the
- *  offending absolute path in trailing brackets (`… [/abs/path]`); pull it out,
- *  make it workspace-relative, dedup, and sort. Lines without a bracketed path
- *  (e.g. macOS syscall lines) fall back to the raw line so nothing is lost. */
-export function undeclaredInputPaths(
-  violations: readonly { line: string }[],
-  workspaceRoot: string,
-): string[] {
-  const rels = new Set<string>()
-  for (const v of violations) {
-    const m = /\[([^\]]+)\]\s*$/.exec(v.line)
-    const raw = m ? m[1]! : v.line
-    rels.add(
-      path.isAbsolute(raw) ? path.relative(workspaceRoot, raw).split(path.sep).join('/') : raw,
-    )
-  }
-  return [...rels].sort()
-}
-
-/** The end-of-run `--verify` summary section: a counts line plus a
- *  failures block naming each non-hermetic task and its diverging outputs.
- *  Empty when no task carried a verdict. */
-export function formatVerifySection(outcomes: readonly TaskOutcome[]): string[] {
-  const verdicts = outcomes.filter((o) => o.verify !== undefined)
-  if (verdicts.length === 0) return []
-  let proven = 0
-  let bad = 0
-  let na = 0
-  let notVerified = 0
-  for (const o of verdicts) {
-    switch (o.verify!.kind) {
-      case 'proven-deterministic':
-      case 'proven-complete':
-        proven++
-        break
-      case 'nondeterministic':
-      case 'rerun-failed':
-      case 'undeclared-inputs':
-        bad++
-        break
-      case 'allowed-nondeterministic':
-      case 'no-outputs':
-        na++
-        break
-      case 'not-verified':
-        notVerified++
-        break
-    }
-  }
-  const lines = [
-    '',
-    `  Verify:   ${proven} proven · ${bad} unsafe · ${na} n/a · ${notVerified} not-verified`,
-  ]
-  for (const o of outcomes) {
-    const v = o.verify
-    if (v === undefined) continue
-    if (v.kind === 'nondeterministic') {
-      lines.push(`    ✗ ${o.node.id} — nondeterministic`)
-      lines.push(`        changed: ${v.changed.join(', ')}`)
-    } else if (v.kind === 'undeclared-inputs') {
-      lines.push(`    ✗ ${o.node.id} — read undeclared inputs`)
-      if (v.paths.length > 0) lines.push(`        ${v.paths.join(', ')}`)
-      lines.push('        add them to cache.inputs.files / workspaceFiles')
-    } else if (v.kind === 'rerun-failed') {
-      lines.push(`    ✗ ${o.node.id} — verify re-run failed (exit ${v.exitCode})`)
-    } else if (v.kind === 'allowed-nondeterministic') {
-      lines.push(`    ⚠ ${o.node.id} — nondeterministic (allowed)`)
-    }
-  }
-  return lines
-}