@vzn/vx 0.0.423 → 0.0.425

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.423",
+  "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.423",
-    "@vzn/vx-linux-arm64": "0.0.423",
-    "@vzn/vx-darwin-x64": "0.0.423",
-    "@vzn/vx-darwin-arm64": "0.0.423"
+    "@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/cli/watch.ts

@@ -205,6 +205,11 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   const swept = await sweepConfigs(allProjects, workspaceRoot, load, opts.tasks)
   const watched = await watchedProjects(workspaceRoot, allProjects, scope, load, swept.staged)
   const ws = await loadCliWorkspace(workspaceRoot)
+  const claimsOf = (plugins: Parameters<typeof fingerprintClaims>[0]): Set<string> =>
+    new Set([
+      ...fingerprintClaims(plugins).keys(),
+      ...(opts.frozen === true ? [LOCKFILE_NAME] : []),
+    ])
   return await runWatchLoop({
     opts,
     held,
@@ -232,6 +237,10 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
       const now = await watchedProjects(workspaceRoot, all, inScope(all), load, sweep.staged)
       return {
         projects: now,
+        // A plugin the workspace config gained since claims its file from
+        // the cycle that loaded it; read once, its edits started nothing
+        // until a restart.
+        claimedRootFiles: claimsOf((await loadCliWorkspace(workspaceRoot)).plugins),
         memberBases: memberBaseDirs(workspace),
         workspaceWide: sweep.workspaceWide,
         workspaceInputs: sweep.workspaceInputs,
@@ -246,10 +255,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     // Under --frozen every cycle's configs are the lock's, so a re-lock is
     // the one edit that changes what a cycle runs; unheard, the loop ran
     // the old lock until a restart (item 971).
-    claimedRootFiles: new Set([
-      ...fingerprintClaims(ws.plugins).keys(),
-      ...(opts.frozen === true ? [LOCKFILE_NAME] : []),
-    ]),
+    claimedRootFiles: claimsOf(ws.plugins),
     // The RESOLVED cache dir, not the `.vx` literal — see `makeWatchIgnore`.
     cacheDir: opts.cacheDir ?? ws.cacheDir,
   })
@@ -296,6 +302,7 @@ interface WatchLoopArgs {
 
 interface Rediscovered {
   projects: readonly ProjectMeta[]
+  claimedRootFiles: ReadonlySet<string>
   memberBases: readonly string[]
   workspaceWide: boolean
   workspaceInputs: readonly string[]
@@ -319,6 +326,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   let outputs = args.outputs
   let inputs = args.inputs
   let uncached = args.uncached
+  let claimedRootFiles = args.claimedRootFiles
   let configImportFiles = args.configImports
   let wsConfigImportFiles = args.workspaceConfigImports
   // A dev server stays up while the loop idles; the cycle that replaces it
@@ -398,12 +406,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
   // project would otherwise trigger every save during `bun install` —
   // and vx's own cache writes would trigger a cycle that writes again.
   let isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-  let matters = makeRootEventFilter(
-    workspaceRoot,
-    projectDirs,
-    workspaceInputs,
-    args.claimedRootFiles,
-  )
+  let matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
   /** Since the last cycle, a member came or went, or a file that shapes the watched set changed (`shapesWatchedSet`). */
   let reread = false
 
@@ -466,7 +469,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
               isWorkspaceFingerprintFile(filename) ||
               isWorkspaceConfigFile(filename) ||
               filename === 'package.json' ||
-              args.claimedRootFiles.has(filename)
+              claimedRootFiles.has(filename)
             ) {
               if (shapesWatchedSet(filename) || filename === LOCKFILE_NAME) reread = true
               trigger(`root ${filename}`, path.join(workspaceRoot, filename))
@@ -608,18 +611,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
     outputs = next.outputs
     inputs = next.inputs
     uncached = next.uncached
+    claimedRootFiles = next.claimedRootFiles
     configImportFiles = next.configImports
     wsConfigImportFiles = next.workspaceConfigImports
     packageDirs = next.packageDirs
     memberBases = next.memberBases
     armBases()
     isIgnoredPath = makeWatchIgnore(cacheDir, outputs, inputs)
-    matters = makeRootEventFilter(
-      workspaceRoot,
-      projectDirs,
-      workspaceInputs,
-      args.claimedRootFiles,
-    )
+    matters = makeRootEventFilter(workspaceRoot, projectDirs, workspaceInputs, claimedRootFiles)
     if (next.workspaceWide !== workspaceWide) {
       // A task started or stopped declaring `workspaceFiles`: the other
       // arm's shape. Until item 891 the choice was made once, at start, and

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
 }

package/src/workspace/migration.ts

@@ -256,6 +256,18 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
   const configName = `vx.config.${format}`
   const workspaceName = `vx.workspace.${format}`
   const empty = plan.projects.length === 0
+  // `vx init` never overwrites a member's config: a half-adopted workspace
+  // keeps each one it has, by name, and gets the rest (M-52). It refused
+  // the whole workspace, and `--force` would have replaced the hand-written
+  // file; `--force` still replaces, as asked.
+  const kept: string[] = []
+  const projects = plan.projects.filter((p) => {
+    if (!init || force || p.tasks.length === 0) return true
+    const existing = metas.find((m) => m.dir === p.dir)?.configPath
+    if (!existing) return true
+    kept.push(relPosix(root, existing))
+    return false
+  })
   if (empty && !init) {
     throw new UserError(
       `nothing to migrate: no ${source === 'package.json scripts' ? 'package.json scripts in any workspace member' : 'tasks in ' + source}`,
@@ -263,7 +275,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
   }
 
   const files: { relPath: string; abs: string; contents: string }[] = []
-  for (const p of plan.projects) {
+  for (const p of projects) {
     if (p.tasks.length === 0) continue
     const abs = path.join(p.dir, configName)
     files.push({
@@ -291,7 +303,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
     const conflicts = new Set<string>()
     // A discovered project with ANY existing vx config (.ts/.mjs/.js) — refuse
     // so we never shadow a hand-written config with a fresh .ts.
-    for (const p of plan.projects) {
+    for (const p of projects) {
       if (p.tasks.length === 0) continue
       const meta = metas.find((m) => m.dir === p.dir)
       if (meta?.configPath) conflicts.add(relPosix(root, meta.configPath))
@@ -316,7 +328,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
   // order, and the report said "written" for a file the run never loaded
   // (item 1033).
   const replaced: string[] = []
-  for (const p of plan.projects) {
+  for (const p of projects) {
     if (p.tasks.length === 0) continue
     const existing = metas.find((m) => m.dir === p.dir)?.configPath
     if (existing && existing !== path.join(p.dir, configName)) replaced.push(existing)
@@ -337,7 +349,7 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
   let todoCount = 0
   let clean = 0
   let cached = false
-  for (const p of plan.projects) {
+  for (const p of projects) {
     for (const t of p.tasks) {
       if (t.todos.length === 0 && t.task !== null) clean++
       if (t.task !== null && 'cache' in t.task) cached = true
@@ -408,8 +420,13 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
       }
     }
     report.push(...plan.notes)
-    report.push(dry ? 'files (dry run, nothing written):' : 'files written:')
+    if (files.length === 0) report.push(dry ? 'no files (dry run)' : 'no files written')
+    else report.push(dry ? 'files (dry run, nothing written):' : 'files written:')
     for (const f of files) report.push(`  ${f.relPath}`)
+    if (kept.length > 0) {
+      report.push('kept (each already has a vx config):')
+      for (const f of kept) report.push(`  ${f}`)
+    }
     if (replaced.length > 0) {
       report.push(dry ? 'would replace (dry run):' : 'replaced:')
       for (const f of replaced) report.push(`  ${relPosix(root, f)}`)