@vzn/vx 0.0.638 → 0.0.640

package/src/graph/task-status.ts

@@ -0,0 +1,95 @@
+// A task's terminal status and what each one means: a pass, a hit, where
+// its result came from. One vocabulary every reader (the run verdict, the
+// logger, the history queries, telemetry, plugins) asks, so none re-lists
+// the statuses.
+
+export type TaskStatus =
+  | 'success'
+  | 'cache-hit'
+  | 'cache-hit-remote'
+  | 'failed'
+  | 'skipped'
+  // A child killed by a shutdown signal (SIGINT/SIGTERM — e.g. Ctrl-C):
+  // the task never finished on its own terms, so it reverts to aborted —
+  // excluded from the tally and the run history. It still PROPAGATES like
+  // a failure (see `willSkip`): the child died mid-write, so its outputs
+  // are partial.
+  | 'aborted'
+
+/** Where a task's result came from, derived ONCE in core from the status. */
+export type CacheSource = 'miss' | 'local' | 'remote' | 'none'
+
+/**
+ * Map a task outcome status to its cache source. `success`/`failed` ran
+ * (a miss as far as the cache read is concerned); the two cache-hit
+ * statuses restored from local/remote; `skipped`/`aborted` never engaged
+ * the cache. Pure function — the single place this mapping is decided;
+ * `isCacheHit` below is derived from it rather than re-listing the two
+ * hit statuses, so there is one decision, not two that can disagree.
+ */
+export function deriveCacheSource(status: TaskStatus): CacheSource {
+  switch (status) {
+    case 'cache-hit':
+      return 'local'
+    case 'cache-hit-remote':
+      return 'remote'
+    case 'success':
+    case 'failed':
+      return 'miss'
+    case 'skipped':
+    case 'aborted':
+      return 'none'
+  }
+}
+
+/**
+ * Whether each status counts as a PASS. Written as a `Record<TaskStatus, …>`
+ * rather than a `new Set([...])` on purpose: a Record must name every member,
+ * so adding a status to the union is a COMPILE error HERE and the omission
+ * cannot ship. A Set of string literals has no such tripwire — it silently
+ * answers `false` for the new member, which is how ten hand-rolled copies of
+ * this vocabulary accumulated across core, cloud and the dashboard.
+ */
+const PASSES: Record<TaskStatus, boolean> = {
+  success: true,
+  'cache-hit': true,
+  'cache-hit-remote': true,
+  failed: false,
+  skipped: false,
+  aborted: false,
+}
+
+/**
+ * Every `TaskStatus`, at runtime. Read off `PASSES`'s keys, which the
+ * `Record<TaskStatus, …>` type guarantees is exactly the union — so this is
+ * derived, not a second list that can fall behind. Exported so a consumer that
+ * cannot import the type (a test asserting a copy of this vocabulary in
+ * another package agrees) can still enumerate the real set.
+ */
+export const TASK_STATUSES: readonly TaskStatus[] = Object.keys(PASSES) as TaskStatus[]
+
+/**
+ * Did the task pass? A cache hit counts — it produced the same result without
+ * spending the time, which is the whole point. `skipped` and `aborted` do NOT:
+ * neither finished on its own terms, so neither can vouch for anything.
+ *
+ * Takes `string`, not `TaskStatus`, because most callers hold a status that
+ * arrived over a wire or out of a database column. An unrecognised string
+ * reads as NOT passing — the safe direction, since the alternative is calling
+ * a run green on a status this build has never heard of.
+ */
+export function isPassStatus(status: string): boolean {
+  return PASSES[status as TaskStatus] === true
+}
+
+/**
+ * Did the task's result come out of the cache (either layer)? Derived from
+ * `deriveCacheSource` rather than re-listing the two hit statuses, so the two
+ * cannot disagree about what a hit is. Unknown strings read as not-a-hit.
+ */
+export function isCacheHit(status: string): boolean {
+  // No known-status guard: an unknown string falls through the switch to
+  // undefined, which is neither hit source (the guard survived item 654).
+  const source = deriveCacheSource(status as TaskStatus)
+  return source === 'local' || source === 'remote'
+}

package/src/{orchestrator → history}/failure-mode.ts

@@ -10,7 +10,7 @@
 
 import type { Database } from 'bun:sqlite'
 import { KEYED_RUNS_SQL } from '../cache/index.js'
-import { isCacheHit, TASK_STATUSES } from './telemetry.js'
+import { isCacheHit, TASK_STATUSES } from '../graph/index.js'
 
 // SQL hit set derived from the predicate — never a hand-typed list and never
 // a prefix LIKE (a prefix counts any status merely NAMED cache-hit-*). The

package/src/{orchestrator → history}/history.ts

@@ -16,7 +16,7 @@ import { branchSource, EXECUTED_RUNS_SQL } from '../cache/index.js'
 import { splitTaskId } from '../util/index.js'
 import { failureModeOf, mixedOutcomeKeysSql } from './failure-mode.js'
 import type { FailureMode } from './failure-mode.js'
-import { isPassStatus, TASK_STATUSES } from './telemetry.js'
+import { isPassStatus, TASK_STATUSES } from '../graph/index.js'
 
 const DEFAULT_RECENT = 50
 

package/src/history/index.ts

@@ -0,0 +1,48 @@
+// What runs leave behind, read back: the duration table a schedule learns
+// from, the flakiness verdict, the queries behind `vx last` / `vx why`, and
+// what a miss's key changed. Read-only SQL over the cache's database; it
+// never runs, renders or writes a run.
+export {
+  EmptyHistoryProvider,
+  type HistoryProvider,
+  type HistoryTable,
+  LocalHistoryProvider,
+  PASS_STATUSES,
+  type TaskHistory,
+  type TaskResources,
+} from './history.js'
+export {
+  detectFlaky,
+  type FailureMode,
+  type FlakyCandidate,
+  type FlakyFinding,
+  type FlakyTask,
+  flakyTasks,
+} from './failure-mode.js'
+export {
+  cacheKeyDiff,
+  explainCacheKey,
+  getInvocation,
+  getRun,
+  inputWriters,
+  latestRunId,
+  listInvocations,
+  listRuns,
+  rootCauses,
+  whyDidThisRerun,
+} from './metrics.js'
+export type {
+  CacheEntryRow,
+  CacheKeyDiff,
+  CacheKeyExplanation,
+  InputDiffEntry,
+  InputWriter,
+  InvocationDetail,
+  ListInvocationsArgs,
+  ListRunsArgs,
+  RootCause,
+  RunDetail,
+  RunSummaryRow,
+  WhyDidThisRerun,
+} from './metrics.js'
+export { createMissExplainer, type MissExplainer } from './miss-reason.js'

package/src/{orchestrator → history}/metrics.ts

@@ -15,11 +15,9 @@ import { statSync } from 'node:fs'
 import path from 'node:path'
 // The keyed-run predicate lives beside the schema in cache/cache.ts, so a
 // rule written once cannot drift.
-import { KEYED_RUNS_SQL } from '../cache/index.js'
-import { splitTaskId } from '../graph/index.js'
+import { KEYED_RUNS_SQL, type TaskInputComponent } from '../cache/index.js'
+import { isPassStatus, splitTaskId } from '../graph/index.js'
 import { clampInt, MASKED, secretNamed } from '../util/index.js'
-import type { TaskInputComponent } from './task-hash.js'
-import { isPassStatus } from './telemetry.js'
 
 // A recorded `cache_policy` is the `--cache-policy` spec (`local:rw,remote:r`).
 const readsCache = (spec: string): boolean => /(?:^|,)(?:local|remote):w?r/.test(spec)
@@ -57,6 +55,8 @@ export interface RunSummaryRow {
   notReady: 'timeout' | 'exited' | 'spawn' | null
   /** The task ran with the run's forwarded args (`-- …`): a requested one under a run that had some. */
   forwarded: boolean
+  /** Each remote read or write of its key that failed, `upload: <message>`, `; `-joined (v40). */
+  remoteError: string | null
 }
 
 export interface ListRunsArgs {
@@ -117,7 +117,7 @@ export function listRuns(db: Database, args: ListRunsArgs = {}): RunSummaryRow[]
               wallclock_start_ns AS wallclockStartNs, wallclock_end_ns AS wallclockEndNs,
               blocked_by AS blockedBy, timed_out AS timedOut,
               sandbox_violations AS sandboxViolations, not_ready AS notReady,
-              forward_args IS NOT NULL AS forwarded
+              forward_args IS NOT NULL AS forwarded, remote_error AS remoteError
        FROM runs ${clause} ORDER BY id DESC LIMIT ?`,
     )
     .all(...params, limit) as RawRow[]
@@ -135,8 +135,7 @@ export function listRuns(db: Database, args: ListRunsArgs = {}): RunSummaryRow[]
 
 /**
  * One `vx run` invocation header — every `invocations` column, camelCased,
- * `tags` parsed to a `Record<string,string>` and `dirty`/`ci`/`exitOk`
- * surfaced as booleans. The SPA's
+ * `dirty`/`ci`/`exitOk` surfaced as booleans. The SPA's
  * existing fields (runId / startedAt / endedAt / taskCount / failedCount /
  * hitCount / totalDurationMs) are all present, so existing views keep working.
  */
@@ -170,7 +169,6 @@ export interface InvocationDetail {
   os: string | null
   arch: string | null
   vxVersion: string
-  tags: Record<string, string>
 }
 
 interface InvocationRawRow {
@@ -201,7 +199,6 @@ interface InvocationRawRow {
   os: string | null
   arch: string | null
   vxVersion: string
-  tags: string
 }
 
 const INVOCATION_COLUMNS = `
@@ -214,7 +211,7 @@ const INVOCATION_COLUMNS = `
   restored_remote_count AS restoredRemoteCount,
   exit_ok AS exitOk,
   commit_sha AS commitSha, branch, dirty, ci, ci_provider AS ciProvider,
-  host, os, arch, vx_version AS vxVersion, tags`
+  host, os, arch, vx_version AS vxVersion`
 
 function mapInvocation(r: InvocationRawRow): InvocationDetail {
   let requestedTasks: string[] = []
@@ -222,15 +219,6 @@ function mapInvocation(r: InvocationRawRow): InvocationDetail {
     const parsed = JSON.parse(r.requestedTasks) as unknown
     if (Array.isArray(parsed)) requestedTasks = parsed.map(String)
   } catch {}
-  let tags: Record<string, string> = {}
-  try {
-    const parsed = JSON.parse(r.tags) as unknown
-    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
-      tags = Object.fromEntries(
-        Object.entries(parsed as Record<string, unknown>).map(([k, v]) => [k, String(v)]),
-      )
-    }
-  } catch {}
   return {
     runId: r.runId,
     command: r.command,
@@ -259,7 +247,6 @@ function mapInvocation(r: InvocationRawRow): InvocationDetail {
     os: r.os,
     arch: r.arch,
     vxVersion: r.vxVersion,
-    tags,
   }
 }
 

package/src/{orchestrator → history}/miss-reason.ts

@@ -9,7 +9,7 @@
 import type { Database } from 'bun:sqlite'
 import type { InputChanges } from '../graph/index.js'
 import { diffKeyComponents, loadEntryInputs } from './metrics.js'
-import type { TaskInputComponent } from './task-hash.js'
+import type { TaskInputComponent } from '../cache/index.js'
 
 /** How many changed components a miss names; `count` says how many there were. */
 const NAMED = 10

package/src/index.ts

@@ -37,7 +37,7 @@ export type {
   ExecConfig,
   ExecEnv,
   CacheConfig,
-  CacheInputs,
+  InputsConfig,
   CacheOutputs,
   InputStability,
   SandboxConfig,
@@ -56,13 +56,9 @@ export { run, planRun, prepareRun } from './orchestrator/index.js'
 // The per-task duration history a `schedule` plugin learns from
 // (`@vzn/vx-schedule-history` does; a plugin package reaches core only
 // through this façade, which is what put these here).
-export { currentBranch, LocalHistoryProvider } from './orchestrator/index.js'
-export type {
-  HistoryProvider,
-  HistoryTable,
-  TaskHistory,
-  TaskResources,
-} from './orchestrator/index.js'
+export { currentBranch } from './orchestrator/index.js'
+export { LocalHistoryProvider } from './history/index.js'
+export type { HistoryProvider, HistoryTable, TaskHistory, TaskResources } from './history/index.js'
 export type { PreparedRun } from './orchestrator/index.js'
 // `RunOptions.affected`: what `--affected`'s diff changed, per project.
 export type { AffectedChanges } from './workspace/index.js'
@@ -72,14 +68,8 @@ export type { AffectedChanges } from './workspace/index.js'
 // docs/cli.md § Programmatic API listed all three (item 387, 2026-09-19).
 export type { RunPlan, PlannedTask } from './orchestrator/index.js'
 export type { CiContext, GitContext, HostContext, WorkspaceIdentity } from './orchestrator/index.js'
-export type {
-  CacheFlags,
-  CachePolicy,
-  Logger,
-  OutputView,
-  RunOptions,
-  RunSummary,
-} from './orchestrator/index.js'
+export type { CacheFlags, CachePolicy, RunOptions, RunSummary } from './orchestrator/index.js'
+export type { Logger, OutputView } from './report/index.js'
 // `splitTaskId` is on the façade because the alternative is what happened:
 // with only `taskId()` to JOIN an id and nothing exported to SPLIT one,
 // consumers roll their own `split('#', 2)` and drift from the graph, which
@@ -178,8 +168,8 @@ export type {
   RunReportTask,
   PluginHookName,
   PluginHookHandlers,
-  RunStartInfo,
 } from './orchestrator/index.js'
+export type { RunStartInfo } from './report/index.js'
 // The per-task execution contract a plugin's `executor` capability returns.
 // (`runCommand` / `runSandboxed`, the local executor's own primitives, left
 // the façade 2026-09-10: no executor plugin built on them — `@vzn/vx-reapi`
@@ -211,15 +201,8 @@ export type {
 // consumer rolls its own Set of status literals — and a Set has no
 // compile-time tripwire when the union gains a member, so it silently answers
 // "no" for the new one.
-// `escapeMarkdownCell` is on the façade for the same demonstrated need: a
-// plugin that renders a run as a markdown table takes the same unvalidated
-// task names core does, and the cloud job summary shipped without the escape.
-export {
-  escapeMarkdownCell,
-  TELEMETRY_SCHEMA_VERSION,
-  isCacheHit,
-  isPassStatus,
-} from './orchestrator/index.js'
+export { type CacheSource, isCacheHit, isPassStatus } from './graph/index.js'
+export { TELEMETRY_SCHEMA_VERSION } from './orchestrator/index.js'
 // `TaskLogBuffer` is on the façade on the same demonstrated need: EVERY
 // telemetry sink that ships build output has to bound it, and the retention
 // rules (per-task tail, per-run budget, failures never evicted by successes,
@@ -231,7 +214,6 @@ export { LOG_WIRE_VERSION, TaskLogBuffer } from './orchestrator/index.js'
 // say `128 + SIGKILL`; the decode is the runner's convention, one copy.
 export { exitSignal } from './orchestrator/index.js'
 export type {
-  CacheSource,
   RunContextRecord,
   RunSummaryRecord,
   TaskLogBundle,
@@ -242,5 +224,5 @@ export type {
   TelemetrySink,
 } from './orchestrator/index.js'
 
-// The serializable run result and its per-task views (what `run()` returns).
-export type { RunResult, TaskView, OutcomeView } from './orchestrator/index.js'
+// The serializable per-task views.
+export type { TaskView, OutcomeView } from './report/index.js'

package/src/orchestrator/affected-tasks.ts

@@ -33,7 +33,7 @@ const KEYED_BY_EVERY_TASK: ReadonlySet<string> = new Set(PROJECT_CONFIG_FILENAME
 
 /**
  * The projects every task of which the change reaches: the whole ones the
- * diff named, and those holding a changed path no cached task of theirs
+ * diff named, and those holding a changed path no task of theirs
  * declares as an input. vx cannot prove such a path re-keys nothing (a
  * `project` plugin may read it), so it reaches the whole project, as it did
  * before selection was per task.
@@ -42,15 +42,15 @@ function wholeProjects(
   changes: AffectedChanges,
   projects: ReadonlyMap<string, ProjectEntry>,
 ): Map<string, string | undefined> {
-  // Each whole project, with the path no cached task claims when one did it.
+  // Each whole project, with the path no task claims when one did it.
   const whole = new Map<string, string | undefined>([...changes.whole].map((n) => [n, undefined]))
   for (const [name, rels] of changes.paths) {
     if (whole.has(name)) continue
-    const caches = Object.values(projects.get(name)?.config.tasks ?? {}).flatMap((t) =>
-      t.exec !== undefined && t.cache !== undefined ? [t.cache] : [],
+    const keyed = Object.values(projects.get(name)?.config.tasks ?? {}).filter(
+      (t) => t.exec !== undefined && t.inputs !== undefined,
     )
     const unclaimed = (rel: string): boolean =>
-      KEYED_BY_EVERY_TASK.has(rel) || !caches.some((c) => declaresInput(c, rel, null))
+      KEYED_BY_EVERY_TASK.has(rel) || !keyed.some((t) => declaresInput(t, rel, null))
     const rel = rels.find(unclaimed)
     if (rel !== undefined) whole.set(name, rel)
   }
@@ -60,8 +60,8 @@ function wholeProjects(
 /**
  * Why `--affected` kept a requested task (`vx run --affected --dry`):
  * `input`, a changed `file` is one of its declared inputs; `project`, its
- * project changed and the task reads it whole (an uncached task, a path no
- * cached task declares, or no single `file`: a lockfile claim, a manifest
+ * project changed and the task reads it whole (a task with no inputs, a
+ * path no task declares, or no single `file`: a lockfile claim, a manifest
  * edge, a config import); `workspace`, a workspace-wide `file` (the
  * workspace config, a root file a plugin claims) reached every task of its
  * project; `package`, a `^` edge passes through `project`, a
@@ -86,9 +86,9 @@ export interface AffectedExplain {
 /**
  * The task ids of `ids` whose closure the change reaches, in their order.
  * A group seeds nothing (it runs nothing) unless it is keyed, as the default
- * `build` is; an uncached task seeds when a changed path lies in its project
- * (or the whole project is reached); a cached one when a changed path is one
- * of its declared inputs. A `^name` edge the
+ * `build` is; a task with no inputs seeds when a changed path lies in its
+ * project (or the whole project is reached); one with inputs when a changed
+ * path is one of them. A `^name` edge the
  * graph passes through a package it loaded no config for reaches it as the
  * default `build` would: any change there reaches the task.
  */
@@ -139,14 +139,15 @@ export function affectedRoots(
     return false
   }
   const seeded = (n: TaskNode): boolean => {
-    const cache = n.config.cache
+    const task = n.config
+    const keyed = task.inputs !== undefined
     // Asked of every node, not only the changed projects' (the
     // `workspaceFiles` owners): a `graph` hook may have given the glob.
-    if (cache !== undefined) {
-      const file = changes.changed.find((rel) => declaresInput(cache, null, rel))
+    if (keyed) {
+      const file = changes.changed.find((rel) => declaresInput(task, null, rel))
       const dir =
         file === undefined
-          ? (changes.nested ?? []).find((d) => workspaceFilesReachInto(cache, d))
+          ? (changes.nested ?? []).find((d) => workspaceFilesReachInto(task, d))
           : undefined
       if (file !== undefined || dir !== undefined) {
         seeds?.set(n.id, { kind: 'input', file: (file ?? dir)! })
@@ -155,10 +156,10 @@ export function affectedRoots(
     }
     if (!changes.projects.has(n.projectName)) return false
     const rels = changes.paths.get(n.projectName) ?? []
-    // A group runs nothing; only the default `build` (projects.ts) is keyed.
-    // An uncached task reads its project: a root file another task of it
-    // declares (`workspaceFiles`) is no change there.
-    if (cache === undefined) {
+    // An unkeyed group runs nothing. A task with no inputs may read anything
+    // in its project: a root file another task of it declares
+    // (`workspaceFiles`) is no change there.
+    if (!keyed) {
       const hit = !isGroupTask(n) && (whole.has(n.projectName) || changes.paths.has(n.projectName))
       if (hit) seeds?.set(n.id, inProject(n.projectName, rels[0]))
       return hit
@@ -167,7 +168,7 @@ export function affectedRoots(
       seeds?.set(n.id, inProject(n.projectName, whole.get(n.projectName)))
       return true
     }
-    const rel = rels.find((r) => declaresInput(cache, r, null))
+    const rel = rels.find((r) => declaresInput(task, r, null))
     if (rel === undefined) return false
     if (seeds !== null) seeds.set(n.id, { ...inProject(n.projectName, rel), kind: 'input' })
     return true

package/src/orchestrator/doctor.ts

@@ -30,7 +30,7 @@ import {
   resolveCacheDir,
   resolveStoreRoot,
 } from '../workspace/index.js'
-import { flakyTasks, type FlakyTask } from './failure-mode.js'
+import { flakyTasks, type FlakyTask } from '../history/index.js'
 import type { VxPlugin } from './plugin.js'
 import { discoverProjects, loadProjects, loadWorkspacePlugins, lockReader } from './projects.js'
 import { atPath, envName, resolveSetting, SETTINGS, type SettingSource } from '../settings.js'

package/src/orchestrator/download-policy.ts

@@ -19,7 +19,7 @@ export type DownloadMode = 'eager' | 'deferred' | 'never'
  * The channel this closes is narrow and specific. A dependent's key folds
  * an upstream's KEY, never its output content (pure-input transitive
  * hashing), so deferral cannot move a dependent's key that way. The one
- * real channel is a task whose `cache.inputs` globs can MATCH a producer's
+ * real channel is a task whose `inputs` globs can MATCH a producer's
  * declared outputs on disk: then its key differs by whether the bytes
  * arrived.
  *
@@ -30,7 +30,7 @@ export type DownloadMode = 'eager' | 'deferred' | 'never'
  * `--cache-download=none` with nothing to defer. Comparing the globs' static
  * prefixes answers the question actually being asked, and stays
  * conservative in every direction that matters: a leading wildcard yields
- * `.` and reaches everything, a cacheable task with no declared `files`
+ * `.` and reaches everything, a task with empty `inputs.files`
  * is treated as reading its whole project, and `workspaceFiles` on either
  * side ignores project boundaries — all three force ineligible.
  */
@@ -44,10 +44,10 @@ export function deferralEligibility(nodes: Map<string, TaskNode>): Map<string, s
     if (list) list.push({ taskId: n.id, prefixes, via })
     else readersByProject.set(n.projectName, [{ taskId: n.id, prefixes, via }])
   }
-  // A task with no `cache` block keys on every file in its project, and a
-  // cached task that depends on it folds that key: deferring a producer
-  // there moved both keys with the transfer flag. Only such a task is a
-  // reader — one nothing cached folds keys nothing that lasts.
+  // A task with no `cache` block keys on its inputs, and a cached task that
+  // depends on it folds that key: deferring a producer there moved both
+  // keys with the transfer flag. Only such a task is a reader — one nothing
+  // cached folds keys nothing that lasts.
   const folded = new Set<string>()
   const stack = [...nodes.values()]
     .filter((n) => n.config.cache !== undefined)
@@ -60,14 +60,11 @@ export function deferralEligibility(nodes: Map<string, TaskNode>): Map<string, s
   let workspaceReader: string | undefined
   let runtimeReader: string | undefined
   for (const n of nodes.values()) {
-    const cache = n.config.cache
-    if (cache === undefined) {
-      if (folded.has(n.id) && !isGroupTask(n) && n.config.exec?.persistent === undefined) {
-        addReader(n, ['.'], 'as a task with no cache block that a cached task folds')
-      }
-      continue
-    }
-    if ((cache.inputs?.workspaceFiles?.length ?? 0) > 0) workspaceReader ??= n.id
+    const inputs = n.config.inputs
+    // A task with no inputs has no key to read; an uncached one with inputs
+    // is read only for the cached tasks that fold its key.
+    if (inputs === undefined || (n.config.cache === undefined && !folded.has(n.id))) continue
+    if ((inputs?.workspaceFiles?.length ?? 0) > 0) workspaceReader ??= n.id
     // A `runtime` input is a SHELL COMMAND whose reads are unknowable —
     // the same reason vx refuses to infer inputs by tracing. It can `cat` a
     // producer's output (or path-escape its project to do it), and its
@@ -77,17 +74,14 @@ export function deferralEligibility(nodes: Map<string, TaskNode>): Map<string, s
     // is exactly what such a command would sample. Nothing defers in a run
     // that declares one — worse than nothing would be a key that moves with
     // a transfer flag.
-    if (
-      (cache.inputs?.runtime?.length ?? 0) > 0 ||
-      (cache.inputs?.workspaceRuntime?.length ?? 0) > 0
-    ) {
+    if ((inputs?.runtime?.length ?? 0) > 0 || (inputs?.workspaceRuntime?.length ?? 0) > 0) {
       runtimeReader ??= n.id
     }
-    const files = cache.inputs?.files
+    const files = inputs?.files
     addReader(
       n,
       files === undefined || files.length === 0 ? ['.'] : files.map(staticPrefix),
-      'with cache.inputs.files',
+      'with inputs.files',
     )
   }
 
@@ -105,14 +99,14 @@ export function deferralEligibility(nodes: Map<string, TaskNode>): Map<string, s
     if (runtimeReader !== undefined) {
       ineligible.set(
         n.id,
-        `${runtimeReader} declares a cache.inputs.runtime command, whose reads cannot be bounded`,
+        `${runtimeReader} declares a inputs.runtime command, whose reads cannot be bounded`,
       )
       continue
     }
     if (workspaceReader !== undefined) {
       ineligible.set(
         n.id,
-        `${workspaceReader} declares cache.inputs.workspaceFiles, which can read any project`,
+        `${workspaceReader} declares inputs.workspaceFiles, which can read any project`,
       )
       continue
     }

package/src/orchestrator/excluded-keys.ts

@@ -14,9 +14,9 @@
 // full run looks up.
 
 import type { CacheLayer, GitFilesCache } from '../cache/index.js'
-import { isGroupTask, type TaskNode, type TaskOutcome } from '../graph/index.js'
+import { isGroupTask, keyedDeps, type TaskNode, type TaskOutcome } from '../graph/index.js'
 import { computeGroupKey, computeTaskHash, type HashCache } from './task-hash.js'
-import { filterUpstreamHashes, keyedDeps, keyedOutcome } from './upstream.js'
+import { filterUpstreamHashes, keyedOutcome } from './upstream.js'
 
 export interface KeyExcludedArgs {
   /** The scheduled graph, after `excludeDependencies`. */
@@ -124,7 +124,7 @@ export function excludedTaint(nodes: ReadonlyMap<string, TaskNode>): {
 
 /**
  * Whether `node`'s key folds a dropped dependency's key: a group folds all
- * of its dependencies, an exec task what its `cache.inputs.tasks` selects.
+ * of its dependencies, an exec task what its `inputs.tasks` selects.
  * A task with `tasks: []` folds none, so its entry claims nothing about a
  * dependency and it saves as usual.
  */
@@ -133,7 +133,6 @@ function foldsExcludedKey(node: TaskNode): boolean {
   if (excluded === undefined) return false
   if (isGroupTask(node)) return true
   return (
-    filterUpstreamHashes(excluded, node.config.cache?.inputs?.tasks, node.projectName, node.id)
-      .length > 0
+    filterUpstreamHashes(excluded, node.config.inputs?.tasks, node.projectName, node.id).length > 0
   )
 }

package/src/orchestrator/execute-args.ts

@@ -0,0 +1,80 @@
+// What a dispatch hands executeTask: the run's half, built once, and the
+// task's half, looked up per dispatch. The run's half is one fixed-shape
+// object every task spreads; the task's optional fields are assigned only
+// when present: twelve conditional spreads per task cost ~18 ms of object
+// copying on a 1,090-package warm run (X-149).
+
+import type { TaskNode, TaskOutcome } from '../graph/index.js'
+import type { Logger } from '../report/index.js'
+import type { DownloadMode } from './download-policy.js'
+import type { ExecuteArgs } from './execute-task.js'
+import type { ShortCircuit } from './local-shortcircuit.js'
+import { UNPLACED_EXECUTOR, type Placements } from './placement.js'
+
+type TaskField =
+  | 'node'
+  | 'upstream'
+  | 'log'
+  | 'executor'
+  | 'nestedProjectDirs'
+  | 'remoteOnlyNoop'
+  | 'remoteOnly'
+  | 'download'
+  | 'preProbed'
+  | 'upfrontKey'
+  | 'upfrontGroupKey'
+  | 'taintedUpstream'
+  | 'noDependants'
+  | 'terminal'
+
+/** What every task of a run shares; an absent optional stays absent. */
+export type RunScope = Omit<ExecuteArgs, TaskField>
+
+/** Where the task's half is read from, per task id. */
+export interface TaskFacts {
+  log: (node: TaskNode) => Logger
+  placements: Placements
+  nestedDirsByProject: ReadonlyMap<string, string[]>
+  downloadModeOf: ReadonlyMap<string, DownloadMode>
+  shortCircuit: Pick<ShortCircuit, 'preProbed' | 'uncachedKeys' | 'groupKeys'>
+  /** Tasks some other task depends on. */
+  dependedOn: ReadonlySet<string>
+  /** Tasks that hold the terminal (`terminalHolders`). */
+  holders: ReadonlySet<string>
+}
+
+/**
+ * The dispatch builder. `reuseProbe: false` takes the task's key again
+ * instead of the up-front probe (admission's retry after a dropped probe);
+ * `tainted` is the run's taint verdict for this dispatch.
+ */
+export function executeArgsOf(
+  scope: RunScope,
+  facts: TaskFacts,
+): (node: TaskNode, upstream: TaskOutcome[], reuseProbe: boolean, tainted: boolean) => ExecuteArgs {
+  const { placements, shortCircuit } = facts
+  return (node, upstream, reuseProbe, tainted) => {
+    const id = node.id
+    const a: ExecuteArgs = {
+      ...scope,
+      node,
+      upstream,
+      log: facts.log(node),
+      executor: placements.executors.get(id) ?? UNPLACED_EXECUTOR,
+      nestedProjectDirs: facts.nestedDirsByProject.get(node.projectName) ?? [],
+    }
+    const probe = reuseProbe ? shortCircuit.preProbed.get(id) : undefined
+    const upfrontKey = shortCircuit.uncachedKeys.get(id)
+    const upfrontGroupKey = shortCircuit.groupKeys.get(id)
+    if (facts.downloadModeOf.get(id) === 'deferred') a.download = 'deferred'
+    if (placements.remoteOnlyNoop.has(id)) a.remoteOnlyNoop = true
+    if (placements.remoteOnly.has(id)) a.remoteOnly = true
+    if (probe !== undefined) a.preProbed = probe
+    if (upfrontKey !== undefined) a.upfrontKey = upfrontKey
+    if (upfrontGroupKey !== undefined) a.upfrontGroupKey = upfrontGroupKey
+    if (tainted) a.taintedUpstream = true
+    if (!facts.dependedOn.has(id)) a.noDependants = true
+    if (facts.holders.has(id)) a.terminal = true
+    return a
+  }
+}