@vzn/vx 0.0.424 → 0.0.425

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.424",
+  "version": "0.0.425",
   "description": "The fastest task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.424",
-    "@vzn/vx-linux-arm64": "0.0.424",
-    "@vzn/vx-darwin-x64": "0.0.424",
-    "@vzn/vx-darwin-arm64": "0.0.424"
+    "@vzn/vx-linux-x64": "0.0.425",
+    "@vzn/vx-linux-arm64": "0.0.425",
+    "@vzn/vx-darwin-x64": "0.0.425",
+    "@vzn/vx-darwin-arm64": "0.0.425"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/execute-task.ts

@@ -160,6 +160,12 @@ export interface ExecuteArgs {
    * Absent → probe lazily, exactly as today (unstable / unclassified).
    */
   preProbed?: { hash: string; hit: CacheEntry | null }
+  /**
+   * An uncached task's key as the up-front pass derived it, present only
+   * when no upstream can change it (`deriveStableKeys`' `uncachedKeys`):
+   * used verbatim instead of deriving the same key again.
+   */
+  upfrontKey?: string
   /**
    * Start the sandbox runtime, on the first task that executes inside one
    * (run.ts, `prepareSandbox`). Absent when no task in the run declares a
@@ -274,7 +280,8 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const hash =
     args.noDependants === true
       ? undefined
-      : await computeTaskHash({
+      : (args.upfrontKey ??
+        (await computeTaskHash({
           node,
           upstream: args.upstream,
           workspaceRoot: args.workspaceRoot,
@@ -284,7 +291,7 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
           nestedProjectDirs: args.nestedProjectDirs,
           ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
           ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
-        })
+        })))
 
   // The args after `--` reach a server as they reach any task. A readyWhen
   // server once got none — "so the matcher sees the unmodified output",
@@ -658,19 +665,19 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   // authoritative stable key) and skip the probe below.
   const preProbed = args.preProbed
   const hash =
-    preProbed !== undefined
-      ? preProbed.hash
-      : await computeTaskHash({
-          node,
-          upstream,
-          workspaceRoot: args.workspaceRoot,
-          workspaceFingerprint: args.workspaceFingerprint,
-          cache,
-          forwardArgs: args.forwardArgs,
-          nestedProjectDirs: args.nestedProjectDirs,
-          ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
-          ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
-        })
+    preProbed?.hash ??
+    args.upfrontKey ??
+    (await computeTaskHash({
+      node,
+      upstream,
+      workspaceRoot: args.workspaceRoot,
+      workspaceFingerprint: args.workspaceFingerprint,
+      cache,
+      forwardArgs: args.forwardArgs,
+      nestedProjectDirs: args.nestedProjectDirs,
+      ...(args.gitFilesCache !== undefined ? { gitFilesCache: args.gitFilesCache } : {}),
+      ...(args.hashCache !== undefined ? { hashCache: args.hashCache } : {}),
+    }))
 
   // The local no-op half of `exec.remote: 'only'`: no remote executor took
   // the task, so it succeeds without running. The hash was still computed —

package/src/orchestrator/local-shortcircuit.ts

@@ -84,10 +84,14 @@ export interface ShortCircuit {
    * with a non-null hit, minus the workspace-outputs exclusion).
    */
   restoreTier: Set<string>
+  /**
+   * Uncached task id → its up-front key, for the tasks whose key no
+   * upstream can change: execute-task reuses it instead of deriving it
+   * again (`deriveStableKeys`' `uncachedKeys`).
+   */
+  uncachedKeys: Map<string, string>
 }
 
-const EMPTY: ShortCircuit = { preProbed: new Map(), restoreTier: new Set() }
-
 /**
  * Classify the graph's stable tasks: derive keys + probe local ONCE,
  * returning the `preProbed` map (probe reuse) and the `restoreTier` set
@@ -99,11 +103,12 @@ const EMPTY: ShortCircuit = { preProbed: new Map(), restoreTier: new Set() }
  */
 export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<ShortCircuit> {
   let stableKeys
+  const uncachedKeys = new Map<string, string>()
   const endKeys = span('stable keys')
   try {
-    stableKeys = await deriveStableKeys(args)
+    stableKeys = await deriveStableKeys({ ...args, uncachedKeys })
   } catch {
-    return EMPTY
+    return { preProbed: new Map(), restoreTier: new Set(), uncachedKeys: new Map() }
   } finally {
     endKeys()
   }
@@ -111,12 +116,17 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   // `cacheEnabled && !unstable` (item 640 deleted a second filter here and
   // nothing reddened).
   const candidates = stableKeys
-  if (candidates.length === 0) return EMPTY
-
-  const keptOut = restoreTierExclusions(args.nodes, args.workspaceRoot)
-
   const preProbed = new Map<string, ProbedEntry>()
   const restoreTier = new Set<string>()
+  if (candidates.length === 0 && uncachedKeys.size === 0) {
+    return { preProbed, restoreTier, uncachedKeys }
+  }
+
+  const keptOut = restoreTierExclusions(args.nodes, args.workspaceRoot)
+  // A root-anchored output may land in a project no edge leads from, so an
+  // uncached key there is derived again once the writer may have run.
+  for (const id of keptOut) uncachedKeys.delete(id)
+  if (candidates.length === 0) return { preProbed, restoreTier, uncachedKeys }
 
   // Bounded pool over the stable candidates: probe local ONCE each. A
   // confirmed hit becomes restore-tier (unless workspace outputs disable
@@ -135,7 +145,7 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
         preProbed.set(node.id, { hash, hit })
         if (hit !== null && !keptOut.has(node.id)) restoreTier.add(node.id)
       }
-      return { preProbed, restoreTier }
+      return { preProbed, restoreTier, uncachedKeys }
     } catch {
       // Fall through to the per-hash pool, which isolates a failing probe
       // to its own task.
@@ -159,7 +169,7 @@ export async function startLocalShortCircuit(args: ShortCircuitArgs): Promise<Sh
   }
   await Promise.all(Array.from({ length: workers }, () => pump()))
 
-  return { preProbed, restoreTier }
+  return { preProbed, restoreTier, uncachedKeys }
 }
 
 /**

package/src/orchestrator/run.ts

@@ -103,7 +103,11 @@ import type { RunOptions, RunSummary } from './options.js'
 
 // Per run, never shared: a `vx watch` process runs many, and a shared map
 // is one `preProbed.set` away from leaking a hit across cycles.
-const emptyShortCircuit = (): ShortCircuit => ({ preProbed: new Map(), restoreTier: new Set() })
+const emptyShortCircuit = (): ShortCircuit => ({
+  preProbed: new Map(),
+  restoreTier: new Set(),
+  uncachedKeys: new Map(),
+})
 
 /**
  * Parse the `VX_TASK_TIMEOUT` env var (ms) — the "global" run-level task
@@ -891,6 +895,7 @@ async function runOnBus(
 
     const buildExecuteArgs = (node: TaskNode, upstream: TaskOutcome[], reuseProbe = true) => {
       const probe = reuseProbe ? shortCircuit.preProbed.get(node.id) : undefined
+      const upfrontKey = shortCircuit.uncachedKeys.get(node.id)
       if (
         options.continueMode === 'always' &&
         node.deps.some((d) => deadServerBehind(nodes, serverDied, d) !== undefined)
@@ -921,6 +926,7 @@ async function runOnBus(
         gitFilesCache,
         hashCache,
         ...(probe !== undefined ? { preProbed: probe } : {}),
+        ...(upfrontKey !== undefined ? { upfrontKey } : {}),
         ...(tainted ? { taintedUpstream: true } : {}),
         ...(dependedOn.has(node.id) ? {} : { noDependants: true as const }),
         fingerprintWatch,

package/src/orchestrator/stable-keys.ts

@@ -27,6 +27,11 @@ export interface DeriveStableKeysArgs {
   nestedDirsByProject: Map<string, string[]>
   gitFilesCache: GitFilesCache
   hashCache: HashCache
+  /**
+   * Filled with each uncached task's key when no upstream can write where
+   * that key reads, so execute-task need not derive it a second time.
+   */
+  uncachedKeys?: Map<string, string>
 }
 
 export interface StableKey {
@@ -237,6 +242,18 @@ export async function deriveStableKeys(args: DeriveStableKeysArgs): Promise<Stab
 
     const cacheEnabled = node.config.cache !== undefined
     if (cacheEnabled && !unstable) stableKeys.push({ hash, node })
+    // An uncached key reads its whole project, so `dependsOnSiblingOutputs`
+    // (which answers false for it) is not the gate: any upstream that may
+    // write into this project, or anywhere, leaves the key preliminary.
+    else if (
+      !cacheEnabled &&
+      !unstable &&
+      !outputProjects.has(node.projectName) &&
+      unfolded?.has(node.projectName) !== true &&
+      !wsOutputUpstream &&
+      !wsUnfoldedHere
+    )
+      args.uncachedKeys?.set(id, hash)
   }
   return stableKeys
 }