@vzn/vx 0.0.65 → 0.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.65",
-    "@vzn/vx-linux-arm64": "0.0.65",
-    "@vzn/vx-darwin-x64": "0.0.65",
-    "@vzn/vx-darwin-arm64": "0.0.65"
+    "@vzn/vx-linux-x64": "0.0.67",
+    "@vzn/vx-linux-arm64": "0.0.67",
+    "@vzn/vx-darwin-x64": "0.0.67",
+    "@vzn/vx-darwin-arm64": "0.0.67"
   },
   "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/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/events.ts

@@ -68,7 +68,10 @@ export function createEventBus(): EventBus {
       // as wrong output, not a silent hang.
       for (const subscriber of subscribers) {
         try {
-          subscriber(event)
+          // A subscriber typed `void` may still be async: its rejection is
+          // isolated as its throw is.
+          const ret: unknown = subscriber(event)
+          if (ret instanceof Promise) ret.catch(() => {})
         } catch {
           // isolate: a surface fault can't propagate into the orchestrator
         }

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.ts

@@ -507,47 +507,53 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
         },
       },
       on(hook, handler) {
+        const fail = (err: unknown): void => {
+          if (disabled.has(plugin.name)) return
+          disabled.add(plugin.name)
+          warn(
+            `[vx] plugin '${plugin.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
+          )
+        }
         const dispose = bus.subscribe((event) => {
           if (disabled.has(plugin.name)) return
-          // void each handler call: hooks may return Promise; we
-          // intentionally don't await (the bus is synchronous;
-          // long-running plugin work happens off the critical path).
+          // Not awaited: the bus is synchronous and plugin work runs off the
+          // critical path. A handler's rejection is caught like its throw.
+          let ret: unknown
           try {
             switch (hook) {
               case 'onRunStart':
                 if (event.kind === 'run:start')
-                  void (handler as PluginHookHandlers['onRunStart'])(event.info)
+                  ret = (handler as PluginHookHandlers['onRunStart'])(event.info)
                 break
               case 'onTaskStart':
                 if (event.kind === 'task:start')
-                  void (handler as PluginHookHandlers['onTaskStart'])(event.node)
+                  ret = (handler as PluginHookHandlers['onTaskStart'])(event.node)
                 break
               case 'onTaskStdout':
                 if (event.kind === 'task:stdout')
-                  void (handler as PluginHookHandlers['onTaskStdout'])(event.node, event.chunk)
+                  ret = (handler as PluginHookHandlers['onTaskStdout'])(event.node, event.chunk)
                 break
               case 'onTaskStderr':
                 if (event.kind === 'task:stderr')
-                  void (handler as PluginHookHandlers['onTaskStderr'])(event.node, event.chunk)
+                  ret = (handler as PluginHookHandlers['onTaskStderr'])(event.node, event.chunk)
                 break
               case 'onTaskComplete':
                 if (event.kind === 'task:complete')
-                  void (handler as PluginHookHandlers['onTaskComplete'])(event.node, event.outcome)
+                  ret = (handler as PluginHookHandlers['onTaskComplete'])(event.node, event.outcome)
                 break
               case 'onRunStatus':
                 if (event.kind === 'run:status')
-                  void (handler as PluginHookHandlers['onRunStatus'])(event.line)
+                  ret = (handler as PluginHookHandlers['onRunStatus'])(event.line)
                 break
               case 'onRunEnd':
-                if (event.kind === 'run:end') void (handler as PluginHookHandlers['onRunEnd'])()
+                if (event.kind === 'run:end') ret = (handler as PluginHookHandlers['onRunEnd'])()
                 break
             }
           } catch (err) {
-            disabled.add(plugin.name)
-            warn(
-              `[vx] plugin '${plugin.name}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
-            )
+            fail(err)
+            return
           }
+          if (ret instanceof Promise) ret.catch(fail)
         })
         disposers.push(dispose)
       },