@vzn/vx 0.0.16 → 0.0.21

package/src/orchestrator/status-line.ts

@@ -19,6 +19,12 @@ const CLEAR = '\x1b[2K\r'
 export interface StatusStream {
   write(chunk: string): unknown
   isTTY?: boolean
+  /**
+   * Terminal width in columns. Read fresh on every draw — `process.stdout`
+   * updates it on SIGWINCH, so a mid-run resize is picked up. Absent (not a
+   * TTY) means the region is never drawn anyway.
+   */
+  columns?: number
 }
 
 export interface OutputWriter {
@@ -68,7 +74,9 @@ export function createOutputWriter(
 
   let current: readonly string[] | null = null
   let shown = false
-  let shownHeight = 0
+  // PHYSICAL rows the shown region occupies, not logical lines — see
+  // `regionRows`.
+  let shownRows = 0
   let dead = false
   let lastDraw = -Infinity
   // Trailing draw scheduled when a forced set lands inside the floor.
@@ -85,10 +93,41 @@ export function createOutputWriter(
     }
   }
 
-  // Erase sequence for whatever is currently shown. Single line keeps
-  // the exact legacy bytes (ESC[2K\r); a taller region moves to its
-  // top line and clears to end of screen.
-  const eraseSeq = (): string => (shownHeight > 1 ? `\r\x1b[${shownHeight - 1}A\x1b[J` : CLEAR)
+  /**
+   * How many PHYSICAL terminal rows `lines` occupies. The terminal wraps
+   * any line wider than the viewport, so a region of N logical lines can
+   * cover more than N rows — and erasing by the logical count moves the
+   * cursor up too few rows, leaving the top of the region on screen. It
+   * accumulates, because every redraw is short by the same amount.
+   *
+   * Both triggers are ordinary: the summary section is a fixed 62 visible
+   * columns (narrower terminal ⇒ every bar row wraps), and a task id is
+   * deliberately never truncated (long id ⇒ the worker row wraps at any
+   * width). Width is read per draw so a mid-run resize is handled. Width
+   * must be VISIBLE width — these lines carry ANSI, which occupies no
+   * column.
+   *
+   * Unknown width falls back to the logical count, which is a KNOWN
+   * residual rather than a guarantee: a wrapped line then under-erases
+   * exactly as it did before this function existed. It is deliberate,
+   * because the alternatives are worse — guessing a width over-erases on a
+   * wider terminal, and `ESC[J` clears to end of SCREEN, so over-erasing
+   * destroys output above the region instead of merely leaving junk below
+   * it. Reachable only on a TTY whose winsize ioctl fails, since a non-TTY
+   * disables the region outright.
+   */
+  const regionRows = (lines: readonly string[]): number => {
+    const cols = stream.columns
+    if (cols === undefined || cols <= 0) return lines.length
+    let rows = 0
+    for (const line of lines) rows += Math.max(1, Math.ceil(Bun.stringWidth(line) / cols))
+    return rows
+  }
+
+  // Erase sequence for whatever is currently shown. A single row keeps
+  // the exact legacy bytes (ESC[2K\r); anything taller moves to its
+  // top row and clears to end of screen.
+  const eraseSeq = (): string => (shownRows > 1 ? `\r\x1b[${shownRows - 1}A\x1b[J` : CLEAR)
 
   const draw = (): void => {
     // Whatever was pending is now painted — the trailing draw would
@@ -97,7 +136,7 @@ export function createOutputWriter(
     const erase = shown ? eraseSeq() : CLEAR
     stream.write(erase + current!.join('\n'))
     shown = true
-    shownHeight = current!.length
+    shownRows = regionRows(current!)
     lastDraw = now()
   }
   const set = (lines: readonly string[], o: { force?: boolean }): void => {
@@ -136,7 +175,7 @@ export function createOutputWriter(
       if (shown) {
         stream.write(eraseSeq())
         shown = false
-        shownHeight = 0
+        shownRows = 0
       }
       stream.write(chunk)
       if (chunk.length > 0) atLineStart = chunk.endsWith('\n')
@@ -156,7 +195,7 @@ export function createOutputWriter(
       if (shown) {
         stream.write(eraseSeq())
         shown = false
-        shownHeight = 0
+        shownRows = 0
       }
     },
   }
@@ -209,13 +248,14 @@ export function formatFailureLine(
   id: string,
   durationMs: number | null,
   colors: ColorSupport = NO_COLOR,
+  cacheWord: 'miss' | 'no-cache' = 'miss',
 ): string {
   return formatTaskRow(
     paint(ERROR, '◼\uFE0E', colors),
     durationMs,
     'failed',
     ERROR,
-    'miss',
+    cacheWord,
     '',
     paintPinnedId(id, colors),
     colors,

package/src/orchestrator/summary.ts

@@ -4,6 +4,7 @@
 // aren't real work and would inflate "N total" misleadingly.
 
 import type { TaskOutcome } from '../graph/index.js'
+import type { FlakyFinding } from './failure-mode.js'
 import { paint, type ColorSupport } from './colors.js'
 import { tallyOutcomes } from './tally.js'
 import { isGroupTask } from '../graph/index.js'
@@ -28,7 +29,7 @@ const GRADIENT_TO = [0xf4, 0x72, 0xb6] as const
 const RULE_DASHES = 57
 
 /** Total visible rule width: `\u2500 <mark> ` + dashes. Shared by summary + header. */
-export function gradientRule(colors: ColorSupport, mark = 'vx'): string {
+function gradientRule(colors: ColorSupport, mark = 'vx'): string {
   const head = `\u2500 `
   const dashes = '\u2500'.repeat(Math.max(8, RULE_DASHES + 2 - mark.length))
   if (!colors.enabled) return `${head}${mark} ${dashes}`
@@ -101,13 +102,17 @@ export interface SummaryStats {
   upToDate: number
   restoredLocal: number
   restoredRemote: number
-  /** Tasks that executed (success + failed) — the cache misses. */
+  /** Tasks that executed (success + failed) with a `cache` block — the misses. */
   miss: number
+  /** Executed with no `cache` block: never consulted the cache, not a miss. */
+  noCache?: number
   /** Still to run (live section only; 0 in the final summary) — renders
    *  as a gray ▱ remainder so the live meters FILL toward the final. */
   left?: number
   /** Cache-miss duration spread (only tasks that actually executed). */
   spread: { maxMs: number; minMs: number; sumMs: number; count: number } | null
+  /** Tasks an `admit` policy held with a worker free, and the waits summed. Absent with no hold. */
+  held?: { count: number; sumMs: number }
 }
 
 /**
@@ -125,14 +130,6 @@ export interface RunContext {
   remoteCacheEnabled: boolean
   /** Total projects discovery found — the bar's denominator. */
   workspaceProjectCount?: number
-  /**
-   * Resource-admission budgets (`exec.resources`), set ONLY when at
-   * least one task declared a reservation — a plain run's footer is
-   * byte-identical. Shown on the `info` row so a packed run says what
-   * it packed against. memBudget in bytes.
-   */
-  cpuBudget?: number
-  memBudget?: number
 }
 
 export function formatSummarySection(
@@ -143,6 +140,7 @@ export function formatSummarySection(
 ): string[] {
   const hits = stats.upToDate + stats.restoredLocal + stats.restoredRemote
   const miss = stats.miss
+  const noCache = stats.noCache ?? 0
   const left = stats.left ?? 0
   const remainder = { n: left, color: '', glyph: '\u25b1', dim: true }
 
@@ -206,10 +204,11 @@ export function formatSummarySection(
 
   // Cache meter + numbers, fixed order: miss · up-to-date · local ·
   // remote.
-  if (miss + hits + left + stats.skipped > 0) {
+  if (miss + noCache + hits + left + stats.skipped > 0) {
     const cacheBar = segmentBar(
       [
         { n: miss, color: ERROR },
+        { n: noCache, color: '', dim: true },
         { n: stats.upToDate, color: SUCCESS },
         { n: stats.restoredLocal, color: LOCAL },
         { n: stats.restoredRemote, color: REMOTE },
@@ -220,6 +219,7 @@ export function formatSummarySection(
     )
     const cacheParts: string[] = []
     if (miss > 0) cacheParts.push(paint(ERROR, `${miss} miss`, colors))
+    if (noCache > 0) cacheParts.push(paint('', `${noCache} no-cache`, colors, { dim: true }))
     if (stats.upToDate > 0) cacheParts.push(paint(SUCCESS, `${stats.upToDate} up-to-date`, colors))
     if (stats.restoredLocal > 0)
       cacheParts.push(paint(LOCAL, `${stats.restoredLocal} local`, colors))
@@ -248,9 +248,14 @@ export function formatSummarySection(
     if (context.concurrency !== undefined)
       info.push(`${context.concurrency} worker${context.concurrency === 1 ? '' : 's'}`)
     info.push(context.remoteCacheEnabled ? 'local + remote cache' : 'local cache')
-    if (context.cpuBudget !== undefined) info.push(`cpu budget ${context.cpuBudget}`)
-    if (context.memBudget !== undefined && Number.isFinite(context.memBudget))
-      info.push(`mem budget ${formatBudgetBytes(context.memBudget)}`)
+    // The plugin's hand on the run: a task a policy held with a worker
+    // free would otherwise have started; without the line nothing says
+    // the policy acted.
+    if (stats.held !== undefined && stats.held.count > 0) {
+      info.push(
+        `admit held ${stats.held.count} task${stats.held.count === 1 ? '' : 's'} ${formatDuration(stats.held.sumMs)}`,
+      )
+    }
     lines.push('', row('info', join(info)), row('time', `${formatDuration(totalMs)}${spread}`))
   } else {
     lines.push('', row('time', `${formatDuration(totalMs)}${spread}`))
@@ -260,29 +265,28 @@ export function formatSummarySection(
 
 // Local byte formatter — the orchestrator can't import cli/format.ts
 // (module boundary), and the footer only needs one compact form.
-function formatBudgetBytes(bytes: number): string {
-  const units = ['B', 'KB', 'MB', 'GB', 'TB']
-  let v = bytes
-  let u = 0
-  while (v >= 1024 && u < units.length - 1) {
-    v /= 1024
-    u++
-  }
-  return `${u === 0 ? v : v.toFixed(1)} ${units[u]}`
-}
-
 export function formatRunSummary(
   outcomes: readonly TaskOutcome[],
   totalMs: number,
   colors: ColorSupport = NO_COLOR,
   context?: RunContext,
 ): string[] {
+  // Counted here, not in the Tally: that object is the `--summarize` payload
+  // (ten documented fields) and a task with no `cache` block is a terminal
+  // distinction — it never consulted the cache, so it is not a miss.
+  const noCache = outcomes.filter(
+    (o) =>
+      !isGroupTask(o.node) &&
+      (o.status === 'success' || o.status === 'failed') &&
+      o.node.config.cache === undefined,
+  ).length
   const t = tallyOutcomes(outcomes)
   // Spread over executed tasks only — `success`/`failed` statuses ran
   // a command; cache-hit statuses replayed one.
   const durations = outcomes
     .filter((o) => (o.status === 'success' || o.status === 'failed') && !isGroupTask(o.node))
     .map((o) => o.durationMs)
+  const heldOutcomes = outcomes.filter((o) => o.admissionHeldMs !== undefined)
   return formatSummarySection(
     {
       failed: t.failed,
@@ -292,7 +296,8 @@ export function formatRunSummary(
       upToDate: t.upToDate,
       restoredLocal: t.restoredLocal,
       restoredRemote: t.restoredRemote,
-      miss: t.total - t.skipped - (t.cachedLocal + t.cachedRemote),
+      miss: t.total - t.skipped - (t.cachedLocal + t.cachedRemote) - noCache,
+      noCache,
       spread:
         durations.length > 0
           ? {
@@ -302,6 +307,14 @@ export function formatRunSummary(
               count: durations.length,
             }
           : null,
+      ...(heldOutcomes.length > 0
+        ? {
+            held: {
+              count: heldOutcomes.length,
+              sumMs: heldOutcomes.reduce((sum, o) => sum + o.admissionHeldMs!, 0),
+            },
+          }
+        : {}),
     },
     totalMs,
     colors,
@@ -309,6 +322,57 @@ export function formatRunSummary(
   )
 }
 
+/**
+ * Post-summary section naming the tasks a shutdown signal killed. An aborted
+ * task did no work, so it is in no tally bucket and no history row — but the
+ * run still exits non-zero, and without this the user reads a red exit over a
+ * fully green summary that names nothing. The interactive Ctrl-C path never
+ * gets here (the signal handler exits before any outcome lands), so this only
+ * ever prints for a run that reached its summary WITH a task killed by some
+ * other signal — an external `kill`, a supervisor, a self-terminating child.
+ * Empty when nothing aborted.
+ */
+export function formatAbortedSection(outcomes: readonly TaskOutcome[]): string[] {
+  const aborted = outcomes.filter((o) => o.status === 'aborted')
+  if (aborted.length === 0) return []
+  const lines = [
+    '',
+    `  Aborted:  ${aborted.length} task${aborted.length === 1 ? '' : 's'} killed by a shutdown signal — not counted above`,
+  ]
+  for (const o of aborted) lines.push(`    ✗ ${o.node.id} — exit ${o.exitCode}, nothing cached`)
+  return lines
+}
+
+/**
+ * Post-summary section naming the tasks this run proved flaky: identical
+ * inputs, both outcomes on record (or a retry within the run). A red run
+ * whose failure has passed on these exact inputs before is not a break to
+ * bisect, and a green run that only passed on the second attempt is not
+ * green — either way the footer's counts alone would say nothing. Empty
+ * when nothing was.
+ */
+export function formatFlakySection(findings: readonly FlakyFinding[]): string[] {
+  if (findings.length === 0) return []
+  const lines = [
+    '',
+    `  Flaky:    ${findings.length} task${findings.length === 1 ? '' : 's'} with the same inputs both passing and failing on record`,
+  ]
+  for (const f of findings) {
+    const times = (n: number): string => `${n}\u00d7`
+    const history =
+      f.status === 'failed'
+        ? `failed on inputs that passed ${times(f.passes)} before`
+        : f.failures > 0
+          ? `passed on inputs that failed ${times(f.failures)} before`
+          : 'passed'
+    const retried = f.attempts > 1 ? ` \u00b7 ${f.attempts} attempts this run` : ''
+    lines.push(
+      `    ${f.status === 'failed' ? '\u2717' : '\u2713'} ${f.taskId} \u2014 ${history}${retried}`,
+    )
+  }
+  return lines
+}
+
 export function formatDuration(ms: number): string {
   if (ms < 1000) return `${Math.round(ms)}ms`
   return `${(ms / 1000).toFixed(2)}s`

package/src/orchestrator/tally.ts

@@ -1,6 +1,7 @@
-// Shared outcome-tally helper. Both `summary.ts` (end-of-run terminal
-// block) and `run-artifacts.ts` (`--summarize` JSON) count the same
-// numbers; centralising it keeps the two surfaces consistent.
+// Shared outcome-tally helper. `summary.ts` (end-of-run terminal block),
+// `run-artifacts.ts` (`--summarize` JSON) and `run-report.ts`
+// (`--report=markdown`) all count the same numbers; centralising the bucket
+// rules keeps the three surfaces from disagreeing about one run.
 
 import { isGroupTask, type TaskOutcome } from '../graph/index.js'
 
@@ -16,25 +17,31 @@ export interface Tally {
   /** Cache hits whose tree already matched — nothing was written. */
   upToDate: number
   cachedRemote: number
+  /**
+   * Killed by a shutdown signal. No work, so it joins no outcome bucket and
+   * not `total` — but it is counted, because it makes the run red: a red run
+   * whose every counted task succeeded is undiagnosable without this.
+   */
+  aborted: number
   /** Tasks counted toward `total`. Group tasks are excluded by default. */
   total: number
 }
 
 /**
- * Walk the outcome list and return a `Tally`. Group tasks (no `exec`)
- * are filtered out — they aren't real work, and including them
- * inflates the per-run "N total" count in ways that mislead the user
- * ("3 of 4 cached" when one was a group that ran nothing).
- *
- * Status bucket rules:
- *   `success`            → +successful
- *   `cache-hit`          → +successful, +cachedLocal
- *   `cache-hit-remote`   → +successful, +cachedRemote
- *   `failed`             → +failed
- *   `skipped`            → +skipped
+ * The minimum an outcome must expose to be bucketed. The in-process
+ * `TaskOutcome` and the serializable `OutcomeView` both satisfy it; they
+ * differ only in how they carry group-ness (a live node ref vs. a projected
+ * boolean), so each entry point supplies that and the RULE lives in one
+ * place. Declared structurally here rather than importing `OutcomeView`,
+ * which would close a module cycle (events → summary → tally).
  */
-export function tallyOutcomes(outcomes: readonly TaskOutcome[]): Tally {
-  const t: Tally = {
+export interface TallyItem {
+  status: TaskOutcome['status']
+  restored?: boolean
+}
+
+function emptyTally(): Tally {
+  return {
     successful: 0,
     failed: 0,
     skipped: 0,
@@ -43,27 +50,63 @@ export function tallyOutcomes(outcomes: readonly TaskOutcome[]): Tally {
     restoredRemote: 0,
     upToDate: 0,
     cachedRemote: 0,
+    aborted: 0,
     total: 0,
   }
-  for (const o of outcomes) {
-    if (isGroupTask(o.node)) continue
-    // aborted (killed by a shutdown signal) is no work — excluded
-    // from totals and every bucket, exactly like a group task.
-    if (o.status === 'aborted') continue
-    t.total++
-    if (o.status === 'success') t.successful++
-    else if (o.status === 'cache-hit') {
-      t.successful++
-      t.cachedLocal++
-      if (o.restored === true) t.restoredLocal++
-      else t.upToDate++
-    } else if (o.status === 'cache-hit-remote') {
-      t.successful++
-      t.cachedRemote++
-      if (o.restored === true) t.restoredRemote++
-      else t.upToDate++
-    } else if (o.status === 'failed') t.failed++
-    else if (o.status === 'skipped') t.skipped++
+}
+
+/**
+ * Fold ONE outcome into the tally — the single owner of the bucket rules.
+ *
+ * Group tasks (no `exec`) aren't real work; including them inflates the
+ * per-run "N total" count in ways that mislead ("3 of 4 cached" when one was
+ * a group that ran nothing).
+ *
+ * Status bucket rules:
+ *   `success`            → +successful
+ *   `cache-hit`          → +successful, +cachedLocal
+ *   `cache-hit-remote`   → +successful, +cachedRemote
+ *   `failed`             → +failed
+ *   `skipped`            → +skipped
+ *   `aborted`            → +aborted only (no bucket, no total)
+ */
+function fold(t: Tally, o: TallyItem, isGroup: boolean): void {
+  if (isGroup) return
+  if (o.status === 'aborted') {
+    t.aborted++
+    return
   }
+  t.total++
+  if (o.status === 'success') t.successful++
+  else if (o.status === 'cache-hit') {
+    t.successful++
+    t.cachedLocal++
+    if (o.restored === true) t.restoredLocal++
+    else t.upToDate++
+  } else if (o.status === 'cache-hit-remote') {
+    t.successful++
+    t.cachedRemote++
+    if (o.restored === true) t.restoredRemote++
+    else t.upToDate++
+  } else if (o.status === 'failed') t.failed++
+  else if (o.status === 'skipped') t.skipped++
+}
+
+/** Walk live outcomes and return a `Tally`. */
+export function tallyOutcomes(outcomes: readonly TaskOutcome[]): Tally {
+  const t = emptyTally()
+  for (const o of outcomes) fold(t, o, isGroupTask(o.node))
+  return t
+}
+
+/**
+ * The same tally over the serializable projection (`OutcomeView`), which
+ * carries group-ness as a flag because it has no node back-ref. An absent
+ * flag reads as "not a group" — the only outcomes without one predate the
+ * field and none of them are groups.
+ */
+export function tallyViews(views: readonly (TallyItem & { isGroup?: boolean })[]): Tally {
+  const t = emptyTally()
+  for (const v of views) fold(t, v, v.isGroup === true)
   return t
 }

package/src/orchestrator/task-hash.ts

@@ -1,9 +1,17 @@
 import path from 'node:path'
 import type { TaskConfig, CacheConfig } from '../config.js'
-import { type CacheLayer, resolveInputs, type GitFilesCache } from '../cache/index.js'
+import type { WorkspaceFilesCache } from '../cache/index.js'
+import {
+  type CacheKeyInput,
+  type CacheLayer,
+  resolveInputs,
+  type GitFilesCache,
+  WORKSPACE_OUTPUT_PREFIX,
+} from '../cache/index.js'
+import type { InputFile, TaskInputs } from '../exec/index.js'
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
-import { xxh3hex } from '../util/index.js'
-import { filterUpstreamHashes } from './upstream.js'
+import { span, relPosix, xxh3hex } from '../util/index.js'
+import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
 
 /**
  * Per-run memoization caches for the two derived hashes that don't
@@ -25,6 +33,7 @@ export interface HashCache {
   taskConfig: WeakMap<TaskConfig, string>
   runtime: Map<string, Promise<string>>
   workspaceRuntime: Map<string, Promise<string>>
+  workspaceFiles: WorkspaceFilesCache
 }
 
 export function createHashCache(): HashCache {
@@ -33,6 +42,7 @@ export function createHashCache(): HashCache {
     taskConfig: new WeakMap(),
     runtime: new Map(),
     workspaceRuntime: new Map(),
+    workspaceFiles: new Map(),
   }
 }
 
@@ -83,6 +93,73 @@ export interface ComputeHashArgs {
  * `computeGroupHash` is exported for that purpose.
  */
 export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
+  const end = span('task hash')
+  try {
+    return await args.cache.key(await resolveKeyInput(args))
+  } finally {
+    end()
+  }
+}
+
+/**
+ * The key AND the structured input set behind it, for the executor seam.
+ * Miss path only: it re-runs the (memoized) resolution `computeTaskHash`
+ * did for the probe and retains the VALUES the key folded — env, runtime
+ * output, per-file digests — which `captureInto` deliberately reduces to
+ * digests because its rows are persisted. Per-file digests come from the
+ * same sources as the fold: the index-OID map for clean tracked files,
+ * else `hashFile`'s stat memo (already warm after `key()`).
+ */
+export async function describeTaskInputs(
+  args: ComputeHashArgs,
+): Promise<{ hash: string; inputs: TaskInputs }> {
+  const input = await resolveKeyInput(args)
+  const hash = await args.cache.key(input)
+  const sorted = [...input.inputFiles].sort()
+  const digests = await Promise.all(
+    sorted.map((f) => input.fileHashes?.get(f) ?? args.cache.hashFile(f)),
+  )
+  const files: InputFile[] = sorted.map((f, i) => ({
+    path: relPosix(input.workspaceRoot, f),
+    digest: digests[i]!,
+  }))
+  // Groups expanded: this list describes the INPUT ROOT, not the key, and a
+  // group produces nothing of its own (see `CacheKeyInput.upstreamGraft`).
+  // Sorted by hash so the list — and any action digest derived from it — is
+  // independent of dependency declaration order.
+  const graft = [...(input.upstreamGraft ?? [])].sort((a, b) =>
+    a.hash < b.hash ? -1 : a.hash > b.hash ? 1 : 0,
+  )
+  // Output lists come from the local index — one SELECT for every upstream
+  // entry. An upstream with no entry (non-cacheable) contributes an empty list.
+  const rows = args.cache.loadOutputFilesBatch(graft.map((g) => g.hash))
+  const upstream = graft.map((g) => {
+    const outputs = (rows.get(g.hash) ?? []).map((r) =>
+      r.path.startsWith(WORKSPACE_OUTPUT_PREFIX)
+        ? r.path.slice(WORKSPACE_OUTPUT_PREFIX.length)
+        : relPosix(input.workspaceRoot, path.join(g.projectDir, r.path)),
+    )
+    return { taskId: g.taskId, hash: g.hash, outputs }
+  })
+  return {
+    hash,
+    inputs: {
+      files,
+      env: input.envValues.map(([name, value]) => ({ name, value })),
+      runtime: (input.runtimeValues ?? []).map(([command, output]) => ({ command, output })),
+      workspaceRuntime: (input.workspaceRuntimeValues ?? []).map(([command, output]) => ({
+        command,
+        output,
+      })),
+      upstream,
+      packageJsonDigest: input.projectPackageJsonHash,
+      configDigest: input.taskConfigHash,
+      workspaceFingerprint: input.workspaceFingerprint,
+    },
+  }
+}
+
+async function resolveKeyInput(args: ComputeHashArgs): Promise<CacheKeyInput> {
   const cfg = args.node.config
   const cacheCfg: CacheConfig | undefined = cfg.cache
   const outputs = cacheCfg?.outputs.files ?? []
@@ -100,6 +177,7 @@ export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
       ? {
           runtimeCache: args.hashCache.runtime,
           workspaceRuntimeCache: args.hashCache.workspaceRuntime,
+          workspaceFilesCache: args.hashCache.workspaceFiles,
         }
       : {}),
   })
@@ -113,6 +191,16 @@ export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
   const upstreamHashes = upstreamPairs.map(([, hash]) => hash)
   // hash → upstream task id, for capture-row naming only (not folded).
   const upstreamIds = new Map(upstreamPairs.map(([id, hash]) => [hash, id]))
+  // The DEPENDENCY closure, groups expanded — for the executor's input root.
+  // Deliberately NOT the filtered set above: `cache.inputs.tasks` says which
+  // upstream KEYS this task's key folds, and what a task may READ is
+  // `dependsOn`. Locally every dependency's outputs are on disk before the
+  // command runs however the filter is written, so an executor that ships the
+  // input closure has to ship the same thing or the task sees less remotely
+  // than it does here. Not folded — see `upstreamGraft`.
+  const upstreamGraft = expandGroupUpstream(args.upstream)
+    .filter((u) => u.hash !== undefined)
+    .map((u) => ({ taskId: u.node.id, hash: u.hash!, projectDir: u.node.projectDir }))
   // Trusted index-OID map for this project (populated by the run's
   // bulk `git ls-files -s` + `git status` pass). Mapped files skip
   // hashFile entirely; everything else falls back to the identical
@@ -136,7 +224,7 @@ export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
 
   const effectiveForwardArgs = args.node.requested ? (args.forwardArgs ?? []) : []
 
-  return await args.cache.key({
+  return {
     taskId: args.node.id,
     taskConfigHash,
     projectPackageJsonHash,
@@ -147,11 +235,13 @@ export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
     workspaceRoot: args.workspaceRoot,
     upstreamHashes,
     upstreamIds,
+    upstreamGraft,
     workspaceFingerprint: args.workspaceFingerprint,
     forwardArgs: effectiveForwardArgs,
     ...(fileHashes !== undefined ? { fileHashes } : {}),
+    ...(args.node.keyParts !== undefined ? { pluginParts: args.node.keyParts } : {}),
     ...(args.captureInto !== undefined ? { captureInto: args.captureInto } : {}),
-  })
+  }
 }
 
 /**
@@ -178,17 +268,23 @@ function hashTaskConfig(cfg: TaskConfig, hashCache?: HashCache): string {
 }
 
 /**
- * Project the config for hashing: `exec.resources` is a pure scheduling
- * hint with zero effect on outputs, so it's stripped — tuning a
- * reservation never busts a cache. A config that declares none takes the
- * fast path and stringifies byte-identically to before the field existed
- * (why this needs no CACHE_VERSION bump). `timeout`/`retries` stay folded
- * — their keys are distinct by design (see the decision log); stripping
- * them retroactively would bump CACHE_VERSION.
+ * Project the config for hashing: `exec.remote` is a pure PLACEMENT hint
+ * with zero effect on outputs, so it is stripped — pinning a task to this
+ * machine never busts a cache. It must not: the whole contract of a remote
+ * executor is that the same command over the same inputs produces the
+ * same outputs, so a key that moved when placement changed would split a
+ * laptop from a worker pool over nothing. (`exec.resources` rode the same
+ * rule until 2026-09-12, when reservations left the config for the
+ * schedule plugin that learns them; a config never declares them now.) A
+ * config that declares no `remote` takes the fast path and stringifies
+ * byte-identically to before the field existed (why this needs no
+ * CACHE_VERSION bump). `timeout`/`retries` stay folded — their keys are
+ * distinct by design (see the decision log); stripping them retroactively
+ * would bump CACHE_VERSION.
  */
 function hashableConfig(cfg: TaskConfig): unknown {
-  if (cfg.exec?.resources === undefined) return cfg
-  const { resources: _resources, ...execRest } = cfg.exec
+  if (cfg.exec?.remote === undefined) return cfg
+  const { remote: _remote, ...execRest } = cfg.exec
   return { ...cfg, exec: execRest }
 }
 
@@ -249,5 +345,5 @@ async function doHashProjectPackageJson(
   if (!(await Bun.file(filePath).exists())) return ''
   // Route through the cache layer's mtime+size fast path so the
   // typical re-run sees a stat + SQLite lookup instead of a file read.
-  return await cache.hashFile(filePath)
+  return cache.hashFile(filePath)
 }