@vzn/vx 0.0.650 → 0.0.652

package/src/orchestrator/run.ts

@@ -8,11 +8,13 @@ import { EMPTY_LOCK, inputStabilityEnv, LOCK_INVALID, lockEntryBroken } from '..
 import { realpathSync } from 'node:fs'
 import path from 'node:path'
 import {
+  historyFiles,
   indexDb,
   Cache,
   type CachePolicy,
   cachesNothing,
   formatCachePolicy,
+  HistoryStream,
   networkConcurrency,
   keepRunNotes,
   stopRuntimeProbes,
@@ -28,10 +30,11 @@ import {
 } from '../exec/index.js'
 import { DeferredOutputs } from './deferred-outputs.js'
 import { resolveDownloadModes } from './download-policy.js'
-import type { MachineReport, TaskExecutor } from '../exec/index.js'
+import type { MachineReport, TaskExecutor, WorkerAdvice } from '../exec/index.js'
 import {
   deadServerBehind,
   declaredTask,
+  isCacheHit,
   isGroupTask,
   markSurfacedDeps,
   runGraph,
@@ -39,11 +42,12 @@ import {
   type TaskNode,
   type TaskOutcome,
 } from '../graph/index.js'
+import { graphCounts } from './graph-memo.js'
 import {
   mark,
   stageTimes,
   MAX_TIMEOUT_MS,
-  printTimings,
+  timingLines,
   ulid,
   isLiteralPattern,
   listed,
@@ -53,13 +57,18 @@ import {
   secretMask,
   isFsRefusal,
   isUserError,
-  detectColors,
-  type ColorSupport,
   SecretBroker,
   thrownMessage,
-  type ui,
 } from '../util/index.js'
-import { keyedProjects } from './keyed-projects.js'
+import * as ui from '../ui/index.js'
+
+/** The stage table `VX_DEBUG_TIMING=1` asks for, on stderr. */
+function printTimings(): void {
+  const lines = timingLines()
+  if (lines !== undefined) ui.print('err', ui.trace(lines))
+}
+import { detectColors, type ColorSupport } from '../ui/index.js'
+import { keyedProjects, readableDeps } from './keyed-projects.js'
 import { isDefaultBuild } from '../graph/index.js'
 import { commandWriteReach, prepareSandbox } from './sandbox-request.js'
 import { recordOutputDirSnapshots, type OutputDirSnapshot, type SaveFacts } from './miss-save.js'
@@ -70,7 +79,6 @@ import { excludedTaint } from './excluded-keys.js'
 import { dependedOn, keyUpstream } from './upstream.js'
 import { createLiveUsage } from './live-usage.js'
 import {
-  blocksCounts,
   busLogger,
   createEventBus,
   createForecast,
@@ -133,7 +141,12 @@ import { deriveStableKeys, probesAfterWrites } from './stable-keys.js'
 import { askRemote, serversToHold } from './held-servers.js'
 
 import { writeRunFailures } from './run-failures.js'
-import { assembleRunRecords, recordLateRemoteErrors } from './run-records.js'
+import {
+  assembleRunRecords,
+  recordLateRemoteErrors,
+  type RecordedOutcome,
+  runRecordOf,
+} from './run-records.js'
 import {
   hasEnded,
   disposeServers,
@@ -150,6 +163,7 @@ import {
   createMissExplainer,
   detectFlaky,
   type FlakyCandidate,
+  knownFlaky,
   LocalHistoryProvider,
 } from '../history/index.js'
 import type { RunOptions, RunSummary } from './options.js'
@@ -356,6 +370,11 @@ export async function run(options: RunOptions): Promise<RunSummary> {
   const detach = (): void => {
     unsubscribeTerminal()
     unsubscribeWarned()
+    // A run refused or thrown before its tasks (an unknown task, a plugin
+    // stage that threw) never reached the end that takes the live region
+    // down: a load slow enough to show its step left `vx:load running`
+    // on screen, and the CLI's refusal was written onto its last line.
+    terminal?.runDone?.()
     terminal?.settle()
   }
   // A plugin's `output` renders the run from its start; core's renderer
@@ -442,11 +461,11 @@ async function runOnBus(
     options = withRunSettings(options, prepared.workspaceConfig)
     inputStability = {
       run: inputStabilityEnv(),
-      ...(prepared.workspaceConfig?.cache?.inputStability !== undefined
-        ? { workspace: prepared.workspaceConfig.cache.inputStability }
+      ...(prepared.workspaceConfig?.inputs?.stability !== undefined
+        ? { workspace: prepared.workspaceConfig.inputs.stability }
         : {}),
     }
-    cleanOutputs = resolveSetting('cache.outputs.clean', prepared.workspaceConfig).value as
+    cleanOutputs = resolveSetting('outputs.clean', prepared.workspaceConfig).value as
       | boolean
       | undefined
   } catch (err) {
@@ -629,15 +648,15 @@ async function runOnBus(
   // deliberate — on a machine with no remote pool the ambient state already
   // is what the task would have produced — but it must not be SILENT: a task
   // reporting success while doing nothing is indistinguishable from one that
-  // worked, and the usual cause (no `cache` block, so no executor can
+  // worked, and the usual cause (no `cache: true`, so no executor can
   // describe its inputs to a worker) cannot be read off the outcome.
   if (placements.remoteOnlyNoop.size > 0) {
     const anyRemote = executors.some((e) => e.remote === true)
     for (const id of placements.remoteOnlyNoop) {
       const why = !anyRemote
         ? 'no remote executor is declared'
-        : nodes.get(id)?.config.cache === undefined
-          ? 'no remote executor accepted it — the task declares no `cache` block, so there is no input set to ship'
+        : nodes.get(id)?.config.cache !== true
+          ? 'no remote executor accepted it — the task has no `cache: true`, so there is no input set to ship'
           : 'no remote executor accepted it'
       warnOf(log)(`[vx] ${id}: exec.remote is 'only' and ${why} — nothing ran`)
     }
@@ -843,7 +862,7 @@ async function runOnBus(
     // SRT's proxies holding the process open.
     const surelyRuns = (n: TaskNode): boolean =>
       n.config.exec?.persistent !== undefined ||
-      n.config.cache === undefined ||
+      n.config.cache !== true ||
       !(policy.localRead || policy.remoteRead)
     // Only what runs here arms this machine's sandbox: a `sandbox` executor
     // enforces it where it runs the task, so a distributed run's
@@ -864,6 +883,7 @@ async function runOnBus(
     }
     if (sandboxed.some(surelyRuns)) prewarm()
     const keyed = keyedProjects(nodes, prepared.keyOnly)
+    const readable = readableDeps(nodes, prepared.keyOnly)
     const outputDirSnapshots: OutputDirSnapshot[] = []
     // Saves run off the execution slot, twice the cap at once (memory:
     // each pack holds an artifact's bytes); a failed save is a miss next
@@ -913,14 +933,39 @@ async function runOnBus(
     const fault = executorFaults(warnOf(log))
     const footers = executors.filter((e) => e.footer !== undefined)
     const placers = executors.filter((e) => e.running !== undefined)
-    // Every row's `blocks`, the live list's and the results': one closure
-    // over the graph, built on the first row that asks.
-    let blocks: ReadonlyMap<string, number> | undefined
-    const blocksNow = (): ReadonlyMap<string, number> => (blocks ??= blocksCounts(nodes))
+    // The scheduler's dependents count, and every row's `blocks` (the live
+    // list's and the results'): one closure over the graph, built on the
+    // first that asks.
+    let counted: ReadonlyMap<string, number> | undefined
+    const blocksNow = (): ReadonlyMap<string, number> =>
+      (counted ??= graphCounts(nodes, hashCache.folds, hashCache.graph))
+    // Every row's `usual` and the forecast's timings: history read once, on
+    // the first row that asks, so a run that executes nothing never reads
+    // it. It was read only a second into a live run, so rows before that,
+    // a short run's and every log's showed none (2026-10-29).
+    let p50s: ReadonlyMap<string, number> | undefined
+    const p50sNow = (): ReadonlyMap<string, number> => {
+      if (p50s !== undefined) return p50s
+      const ids: string[] = []
+      for (const n of nodes.values()) if (!isGroupTask(n)) ids.push(n.id)
+      try {
+        p50s = new LocalHistoryProvider(
+          indexDb(prepared.localCache),
+          undefined,
+          prepared.branch(),
+          taskDefinitions(nodes.values()),
+        ).p50sNow(ids)
+      } catch {
+        // History is observability: an unreadable one knows no task.
+        p50s = new Map()
+      }
+      return p50s
+    }
     // The live rows' `cpu` and `mem`; it looks only once the live list asks.
     const liveUsage = createLiveUsage()
     const runContext = {
       blocks: blocksNow,
+      usual: (id: string) => p50sNow().get(id),
       usage: liveUsage.usage,
       ...(footers.length > 0
         ? { executorRows: () => footers.flatMap((e) => executorFooter(e, fault)) }
@@ -979,17 +1024,7 @@ async function runOnBus(
     // never reads history.
     terminal?.forecast(
       () => createForecast(nodes, new Map(), concurrency, blocksNow()),
-      async () => {
-        const ids: string[] = []
-        for (const n of nodes.values()) if (!isGroupTask(n)) ids.push(n.id)
-        const p50s = await new LocalHistoryProvider(
-          indexDb(prepared.localCache),
-          undefined,
-          prepared.branch(),
-          taskDefinitions(nodes.values()),
-        ).p50sFor(ids)
-        return createForecast(nodes, p50s, concurrency, blocksNow())
-      },
+      async () => createForecast(nodes, p50sNow(), concurrency, blocksNow()),
     )
 
     // Remote-only: kick off background prefetches so remote-GET latency
@@ -1089,7 +1124,7 @@ async function runOnBus(
           (probe.hit !== null ? hits : missed).push(id)
         // An empty store was not asked: it holds none of them.
         if (coldLocal && !remote)
-          for (const [id, n] of nodes) if (n.config.cache !== undefined) missed.push(id)
+          for (const [id, n] of nodes) if (n.config.cache === true) missed.push(id)
         demand.settle(hits, missed)
       }
     }
@@ -1128,6 +1163,8 @@ async function runOnBus(
     // The scheduler's fail-fast stop, as the retry loop of a task already
     // in flight sees it.
     const failFast = new AbortController()
+    // Tasks a plugin's shared record names flaky (`ctx.flaky`).
+    const sharedFlaky = new Set<string>()
     const scope: RunScope = {
       workspaceRoot,
       cache,
@@ -1143,6 +1180,7 @@ async function runOnBus(
       probesAfterWrites: lateProbes,
       fingerprintWatch,
       keyedProjects: keyed,
+      readableDeps: readable,
       outputDirSnapshots,
       deferSave: saveLane.defer,
       deferredSaves,
@@ -1152,6 +1190,15 @@ async function runOnBus(
       inputStability,
     }
     if (options.retries !== undefined) scope.retries = options.retries
+    scope.knownFlaky = (node, hash) => {
+      if (sharedFlaky.has(node.id)) return true
+      try {
+        return knownFlaky(indexDb(prepared.localCache), node.projectName, node.taskName, hash)
+      } catch {
+        // History is observability: an unreadable one retries nothing.
+        return false
+      }
+    }
     if (taskTimeoutDefault !== undefined) scope.timeout = taskTimeoutDefault
     if (cleanOutputs !== undefined) scope.cleanOutputs = cleanOutputs
     const sinkTrack = telemetry?.track
@@ -1228,6 +1275,9 @@ async function runOnBus(
             if (reprioritize !== undefined) reprioritize(merged)
             else if (!graphOver) refinedEarly = merged
           },
+          flaky: (ids) => {
+            for (const id of ids) if (nodes.has(id)) sharedFlaky.add(id)
+          },
         })
     mark('schedule')
     // Judged as each task finishes, against the history BEFORE this run's
@@ -1268,10 +1318,35 @@ async function runOnBus(
       }
     }
     let lockBroken: boolean | undefined
+    prepared.localCache.storeHeldBlobSizes()
+    // A hit's row is whole when it finishes, so it is written while the
+    // graph runs (history-stream.ts); every other row waits for the bundle.
+    // A row with forward args is the bundle's too: only it digests them.
+    const historyAt = historyFiles(prepared.localCache)
+    const stream = historyAt === undefined ? undefined : new HistoryStream<TaskOutcome>(historyAt)
+    const forwards = (options.forwardArgs?.length ?? 0) > 0
+    const streamHit = (o: TaskOutcome): void => {
+      if (stream === undefined || isGroupTask(o.node)) return
+      if (!isCacheHit(o.status)) return
+      if (o.wallclockStartNs === undefined || o.wallclockEndNs === undefined) return
+      if (forwards && o.node.requested) return
+      stream.add(
+        o,
+        runRecordOf(o as RecordedOutcome, {
+          tainted: taintedRan,
+          runId,
+          startedAtMs: endedAtMsAtStart,
+          endedAtMs: endedAtMsAtStart,
+          blocks: blocksNow(),
+          remoteTraffic: prepared.localCache.traffic.keys,
+        }),
+      )
+    }
     const outcomes = await runGraph({
       nodes,
       concurrency,
       restoreConcurrency: options.restoreConcurrency ?? 2 * concurrency,
+      reverseDeps: blocksNow,
       settledOf: (o) => deferredSaves.get(o.node.id),
       ...(hasPooledExecutor(executors) ? { poolOf: poolOfPlacement(placements) } : {}),
       ...(admit !== undefined ? { admit } : {}),
@@ -1280,8 +1355,8 @@ async function runOnBus(
       serverDied,
       onFailFast: () => failFast.abort(),
       signal: stop.signal,
-      onStart: (node, queuedMs) => {
-        log.taskStart?.(node, queuedMs === undefined ? undefined : { waitedMs: queuedMs })
+      onStart: (node) => {
+        log.taskStart?.(node)
       },
       onFinish: (o) => {
         if (cacheOff) o.cacheOff = true
@@ -1289,6 +1364,7 @@ async function runOnBus(
         judgeFlaky(o)
         keeper?.taskDone(o)
         log.taskComplete(o.node, o)
+        streamHit(o)
         demand.finished(o.node.id)
         // A server that dies while the graph runs is no longer running:
         // its pin stayed `running` under the line naming its exit.
@@ -1380,6 +1456,9 @@ async function runOnBus(
     const hold =
       options.holdPersistent === true &&
       (!stop.signal.aborted || stop.signal.reason === CYCLE_INTERRUPT)
+    // A stop already signalled every server once and waits out its grace:
+    // a SIGTERM here, while a server ran its cleanup, cut it short.
+    if (stop.signal.aborted) await stop.aborting?.catch(() => {})
     const { keepAlive, crashed: crashedPersistent } = await disposeServers({
       registry: persistentRegistry,
       nodes,
@@ -1390,6 +1469,9 @@ async function runOnBus(
       endedBeforeStop: stop.endedBeforeStop,
     })
 
+    // Every batch the stream sent has answered: what landed is not written again.
+    const streamed = await stream?.finish()
+    const landed = new Set(streamed?.landed.map((s) => s.item))
     mark('run graph')
 
     // Clear the status line for good before the summary prints.
@@ -1488,7 +1570,9 @@ async function runOnBus(
         ci: ciContext,
         host: hostContext,
         withTelemetry: telemetry !== undefined,
+        blocks: blocksNow(),
         remoteTraffic: prepared.localCache.traffic.keys,
+        landed,
       })
     const records = recordsOf(list, ok)
     const recordHistory = (write: () => void): void => {
@@ -1572,7 +1656,13 @@ async function runOnBus(
     }
     // An upload that failed after the rows went in: its row says so too.
     if (prepared.localCache.uploads.failed > 0 && stop.stoppedBy === undefined && !historyAfterWait)
-      recordHistory(() => recordLateRemoteErrors(prepared.localCache, records.runs, runId))
+      recordHistory(() =>
+        recordLateRemoteErrors(
+          prepared.localCache,
+          [...records.runs, ...(streamed?.landed.map((s) => s.record) ?? [])],
+          runId,
+        ),
+      )
     const report = reportOf(list, { runId, commit: head.commitSha, ciRun: ciContext, ok }, keeper)
     // Hand the per-run summary to the telemetry sinks + drain them. Only
     // when a sink is active (telemetry !== undefined) — otherwise this
@@ -1592,6 +1682,7 @@ async function runOnBus(
         uploads: prepared.localCache.uploads,
         machines: executors.flatMap((e) => executorMachines(e, fault)),
         idealMs: executors.map((e) => executorIdeal(e, fault)).find((ms) => ms !== undefined),
+        advice: executors.flatMap((e) => executorAdvice(e, fault)),
       })
       telemetry.emitSummary(summary)
       const sinks = telemetry
@@ -1950,12 +2041,15 @@ function didYouMean(
   elsewhere: readonly string[],
   taskless: (name: string) => boolean,
 ): string {
-  const tasksOf = (p: ProjectEntry | undefined): string[] => Object.keys(p?.config.tasks ?? {})
-  // What a bare name can select: a default `build` is no match (X-102).
+  // A default `build` is no declared task (X-102): neither a bare name's
+  // match nor a menu item or hint for `p#typo`, which led to `p#build`
+  // and its refusal ("p declares no build").
+  const tasksOf = (p: ProjectEntry | undefined): string[] =>
+    Object.entries(p?.config.tasks ?? {})
+      .filter(([, c]) => !isDefaultBuild(c))
+      .map(([t]) => t)
   const allTasks = new Set<string>()
-  for (const p of projects.values()) {
-    for (const t of tasksOf(p)) if (!isDefaultBuild(p.config.tasks![t])) allTasks.add(t)
-  }
+  for (const p of projects.values()) for (const t of tasksOf(p)) allTasks.add(t)
   // A Set: two typos of the same task hint it once, not once per typo.
   const hints = new Set<string>()
   // A typo past two edits named nothing to pick from (M-56): with no near
@@ -2065,10 +2159,10 @@ function flakyCandidates(
   for (const o of outcomes) {
     if (o.status !== 'success' && o.status !== 'failed') continue
     // "Same inputs, failed after passing" is a claim only a task with declared
-    // inputs can make: a task with no `cache` block keys on its config alone
+    // inputs can make: a task without `cache: true` keys on its config alone
     // and runs every time, so one bad network day would read as a flake for
     // thirty days. Groups do no work.
-    if (o.hash === undefined || o.node.config.cache === undefined || isGroupTask(o.node)) continue
+    if (o.hash === undefined || o.node.config.cache !== true || isGroupTask(o.node)) continue
     // Behind a failed dependency the outcome is not the key's: a failure is
     // the dependency's, and a pass built on bytes the key never named, so a
     // later failure relapsed from it and read as a flake for thirty days.
@@ -2153,6 +2247,16 @@ function executorMachines(e: TaskExecutor, fault: ExecutorFault): readonly Machi
   }
 }
 
+function executorAdvice(e: TaskExecutor, fault: ExecutorFault): readonly WorkerAdvice[] {
+  try {
+    const a = e.advice?.()
+    return Array.isArray(a) ? a : []
+  } catch (err) {
+    fault(e, 'advice', err)
+    return []
+  }
+}
+
 function executorIdeal(e: TaskExecutor, fault: ExecutorFault): number | undefined {
   try {
     const ms = e.idealMs?.()

package/src/orchestrator/sandbox-request.ts

@@ -183,6 +183,10 @@ export function prepareSandbox(nodes: Iterable<SandboxedNode>): SandboxArmer | n
  * anyone's (2026-09-24): `keyed` is the set of project directories the
  * task's key answers for (keyed-projects.ts), and `undefined` for a task
  * with no `cache`, which has no key to be stale.
+ *
+ * The other is the outputs of the tasks its key folds
+ * (`dependencyOutputs`, 2026-11-06): an edge the user drew, whose files
+ * this key already answers for, so the read can replay nothing stale.
  */
 export async function sandboxRequestFor(
   node: Pick<TaskNode, 'projectDir'>,
@@ -197,6 +201,8 @@ export async function sandboxRequestFor(
    * grant covered it could plant artifacts and index rows (L-24).
    */
   cacheDir?: string,
+  /** The dependencies' outputs it may read (`dependencyReads`): absolute paths. */
+  dependencyOutputs: readonly string[] = [],
 ): Promise<SandboxRequest> {
   // The runtime reads a path holding a bracket as a pattern: on Linux it
   // mounts no such write path (B-60); seatbelt's rules compile it as a
@@ -238,7 +244,7 @@ export async function sandboxRequestFor(
   // own `package.json` depends on (2026-09-05) — when the key
   // moves with it.
   const links = await linkedDeps(depDirs, node.projectDir, workspaceRoot, keyed)
-  depDirs.push(...links.granted)
+  depDirs.push(...links.granted, ...dependencyOutputs)
   // bwrap cannot --bind a path that does not exist: the bind silently
   // becomes a no-op and writes to it appear to succeed but never land.
   // Pre-create what the task said it will write — after the grants are
@@ -269,7 +275,8 @@ export async function sandboxRequestFor(
     throw err
   }
   const request: NonNullable<ExecuteRequest['sandbox']> = {
-    // Only what the task declared, plus node_modules. Write paths are
+    // Only what the task declared, plus node_modules and the outputs of
+    // the tasks its key folds (`dependencyReads`). Write paths are
     // readable too: a task that writes `dist/x` expects to read it back
     // (`tsc --incremental` re-reads .tsbuildinfo).
     baseAllowRead: depDirs,
@@ -304,10 +311,46 @@ export async function sandboxRequestFor(
     reportLinked: links.withheld.map((w) => w.dir),
     config,
     ...(keyed === undefined ? {} : { keyed: [...keyed] }),
+    ...(dependencyOutputs.length === 0 ? {} : { dependencyReads: [...dependencyOutputs] }),
   }
   return { sandbox: request, placeholders, withheld: links.withheld }
 }
 
+/**
+ * The paths a sandboxed task may read of its dependencies' declared
+ * outputs (`readableDeps`): each output glob's fixed head, or, for a glob
+ * with none (`*.tsbuildinfo`), the files it matches now, so a root-level
+ * output never grants the dependency's whole project. Asked when the task
+ * runs, after its dependencies ran or were restored: a head that names
+ * nothing is left out, as bwrap binds no missing path.
+ */
+export async function dependencyReads(
+  deps: readonly TaskNode[],
+  workspaceRoot: string,
+): Promise<string[]> {
+  const reads = new Set<string>()
+  for (const dep of deps) {
+    const outputs = dep.config.outputs
+    if (outputs === undefined) continue
+    const globs = [
+      ...outputs.files.map((g) => [dep.projectDir, g] as const),
+      ...(outputs.workspaceFiles ?? []).map((g) => [workspaceRoot, g] as const),
+    ]
+    for (const [base, glob] of globs) {
+      if (glob.startsWith('!')) continue
+      const head = grantPrefix(glob)
+      if (head !== '' && head !== '.') {
+        const abs = path.join(base, head)
+        if (existsSync(abs)) reads.add(abs)
+        continue
+      }
+      for await (const f of new Bun.Glob(glob).scan({ cwd: base, onlyFiles: true, dot: true }))
+        reads.add(path.join(base, f))
+    }
+  }
+  return [...reads]
+}
+
 /**
  * The sandbox half of the request, plus the empty files vx created so a
  * literal write grant had something to bind (`placeholders`). They are
@@ -446,8 +489,8 @@ export function withheldLinkLine(taskId: string, w: WithheldLink): string {
   return (
     `vx: ${taskId} read \`${w.target}\` through \`${w.link}\`, and its key includes no task of ` +
     `${w.name}, so an edit there would not re-run it. Add a \`dependsOn\` edge that ` +
-    `reaches one (\`^build\` where ${w.name}#build keys its sources, or a \`source\` task: ` +
-    `\`${w.name}#source\`), or grant and key the files yourself (\`allow.read\` plus ` +
+    `reaches one (\`^build\`, where ${w.name}#build keys its sources), or grant and key ` +
+    `the files yourself (\`allow.read\` plus ` +
     `\`inputs.workspaceFiles\`).`
   )
 }
@@ -573,7 +616,7 @@ function wallOff(
     if (wall === undefined) continue
     throw new UserError(
       `exec.sandbox.allow.write: the grant binding ${bind} would make ${wall} writable — another ` +
-        `project's directory, the repository or vx's own. A file grant binds its directory; ` +
+        `project's directory, .git or vx's own. A file grant binds its directory; ` +
         `grant a directory of the task's own instead, such as "dist/".`,
     )
   }
@@ -774,13 +817,13 @@ export type WriteReach = 'none' | 'project' | 'workspace'
  * names — the files whose run-start facts (the git snapshot, its index
  * OIDs) a later key must not reuse (item 743).
  *
- * A cached task declares its outputs and is held to them. A task with no
- * `cache` block can declare none, so it may have written anywhere
- * `commandWriteReach` says. An unsandboxed write into another project is
+ * A cached task declares its outputs and is held to them: its save checks
+ * them. A task with no `cache: true` is held to nothing, even when it
+ * declares outputs, so it may have written anywhere `commandWriteReach` says. An unsandboxed write into another project is
  * out of contract, as it is for a cached task.
  */
 export function undeclaredWriteReach(node: TaskNode, workspaceRoot: string): WriteReach {
-  if (node.config.cache !== undefined) return 'none'
+  if (node.config.cache === true) return 'none'
   return commandWriteReach(node, workspaceRoot)
 }
 

package/src/orchestrator/shell-verdict.ts

@@ -43,6 +43,15 @@ export function shellVerdict(args: {
   if (args.code === 126) {
     return `[vx] exit 126 is the shell's "found but cannot execute": ${what} is not executable or is a directory — chmod +x it`
   }
+  // A program the host's PATH has may be one the sandbox hides (a
+  // hermetic task sees no /usr/bin): the reason is a grant, not an install.
+  const found =
+    word === undefined || args.hidden === undefined
+      ? null
+      : Bun.which(word, { PATH: [...args.bins, process.env['PATH'] ?? ''].join(path.delimiter) })
+  if (found !== null && args.hidden!(found)) {
+    return `[vx] exit 127 is the shell's "command not found": ${word} is ${found} on the host, but no sandbox grant reads it, so inside the sandbox it is not there — add it (or its directory) to exec.sandbox.allow.read`
+  }
   const unnamed = args.bins.find((dir) => dir.includes(path.delimiter))
   if (unnamed !== undefined) {
     return `[vx] exit 127 is the shell's "command not found": ${what} is not on this task's PATH — ${unnamed} holds "${path.delimiter}", which PATH reads as a separator, so vx cannot put it there; move the workspace to a path without "${path.delimiter}"`

package/src/orchestrator/signals.ts

@@ -14,7 +14,13 @@
 // them to the runner around every spawn.
 
 import { signalExitCode } from '../exec/index.js'
-import { claimExitForSignal, hangupIgnored, killGraceMs, settleWithin } from '../util/index.js'
+import {
+  claimExitForSignal,
+  dieOf,
+  hangupIgnored,
+  killGraceMs,
+  settleWithin,
+} from '../util/index.js'
 import {
   holdGroups,
   killTree,
@@ -154,10 +160,7 @@ export function forwardSignals(args: {
     // and a 130 exit ran the script's next line. The code stays the
     // fallback should the signal not land.
     if (args.handsTerminal !== true) {
-      process.once('exit', () => {
-        process.removeAllListeners(signal)
-        process.kill(process.pid, signal)
-      })
+      process.once('exit', () => dieOf(signal))
     }
     process.exit(signalExitCode(signal))
   }