@vzn/vx 0.0.636 → 0.0.638

package/src/orchestrator/execute-task.ts

@@ -6,6 +6,7 @@ import {
   type CacheLayer,
   type CachePolicy,
   cleanOutputs,
+  committedFiles,
   cleanWorkspaceOutputs,
   type OutputStamp,
   ownOutputsSince,
@@ -14,6 +15,7 @@ import {
   stampWorkspaceOutputs,
   FULL_CACHE_POLICY,
   type GitFilesCache,
+  racyWindowMs,
 } from '../cache/index.js'
 import {
   buildIsolatedEnv,
@@ -51,7 +53,9 @@ import { isGroupTask, RestoreDemoted, type TaskNode, type TaskOutcome } from '..
 import {
   killGraceMs,
   MASKED,
+  parseDuration,
   maskedEmitter,
+  outputMatcher,
   printable,
   relPosix,
   secretMask,
@@ -61,12 +65,15 @@ import {
 } from '../util/index.js'
 import { forwardedSignal, SIGNAL_SHUTDOWN_GRACE_MS, terminateChildren } from './signals.js'
 import { executorLabel, nameExecutorFailure } from './plugin-host.js'
+import type { CommandWindows } from './command-windows.js'
 import {
+  commandWriteReach,
   mayWriteFingerprint,
   type Placeholder,
   placeholderSweeper,
   reachedWithheld,
   sandboxRequestFor,
+  sandboxReadable,
   sweepPlaceholders,
   undeclaredWriteReach,
   untouchedPlaceholderLine,
@@ -88,6 +95,7 @@ import {
   computeTaskHash,
   describeTaskInputs,
   type HashCache,
+  type InputFact,
   movedInput,
   type TaskInputComponent,
   type UpfrontGroupKey,
@@ -99,7 +107,6 @@ export interface ExecuteArgs {
   node: TaskNode
   upstream: TaskOutcome[]
   workspaceRoot: string
-  workspaceFingerprint: string
   cache: CacheLayer
   /** Granular cache read/write policy. Undefined → everything on. */
   cachePolicy?: CachePolicy
@@ -121,7 +128,7 @@ export interface ExecuteArgs {
    */
   remoteOnly?: boolean
   /**
-   * Plan-time `--download` decision for THIS task (run.ts). `'deferred'`
+   * Plan-time `--cache-download` decision for THIS task (run.ts). `'deferred'`
    * means: do not clean, do not save — the executor is expected to leave
    * the outputs in the remote store and hand back a closure. An executor
    * that ignores it and materialises anyway simply gets no local entry;
@@ -163,26 +170,29 @@ export interface ExecuteArgs {
   /** Name what a missed key changed (`createMissExplainer`); absent when nobody listens. */
   explainMiss?: MissExplainer
   /**
-   * Run-level retry default (`--retry <n>` / `RunOptions.retries`).
+   * Run-level retry default (`--retries <n>` / `RunOptions.retries`).
    * Explicit `exec.retries` wins, including an explicit 0. Threaded as
    * an option only — never folded into any hash, so cache keys are
    * byte-identical with and without it.
    */
   retries?: number
   /**
-   * Run-level default task timeout (ms) — the already-resolved
-   * `VX_TASK_TIMEOUT`/workspace/`--timeout` fallback. Per-task
-   * `exec.timeout` wins. Threaded as an option only — never hashed.
+   * `run.timeout` (ms), already resolved from flag, variable and
+   * workspace. Per-task `exec.timeout` wins. Never hashed.
    */
   timeout?: number
+  /** `run.readyNotice` (ms), resolved like `timeout`; unset, 10 s. */
+  readyNotice?: number
   /**
    * The run's `inputStability` layers around the task's own: `run` from
-   * the env vars (above the task), `workspace` from `vx.workspace` (below).
+   * the env vars (above the task), `workspace` from `.vx/workspace` (below).
    */
   inputStability?: { run: InputStability; workspace?: InputStability }
+  /** `cache.outputs.clean` for tasks without their own: `.vx/workspace`. */
+  cleanOutputs?: boolean
   /** Per-run memo for `git ls-files` (one entry per project dir). */
   gitFilesCache?: GitFilesCache
-  /** Per-run memo for derived hashes (package.json bytes + task config). */
+  /** Per-run memo for derived hashes (task config, file lists). */
   hashCache?: HashCache
   /** The run's `probesAfterWrites`, handed to every key this task takes. */
   probesAfterWrites?: ReadonlySet<string>
@@ -247,8 +257,14 @@ export interface ExecuteArgs {
    */
   taintedUpstream?: boolean
   /**
-   * Whether a task has rewritten a file the workspace fingerprint folded
-   * since the run read it (fingerprint-watch.ts): past that, no key taken
+   * The run keeps its bytes in a remote (run-store.ts): an attempt captures
+   * its output at the entry's bounds, and an outcome that saves no entry
+   * (a failure, an uncached run) carries it as `runLog`.
+   */
+  keepRunLog?: boolean
+  /**
+   * Whether a task has rewritten a root file a plugin claims (whose bytes
+   * the claimant folded) since the run read it (fingerprint-watch.ts): past that, no key taken
    * on the old digest is probed or saved.
    */
   fingerprintWatch?: FingerprintWatch
@@ -260,6 +276,8 @@ export interface ExecuteArgs {
   noDependants?: true
   /** The task holds vx's terminal (`terminalHolders`): its stdio is vx's own. */
   terminal?: true
+  /** When each command of the run ran and where it may write (command-windows.ts). */
+  commandWindows?: CommandWindows
 }
 
 /**
@@ -360,9 +378,14 @@ function inputStabilityOf(
   }
 }
 
+/** The root files the plugins claim, as the run's watch holds them. */
+function claimedFiles(args: ExecuteArgs): readonly string[] {
+  return args.fingerprintWatch?.names ?? []
+}
+
 /**
- * The workspace fingerprint every key here folded has moved (a task
- * rewrote the lockfile), said once per run.
+ * A claimed file every key here folded through its claimant has moved (a
+ * task rewrote the lockfile), said once per run.
  */
 function fingerprintMoved(args: ExecuteArgs): boolean {
   if (args.fingerprintWatch?.moved() === undefined) return false
@@ -390,7 +413,6 @@ async function executeGroupTask(args: ExecuteArgs): Promise<TaskOutcome> {
     node: args.node,
     upstream: args.upstream,
     workspaceRoot: args.workspaceRoot,
-    workspaceFingerprint: args.workspaceFingerprint,
     cache: args.cache,
     forwardArgs: args.forwardArgs,
     nestedProjectDirs: args.nestedProjectDirs,
@@ -486,7 +508,6 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
           node,
           upstream: args.upstream,
           workspaceRoot: args.workspaceRoot,
-          workspaceFingerprint: args.workspaceFingerprint,
           cache: args.cache,
           forwardArgs: args.forwardArgs,
           nestedProjectDirs: args.nestedProjectDirs,
@@ -548,6 +569,8 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const serverSecrets = secretMask([process.env, env, step.env?.define], step.env?.secret)
   const serverOut = serverSecrets && maskedEmitter(serverSecrets, (t) => log.taskStdout(node, t))
   const serverErr = serverSecrets && maskedEmitter(serverSecrets, (t) => log.taskStderr(node, t))
+  // A server writes until the run stops it: its window stays open.
+  args.commandWindows?.open(node.id, node.projectDir, commandWriteReach(node, args.workspaceRoot))
   const persistentOpts: Parameters<typeof runPersistent>[0] = {
     command,
     cwd: node.projectDir,
@@ -566,7 +589,7 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   }
   // For a persistent task the timeout bounds the readiness wait. Per-task
   // `exec.timeout` wins; else the run-level default (env/workspace/--timeout).
-  const effectiveTimeout = step.timeout ?? args.timeout
+  const effectiveTimeout = taskTimeoutMs(step) ?? args.timeout
   if (effectiveTimeout !== undefined) {
     persistentOpts.timeoutMs = effectiveTimeout
   }
@@ -617,7 +640,8 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   // it fails, and with no `exec.timeout` the wait never ends, so a run
   // whose `readyWhen` never matched showed nothing at all.
   const readyWhen = step.persistent.readyWhen
-  const noticeMs = readyNoticeMs()
+  // How long a server may take to match `readyWhen` before vx says it waits.
+  const noticeMs = args.readyNotice ?? 10_000
   const notice =
     readyWhen === undefined
       ? undefined
@@ -660,7 +684,7 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
     const message = err instanceof Error ? err.message : String(err)
     // The task's OWN stream, not the process's: the frame is where a
     // reader looks for why a task failed, and a run with a custom logger
-    // (an embedder, the MCP server) never saw a bare stderr write at all.
+    // (an embedder) never saw a bare stderr write at all.
     log.taskStderr(node, `\n[vx] ${node.id}: persistent task failed to become ready: ${message}\n`)
     // A server is never traced, so the sandbox's refusals reach no report:
     // a dev server that died on a file outside its grants read only as the
@@ -724,7 +748,9 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   }
   args.persistentRegistry?.set(node.id, spawn.child)
   forgetUndeclaredWrites(args, undeclaredWriteReach(node, args.workspaceRoot))
-  if (mayWriteFingerprint(node, args.workspaceRoot)) args.fingerprintWatch?.wrote()
+  if (mayWriteFingerprint(node, args.workspaceRoot, claimedFiles(args))) {
+    args.fingerprintWatch?.wrote()
+  }
   return {
     node,
     status: 'success',
@@ -795,10 +821,9 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const outputs = cacheCfg?.outputs.files ?? []
   const wsOutputs = cacheCfg?.outputs.workspaceFiles ?? []
   const effectiveForwardArgs = node.requested ? (args.forwardArgs ?? []) : []
-  // Timeout precedence: per-task `exec.timeout` → run-level default
-  // (`--timeout`/`RunOptions.timeout` → `VX_TASK_TIMEOUT` → workspace
-  // `timeout`, already collapsed into `args.timeout` by run.ts).
-  const effectiveTimeout = step.timeout ?? args.timeout
+  // Per-task `exec.timeout` beats `run.timeout` (flag, variable,
+  // workspace; resolved into `args.timeout` by run.ts).
+  const effectiveTimeout = taskTimeoutMs(step) ?? args.timeout
   // `signal` stops a plugin executor on the run's stop AND on
   // `exec.timeout`: core cannot kill a process an executor spawned, so a
   // declared timeout meant nothing on one that kept its own clock (H-12).
@@ -910,7 +935,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       node,
       upstream,
       workspaceRoot: args.workspaceRoot,
-      workspaceFingerprint: args.workspaceFingerprint,
       cache,
       forwardArgs: args.forwardArgs,
       nestedProjectDirs: args.nestedProjectDirs,
@@ -941,8 +965,13 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     projectDir: node.projectDir,
     outputs,
     nestedProjectDirs: args.nestedProjectDirs,
+    committed: committedFiles(args.gitFilesCache, node.projectDir),
+  }
+  const wsCleanArgs = {
+    workspaceRoot: args.workspaceRoot,
+    outputs: wsOutputs,
+    committed: committedFiles(args.gitFilesCache, args.workspaceRoot),
   }
-  const wsCleanArgs = { workspaceRoot: args.workspaceRoot, outputs: wsOutputs }
   // An ADDITIVE task (its outputs overlap an upstream's, with the edge that
   // orders them; item 588) does not clean by glob — the glob selects the
   // upstream's files it adds beside. Its outputs are stamped once before
@@ -952,6 +981,12 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const additive = (node.addsToOutputsOf?.length ?? 0) > 0
   let stampedBefore: ReadonlyMap<string, OutputStamp> | undefined
   let wsStampedBefore: ReadonlyMap<string, OutputStamp> | undefined
+  // `cache.outputs.clean: false` leaves the outputs to the first attempt's
+  // command, and the save stores whatever they hold after it, a leftover
+  // included: the user opted out of the clean-tree guarantee (M,
+  // 2026-10-15). A retry still starts clean. An additive task never cleans
+  // by glob anyway.
+  const keepOutputs = !additive && (cacheCfg?.outputs.clean ?? args.cleanOutputs ?? true) === false
 
   // Cache lookup. On hit, time the user-perceived restore op
   // (clean+restore+log-replay) — that's what the framed-block footer
@@ -990,7 +1025,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         node,
         upstream,
         workspaceRoot: args.workspaceRoot,
-        workspaceFingerprint: args.workspaceFingerprint,
         cache,
         forwardArgs: args.forwardArgs,
         nestedProjectDirs: args.nestedProjectDirs,
@@ -1002,6 +1036,41 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
           : {}),
       })
     : undefined
+  /** The other command that may have put a moved input back (`ownRewrite`). */
+  let rewroteBy: string | undefined
+  /**
+   * Under `'mutable'`, a write during the command that left the key's bytes
+   * is the task's own identical rewrite only if no other command that may
+   * write the file ran between the describe and that write: one that did
+   * may have changed it and put it back while this command read it.
+   */
+  const ownRewrite = (file: string, ctimeMs: number): boolean => {
+    rewroteBy = args.commandWindows?.writerDuring(
+      node.id,
+      file,
+      described!.describedAt,
+      ctimeMs + racyWindowMs(ctimeMs, 0),
+    )
+    return rewroteBy === undefined
+  }
+
+  /**
+   * A committed file under the task's own outputs is keyed (`committedFiles`)
+   * and the task may rewrite it (TanStack Router's `routeTree.gen.ts`): the
+   * bytes it leaves are an output the entry saves and a restore writes, and
+   * they follow from the key, so their change is no moved input.
+   */
+  const ownOutput = outputs.length === 0 ? undefined : outputMatcher(outputs)
+  const ownWsOutput = wsOutputs.length === 0 ? undefined : outputMatcher(wsOutputs)
+  const keyedInputs = (facts: readonly InputFact[]): readonly InputFact[] =>
+    ownOutput === undefined && ownWsOutput === undefined
+      ? facts
+      : facts.filter(
+          (f) =>
+            ownOutput?.(relPosix(node.projectDir, f.path)) !== true &&
+            ownWsOutput?.(relPosix(args.workspaceRoot, f.path)) !== true,
+        )
+
   // A name only `exec.env.secret` makes secret is not one the name rule
   // sees later: its row carries the mark, so `vx why` hides its hash (M-63).
   const named = node.config.exec?.env?.secret
@@ -1061,7 +1130,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   let withheld: WithheldLink[] = []
 
   // Cache miss path (or caching disabled), up to `1 + retries` attempts.
-  // Explicit config wins over the run-level `--retry` default, including
+  // Explicit config wins over the run-level `--retries` default, including
   // an explicit `retries: 0`.
   const maxAttempts = 1 + (step.retries ?? args.retries ?? 0)
   let attempt = 0
@@ -1084,6 +1153,8 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     exitCode: number
     withdrawn?: true
   }> {
+    // The first attempt under `clean: false` finds its last outputs (tsc's `.tsbuildinfo`).
+    const clean = willWrite && !deferralRequested && !(keepOutputs && attempt === 1)
     // A deferred task's outputs are deliberately NOT coming, so wiping the
     // tree would replace a stale build with nothing at all. The eligibility
     // gate guarantees no key in this run can see what stays behind, and the
@@ -1092,7 +1163,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       const endStamp = span('miss: stamp outputs')
       stampedBefore ??= await stampOutputs(cleanArgs)
       endStamp()
-    } else if (willWrite && !deferralRequested && outputs.length > 0) {
+    } else if (clean && outputs.length > 0) {
       // Mark the wiped paths, exactly as the workspace twin below does. The
       // git snapshot still lists them with their committed index OIDs, and
       // resolveFiles SKIPS its existence probe for any path carrying a
@@ -1102,7 +1173,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       const endClean = span('miss: clean outputs')
       const cleanedRels = await cleanOutputs(cleanArgs)
       endClean()
-      args.gitFilesCache?.noteClean(node.id, node.projectDir, cleanedRels)
       args.gitFilesCache?.markOutputsChanged(node.projectDir, cleanedRels)
     }
     if (additive && willWrite && !deferralRequested && wsOutputs.length > 0) {
@@ -1110,7 +1180,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       // glob clean deleted the upstream's files before this task, which
       // reads them, ran (A-43).
       wsStampedBefore ??= await stampWorkspaceOutputs(wsCleanArgs)
-    } else if (willWrite && !deferralRequested && wsOutputs.length > 0) {
+    } else if (clean && wsOutputs.length > 0) {
       // Root-anchored deletions can land in other projects' dirs; mark
       // them so stale per-project git snapshots can't survive the wipe.
       const cleanedWsRels = await cleanWorkspaceOutputs(wsCleanArgs)
@@ -1139,6 +1209,12 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     // the throw is its rejection, the value its resolution, so both reach
     // the naming catch and the cleanup in finally below.
     let running: Promise<unknown>
+    const closeWindow =
+      args.commandWindows?.open(
+        node.id,
+        node.projectDir,
+        commandWriteReach(node, args.workspaceRoot),
+      ) ?? (() => {})
     try {
       running = Promise.resolve(args.executor.execute(req))
     } catch (thrown) {
@@ -1177,6 +1253,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         throw err
       })
       .finally(() => {
+        closeWindow()
         clearTimeout(timeoutTimer)
         unlistenStop?.()
         unlistenStop = undefined
@@ -1267,18 +1344,6 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       // The line quotes the command's first word, which a config may have
       // built from a secret: masked as the task's own output is (L-37).
       if (verdict !== undefined) log.taskStderr(node, `\n${secrets?.mask(verdict) ?? verdict}\n`)
-      // A committed file another task's clean removed, still gone: vx
-      // cleans outputs before a run where Turbo does not, so a reader with
-      // no edge to the producer fails naming only the file (A-48).
-      if (code !== 0) {
-        for (const c of (args.gitFilesCache?.trackedCleansMissing(node.id) ?? []).slice(0, 3)) {
-          const rel = relPosix(args.workspaceRoot, c.path)
-          log.taskStderr(
-            node,
-            `\n[vx] ${rel} is tracked by git, and ${c.by} removed it as an output before its run; it is still missing. A task that reads it needs dependsOn on ${c.by}.\n`,
-          )
-        }
-      }
     }
     return { result: res, exitCode: code }
   }
@@ -1327,7 +1392,8 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const writeReach =
     args.executor.remote === true ? 'none' : undeclaredWriteReach(node, args.workspaceRoot)
   const writesFingerprint =
-    args.executor.remote !== true && mayWriteFingerprint(node, args.workspaceRoot)
+    args.executor.remote !== true &&
+    mayWriteFingerprint(node, args.workspaceRoot, claimedFiles(args))
   // A stop that landed during the awaits above (the key, the probe, the
   // input description): the first attempt would wipe the last build and
   // hand the executor a request after the run had stopped. Through a call,
@@ -1404,9 +1470,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   }
 
   async function buildRequest(local: boolean): Promise<ExecuteRequest> {
-    const kept = willSave
-      ? new BoundedCapture()
-      : new BoundedCapture(FAILED_OUTPUT_HEAD_CHARS, FAILED_OUTPUT_TAIL_CHARS)
+    const kept =
+      willSave || args.keepRunLog === true
+        ? new BoundedCapture()
+        : new BoundedCapture(FAILED_OUTPUT_HEAD_CHARS, FAILED_OUTPUT_TAIL_CHARS)
     output = kept
     const toOut = (t: string): void => {
       kept.push(t)
@@ -1474,8 +1541,9 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const wallclockEndNs = process.hrtime.bigint() - args.runStartHrTimeNs
 
   const stability = inputStabilityOf(args.node.config.cache, args.inputStability)
-  let movedFails = false
+  let movedFails: string | undefined
   let own: Awaited<ReturnType<typeof ownOutputs>>
+  let saved = false
   if (effectiveExitCode === 0 && willSave && deferralRequested) {
     // The outputs never landed here: no artifact, no rows. A partial local
     // record (a row with no artifact) is exactly the corrupt-entry shape
@@ -1527,8 +1595,19 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       deferSave: args.deferSave,
       // A sink listens: say what the save cost.
       measure: args.explainMiss !== undefined,
+      ...(userSandbox
+        ? {
+            readable: sandboxReadable(
+              node,
+              cfg.exec!.sandbox!,
+              args.workspaceRoot,
+              args.nestedProjectDirs,
+            ),
+          }
+        : {}),
     })
     args.deferredSaves?.set(node.id, landed)
+    saved = true
   } else if (cfgCacheable && !remoteOnly && !deferralRequested && args.noDependants !== true) {
     // Ran here and saves nothing — failed, a read-only policy, a tainted
     // upstream, a key that no longer held — yet it wrote what a save would
@@ -1586,10 +1665,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     if (described!.hash !== hash) return null
     return (
       (await movedInput(
-        described!.facts,
+        keyedInputs(described!.facts),
         cache,
         described!.describedAt,
-        stability.strategy === 'mutable',
+        stability.strategy === 'mutable' ? ownRewrite : undefined,
       )) ?? described!.added()
     )
   }
@@ -1619,24 +1698,25 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     endCheck()
     if (moved === undefined) return true
     const what =
-      moved === null ? 'its inputs' : `\`${printable(relPosix(args.workspaceRoot, moved))}\``
+      (moved === null ? 'its inputs' : `\`${printable(relPosix(args.workspaceRoot, moved))}\``) +
+      ' changed after its key was taken' +
+      (rewroteBy === undefined ? '' : ` while ${rewroteBy} ran`)
     // A task that regenerates its own input (TanStack Router's committed
     // `routeTree.gen.ts`, rewritten to the same bytes by every build) is
     // never saved (item 1015), and the line said so without the way out.
-    // Not for `package.json`, which an output may not cover.
     const hint =
-      moved === null || path.basename(moved) === 'package.json'
+      moved === null || rewroteBy !== undefined
         ? ''
         : '; if the task writes it, declare it in cache.outputs'
     if (stability.severity === 'error') {
       log.status(
-        `[vx] ${node.id}: ${what} changed after its key was taken — the result is not saved, ` +
+        `[vx] ${node.id}: ${what} — the result is not saved, ` +
           `and inputStability.severity is 'error', so the task fails${hint}`,
       )
-      movedFails = true
+      movedFails = moved === null ? '' : printable(relPosix(args.workspaceRoot, moved))
     } else {
       log.status(
-        `[vx] ${node.id}: ${what} changed after its key was taken — the result stands, ` +
+        `[vx] ${node.id}: ${what} — the result stands, ` +
           `but is not saved under a key that no longer describes it${hint}`,
       )
     }
@@ -1645,7 +1725,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     return false
   }
 
-  if (movedFails) effectiveExitCode = 1
+  if (movedFails !== undefined) effectiveExitCode = 1
 
   if (unkeyedUpstream !== undefined && willWrite && effectiveExitCode === 0) {
     log.status(
@@ -1670,10 +1750,15 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       : {}),
     ...(inputChanges !== undefined ? { inputChanges } : {}),
     ...(unkeyed ? { unkeyed: true as const } : {}),
+    ...(saved ? { saved: true as const } : {}),
     ...(effectiveExitCode !== 0 && output !== undefined
-      ? { failedOutput: failedOutputLog(output, willSave) }
+      ? { failedOutput: failedOutputLog(output, willSave || args.keepRunLog === true) }
+      : {}),
+    ...(args.keepRunLog === true && (effectiveExitCode !== 0 || !willSave) && output !== undefined
+      ? { runLog: storedOutput() }
       : {}),
     ...(result.timedOut === true && effectiveExitCode !== 0 ? { timedOut: true as const } : {}),
+    ...(movedFails !== undefined ? { inputMoved: movedFails } : {}),
     ...(result.cpuMs !== undefined ? { cpuMs: result.cpuMs } : {}),
     ...(result.peakRssBytes !== undefined ? { peakRssBytes: result.peakRssBytes } : {}),
     ...(result.where !== undefined ? { where: result.where } : {}),
@@ -1704,7 +1789,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
 /**
  * Drop the run's facts about files a task may have written without
  * declaring them (`undeclaredWriteReach`): the project's git snapshot and
- * its index OIDs, and its `package.json` digest. The next reader
+ * its index OIDs. The next reader
  * re-enumerates the project (one `git ls-files`) and hashes its files by
  * content; the per-declaration file-list memos are keyed on the snapshot
  * array, so they miss with it (item 743).
@@ -1713,12 +1798,10 @@ function forgetUndeclaredWrites(args: ExecuteArgs, reach: 'none' | 'project' | '
   if (reach === 'none') return
   if (reach === 'workspace') {
     args.gitFilesCache?.clear()
-    args.hashCache?.packageJson.clear()
     return
   }
   args.gitFilesCache?.delete(args.node.projectDir)
   args.gitFilesCache?.invalidateWorkspacePartition()
-  args.hashCache?.packageJson.delete(args.node.projectDir)
 }
 
 /** The two bin directories a task's PATH starts with: its own, then the root's (once when they coincide). */
@@ -1765,16 +1848,11 @@ function taskEnv(node: TaskNode, step: ExecConfig, workspaceRoot: string): NodeJ
   return env
 }
 
-function isAborted(signal: AbortSignal | undefined): boolean {
-  return signal?.aborted === true
+/** A task's own `exec.timeout` in ms; the schema has checked its form. */
+function taskTimeoutMs(step: ExecConfig): number | undefined {
+  return step.timeout === undefined ? undefined : parseDuration(step.timeout)!
 }
 
-/**
- * How long a server may take to match `readyWhen` before vx says it waits.
- * `VX_READY_NOTICE_MS` overrides it, as `VX_KILL_GRACE_MS` does the grace.
- */
-function readyNoticeMs(): number {
-  const raw = process.env['VX_READY_NOTICE_MS']
-  if (raw !== undefined && /^[0-9]+$/.test(raw) && Number(raw) > 0) return Number(raw)
-  return 10_000
+function isAborted(signal: AbortSignal | undefined): boolean {
+  return signal?.aborted === true
 }

package/src/orchestrator/failure-mode.ts

@@ -4,7 +4,9 @@
 // drift into opposite verdicts on identical data. Both build on
 // `mixedOutcomeKeysSql` + `failureModeOf`, so the rule cannot fork again.
 // The per-run detector (`detectFlaky`) and the doctor's list (`flakyTasks`)
-// read the same per-key projection (`keyOutcomesSql`).
+// read the same per-key projection (`keyOutcomesSql`) over the shared
+// store's flaky record (`task_outcomes`, v38), so every worktree of a repo
+// judges a key on what all of them saw.
 
 import type { Database } from 'bun:sqlite'
 import { KEYED_RUNS_SQL } from '../cache/index.js'
@@ -17,6 +19,9 @@ const HIT_STATUSES = `(${TASK_STATUSES.filter(isCacheHit)
   .map((s) => `'${s}'`)
   .join(', ')})`
 
+/** The shared store's flaky record: what `detectFlaky` and `flakyTasks` read. */
+const OUTCOMES = 'task_outcomes'
+
 export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
 
 /**
@@ -33,6 +38,10 @@ export type FailureMode = 'stable' | 'flaky-recoverable' | 'flaky-fatal'
  * projection.
  */
 function keyOutcomesSql(source: string, where = ''): string {
+  // The flaky record keeps only rows that observed their key (run-history.ts
+  // `observesKey`), so it carries none of the filter's columns.
+  const keyed =
+    source === OUTCOMES ? '1' : `${KEYED_RUNS_SQL} AND cached IS NOT 0 AND blocked_by IS NULL`
   return `SELECT project, task, hash, SUM(failed) AS failures, SUM(passed) AS passes,
        SUM(retried) AS retried_failures,
        SUM(CASE WHEN failed = 1 AND id > first_pass THEN 1 ELSE 0 END) AS relapses
@@ -41,10 +50,10 @@ function keyOutcomesSql(source: string, where = ''): string {
          FROM (SELECT project, task, hash, id,
              CASE WHEN status = 'failed' THEN 1 ELSE 0 END AS failed,
              CASE WHEN status = 'success' AND attempts > 1 THEN attempts - 1 ELSE 0 END AS retried,
-             CASE WHEN status = 'success' OR status IN ${HIT_STATUSES} OR cache_hit = 1
+             CASE WHEN status = 'success' OR status IN ${HIT_STATUSES}${source === OUTCOMES ? '' : ' OR cache_hit = 1'}
                THEN 1 ELSE 0 END AS passed
            FROM ${source}
-           WHERE ${KEYED_RUNS_SQL} AND cached IS NOT 0 AND blocked_by IS NULL${where}))
+           WHERE ${keyed}${where}))
        GROUP BY project, task, hash`
 }
 
@@ -136,9 +145,9 @@ const keyOf = (c: { project: string; task: string; hash: string }): string =>
  * failures is a recovery, not a flake. The counts fold this run in.
  *
  * The cost follows the run's colour. No candidate (every task a hit or a
- * skip): no query. A green miss: one probe of the `runs_failed` partial
- * index for the keys that ever failed — failures are the rare rows, so the
- * probe is microseconds however long the history. Only a key that DID fail
+ * skip): no query. A green miss: one probe of the `task_outcomes_hash`
+ * index for the keys that ever failed — a key holds a handful of rows, so
+ * the probe is microseconds however long the history. Only a key that DID fail
  * before, or a task failing now, pays the projection scan over its own
  * keys, and a run that is failing has more to look at than a scan.
  */
@@ -149,8 +158,8 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   chunked(passedNow, (chunk) => {
     const rows = db
       .query(
-        `SELECT DISTINCT project, task, hash FROM runs
-         WHERE status = 'failed' AND blocked_by IS NULL AND hash IN (${chunk.map(() => '?').join(', ')})`,
+        `SELECT DISTINCT project, task, hash FROM ${OUTCOMES}
+         WHERE status = 'failed' AND hash IN (${chunk.map(() => '?').join(', ')})`,
       )
       .all(...chunk.map((c) => c.hash)) as { project: string; task: string; hash: string }[]
     for (const r of rows) everFailed.add(keyOf(r))
@@ -162,7 +171,7 @@ export function detectFlaky(db: Database, candidates: readonly FlakyCandidate[])
   const counts = new Map<string, { passes: number; failures: number; relapses: number }>()
   chunked(suspects, (chunk) => {
     const rows = db
-      .query(keyOutcomesSql('runs', ` AND hash IN (${chunk.map(() => '?').join(', ')})`))
+      .query(keyOutcomesSql(OUTCOMES, ` AND hash IN (${chunk.map(() => '?').join(', ')})`))
       .all(...chunk.map((c) => c.hash)) as {
       project: string
       task: string
@@ -212,7 +221,7 @@ export function flakyTasks(db: Database): FlakyTask[] {
     .query(
       `SELECT project, task, COUNT(*) AS keys, SUM(passes) AS passes, SUM(failures) AS failures
        FROM (SELECT project, task, passes, failures + retried_failures AS failures
-             FROM (${keyOutcomesSql('runs')})
+             FROM (${keyOutcomesSql(OUTCOMES)})
              WHERE relapses > 0 OR retried_failures > 0)
        GROUP BY project, task
        ORDER BY failures DESC, passes DESC, project, task`,