@vzn/vx 0.0.66 → 0.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.66",
-    "@vzn/vx-linux-arm64": "0.0.66",
-    "@vzn/vx-darwin-x64": "0.0.66",
-    "@vzn/vx-darwin-arm64": "0.0.66"
+    "@vzn/vx-linux-x64": "0.0.68",
+    "@vzn/vx-linux-arm64": "0.0.68",
+    "@vzn/vx-darwin-x64": "0.0.68",
+    "@vzn/vx-darwin-arm64": "0.0.68"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cli/watch.ts

@@ -292,7 +292,13 @@ export function pollWatcher(
         }
         if (!e.isFile()) continue
         try {
-          current.set(childRel, fs.statSync(path.join(abs, e.name)).mtimeMs)
+          // The later of the two clocks, as `modifiedBefore` reads them: a
+          // replacement that carries the old file's mtime (`cp -p`, `rsync
+          // -a`, `mv` of a file stamped the same) moved nothing under mtime
+          // alone, and the poller never ran it where the native watcher did.
+          // A rename or a write moves ctime, and no process can set it.
+          const st = fs.statSync(path.join(abs, e.name))
+          current.set(childRel, Math.max(st.mtimeMs, st.ctimeMs))
         } catch {
           // raced with a delete; the next scan settles it
         }

package/src/exec/executor.ts

@@ -190,7 +190,8 @@ export interface TaskExecutor {
   /**
    * How many tasks this executor runs at once. Its tasks then occupy a pool
    * of this size instead of the local worker slots, so a remote pool is not
-   * throttled by the local CPU count. Absent = the local pool.
+   * throttled by the local CPU count. A positive integer; anything else
+   * is refused when the executor is resolved. Absent = the local pool.
    */
   readonly capacity?: number
   /** Per-task opt-out at placement time. Absent = accepts every task it is offered. */

package/src/graph/scheduler.ts

@@ -76,6 +76,13 @@ export interface TaskOutcome {
    * outcomes only; never folded into any key.
    */
   groupUpstream?: readonly TaskOutcome[]
+  /**
+   * This task RAN over inputs its key no longer describes: one moved while
+   * it ran, the workspace fingerprint moved, or an upstream carried this
+   * mark. Its save was withheld, and its outputs are not what `hash` names,
+   * so a dependant that folds `hash` saves nothing either (A-12).
+   */
+  unkeyed?: true
   /**
    * On a `skipped` outcome: the task at the ROOT of what blocked it — the
    * failed (or aborted) upstream, followed through any chain of skips

package/src/orchestrator/execute-task.ts

@@ -62,6 +62,7 @@ import {
   type TaskInputComponent,
 } from './task-hash.js'
 import { getContext } from './remote-prefetch.js'
+import { expandGroupUpstream, filterUpstreamHashes } from './upstream.js'
 
 export interface ExecuteArgs {
   node: TaskNode
@@ -412,8 +413,27 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   const willRead = !remoteOnly && cfgCacheable && (policy.localRead || policy.remoteRead)
   const willWrite = !remoteOnly && cfgCacheable && (policy.localWrite || policy.remoteWrite)
   // `willWrite` governs output hygiene (clean before exec); the save itself
-  // is also withheld from a task downstream of a failure (see `taintedUpstream`).
-  const willSave = willWrite && args.taintedUpstream !== true
+  // is also withheld from a task downstream of a failure (see `taintedUpstream`),
+  // and from one downstream of a task that ran over inputs its key no longer
+  // describes: this key folds that upstream's key, while the bytes on disk
+  // are not the ones that key names. With `a.txt` edited while `gen` ran,
+  // `gen` withheld its save, `use` saved over the edit under a key folding
+  // `gen`'s, and once `a.txt` was put back `use` hit the edit's output (A-12).
+  // Only an upstream whose key this one folds: one read by content
+  // (`tasks: []` and a file input) is judged by its bytes. `upstream` holds
+  // a hole where a dependency did not run (a skipped one, a restore-tier
+  // task's unfinished deps).
+  const present = upstream.filter((u): u is TaskOutcome => u !== undefined)
+  const folded = new Set(
+    filterUpstreamHashes(present, cacheCfg?.inputs?.tasks, node.projectName, node.id).map(
+      ([id]) => id,
+    ),
+  )
+  const unkeyedUpstream = expandGroupUpstream(present.filter((u) => folded.has(u.node.id))).find(
+    (u) => u.unkeyed === true,
+  )
+  let unkeyed = unkeyedUpstream !== undefined
+  const willSave = willWrite && args.taintedUpstream !== true && !unkeyed
 
   // Retain only what is read back. `cache.save` below is the single consumer
   // of `result.stdout`, and it runs only when this task will WRITE an entry;
@@ -968,7 +988,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
    * withholds it too: the key folded the old one.
    */
   async function keyStillTrue(): Promise<boolean> {
-    if (fingerprintMoved()) return false
+    if (fingerprintMoved()) {
+      unkeyed = true
+      return false
+    }
     const endCheck = span('miss: recheck inputs')
     const moved = await movedSinceKey()
     endCheck()
@@ -979,9 +1002,17 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         `but is not saved under a key that no longer describes it`,
     )
     forgetUndeclaredWrites(args, wsOutputs.length > 0 ? 'workspace' : 'project')
+    unkeyed = true
     return false
   }
 
+  if (unkeyedUpstream !== undefined && willWrite && effectiveExitCode === 0) {
+    log.status(
+      `[vx] ${node.id}: ran over ${unkeyedUpstream.node.id}'s outputs, which its key no longer ` +
+        `describes — the result stands, but is not saved`,
+    )
+  }
+
   const finalViolations = violations
 
   return {
@@ -991,6 +1022,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
     durationMs: spentMs,
     hash,
     ...(attempt > 1 ? { attempts: attempt } : {}),
+    ...(unkeyed ? { unkeyed: true as const } : {}),
     ...(result.timedOut === true && effectiveExitCode !== 0 ? { timedOut: true as const } : {}),
     ...(result.cpuMs !== undefined ? { cpuMs: result.cpuMs } : {}),
     ...(result.peakRssBytes !== undefined ? { peakRssBytes: result.peakRssBytes } : {}),

package/src/orchestrator/plugin-host.ts

@@ -419,6 +419,13 @@ export async function resolveExecutors(
     if (typeof executor.name !== 'string' || executor.name.length === 0) {
       throw new UserError(`plugin '${plugin.name}' returned an executor with no name`)
     }
+    // The pool's room is `active < capacity`: 0 or NaN parks its tasks for good.
+    const capacity: unknown = executor.capacity
+    if (capacity !== undefined && !(Number.isInteger(capacity) && (capacity as number) > 0)) {
+      throw new UserError(
+        `plugin '${plugin.name}' returned executor '${executor.name}' with capacity ${typeof capacity === 'number' ? String(capacity) : JSON.stringify(capacity)}: it must be a positive integer`,
+      )
+    }
     executorPlugin.set(executor, plugin.name)
     executors.push(executor)
   }