@vzn/vx 0.0.70 → 0.0.72

package/package.json

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

package/src/graph/scheduler.ts

@@ -178,6 +178,12 @@ export interface ScheduleOptions {
   execute: (node: TaskNode, upstream: TaskOutcome[]) => Promise<TaskOutcome>
   onStart?: (node: TaskNode) => void
   onFinish?: (outcome: TaskOutcome) => void
+  /**
+   * Where the line naming a rejected `execute` goes, before its failed
+   * outcome lands. Absent = stderr. The run gives it the task's own
+   * stderr, so its frame and the failure recap carry the reason.
+   */
+  onError?: (node: TaskNode, line: string) => void
   /**
    * What an outcome still owes before its dependents may start — a cache
    * save that runs off the execution slot (the orchestrator's save lane):
@@ -722,19 +728,15 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             })
             leave()
             untrack()
-            finishOne(id, outcome)
-            // Surface the error live; the outcome itself doesn't
-            // carry captured stderr (that's the logger's job). A
-            // UserError is a config/input failure (e.g. a failed
+            // A UserError is a config/input failure (e.g. a failed
             // `cache.inputs.runtime` command), not a vx bug — report it
             // plainly, never as an "internal error".
+            let line: string
             if (isUserError(err) || isFsRefusal(err)) {
               const text = isUserError(err) ? message : `${message} — ${fsRefusalHint(err)}`
               const first = refusedBy.get(text)
               if (first === undefined) refusedBy.set(text, id)
-              process.stderr.write(
-                `[vx] ${id}: ${first === undefined ? text : `as ${first} above`}\n`,
-              )
+              line = `[vx] ${id}: ${first === undefined ? text : `as ${first} above`}\n`
             } else {
               const named = err instanceof Error && err.name !== 'Error' ? `${err.name}: ` : ''
               // A wrapped error's cause is the fact the reader needs (a
@@ -746,8 +748,15 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
                 cause === undefined
                   ? ''
                   : ` (cause: ${(cause as NodeJS.ErrnoException).code ?? cause.name}: ${cause.message})`
-              process.stderr.write(`[vx] internal error in ${id}: ${named}${message}${because}\n`)
+              line = `[vx] internal error in ${id}: ${named}${message}${because}\n`
             }
+            try {
+              if (options.onError === undefined) process.stderr.write(line)
+              else options.onError(node, line)
+            } catch {
+              process.stderr.write(line)
+            }
+            finishOne(id, outcome)
             tick()
           },
         )

package/src/orchestrator/run.ts

@@ -806,6 +806,7 @@ async function runOnBus(
         log.taskComplete(o.node, o)
         narrowDemand(o.node.id)
       },
+      onError: (node, line) => log.taskStderr(node, line),
       execute: (node, upstream) => executeWithDedup(node, keyUpstream(node, upstream)),
       // A `schedule` plugin's weights; the scheduler keeps its structural
       // baseline as the tie-break. Empty map → baseline only.