@vzn/vx 0.0.546 → 0.0.548

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.546",
+  "version": "0.0.548",
   "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.546",
-    "@vzn/vx-linux-arm64": "0.0.546",
-    "@vzn/vx-darwin-x64": "0.0.546",
-    "@vzn/vx-darwin-arm64": "0.0.546"
+    "@vzn/vx-linux-x64": "0.0.548",
+    "@vzn/vx-linux-arm64": "0.0.548",
+    "@vzn/vx-darwin-x64": "0.0.548",
+    "@vzn/vx-darwin-arm64": "0.0.548"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/orchestrator/execute-task.ts

@@ -507,11 +507,13 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
     }
     // The reason rides the outcome (every label reads it), and a child that
     // exited before ready keeps its own exit code rather than a made-up 1.
+    // One the readiness timeout is killing reports the signal's, as an
+    // ordinary timeout does (X-24).
     const ready = err instanceof PersistentReadyError ? err : undefined
     return {
       node,
       status: 'failed',
-      exitCode: ready?.exitCode ?? 1,
+      exitCode: ready?.reason === 'timeout' ? await spawn.child.exited : (ready?.exitCode ?? 1),
       durationMs: spawn.readyMs(),
       ...(ready !== undefined ? { notReady: ready.reason } : {}),
       wallclockStartNs,

package/src/orchestrator/run.ts

@@ -5,7 +5,7 @@
 import type { ProjectEntry } from '../workspace/index.js'
 import { loadWorkspace, unreachedHint, unreachedPackages } from '../workspace/index.js'
 import path from 'node:path'
-import { type CacheLayer, type CachePolicy, stopRuntimeProbes } from '../cache/index.js'
+import { Cache, type CacheLayer, type CachePolicy, stopRuntimeProbes } from '../cache/index.js'
 import { VERSION } from '../version.js'
 import {
   resetSandbox,
@@ -1177,38 +1177,48 @@ async function runOnBus(
     // entry's save transaction (miss path only), so a warm all-cache-hit
     // run does no extra recording work. The telemetry mirror is built in
     // the same pass, only when a sink is active.
-    const records = assembleRunRecords({
-      outcomes: list,
-      runId,
-      startedAtMs: endedAtMsAtStart,
-      endedAtMs,
-      totalMs,
-      ok,
-      // The invocation is stored and `vx last` prints it: a secret passed
-      // after `--` (`-- --token=$NPM_TOKEN`) is masked here as the task's
-      // own output masks it, so cache.db holds no plaintext value.
-      command: maskInvocation(options.command ?? process.argv.slice(1).join(' ')),
-      requestedTasks: options.tasks,
-      cachePolicy: compactCachePolicy(policy),
-      concurrency,
-      flow: options.flow ?? null,
-      forwardArgs: options.forwardArgs,
-      tags: maskTags(options.tags ?? {}),
-      git: gitContext,
-      ci: ciContext,
-      host: hostContext,
-      withTelemetry: telemetry !== undefined,
-    })
-    try {
-      if (stoppedBy === undefined) cache.recordRunBundle(records)
-    } catch (err) {
-      // History is observability: a full cache disk at the very end must
-      // not turn a finished run's verdict into a stack and exit 1 (seen as
-      // an unprivileged user on a 2 MiB disk, 2026-09-16). The run said
-      // what happened; `vx last` and the flaky list will not know this one.
-      const message = err instanceof Error ? err.message : String(err)
-      log.status(`[vx] run history not recorded: ${message} — the verdict above stands`)
+    const recordsOf = (final: TaskOutcome[], runOk: boolean) =>
+      assembleRunRecords({
+        outcomes: final,
+        runId,
+        startedAtMs: endedAtMsAtStart,
+        endedAtMs,
+        totalMs,
+        ok: runOk,
+        // The invocation is stored and `vx last` prints it: a secret passed
+        // after `--` (`-- --token=$NPM_TOKEN`) is masked here as the task's
+        // own output masks it, so cache.db holds no plaintext value.
+        command: maskInvocation(options.command ?? process.argv.slice(1).join(' ')),
+        requestedTasks: options.tasks,
+        cachePolicy: compactCachePolicy(policy),
+        concurrency,
+        flow: options.flow ?? null,
+        forwardArgs: options.forwardArgs,
+        tags: maskTags(options.tags ?? {}),
+        git: gitContext,
+        ci: ciContext,
+        host: hostContext,
+        withTelemetry: telemetry !== undefined,
+      })
+    const records = recordsOf(list, ok)
+    const recordHistory = (write: () => void): void => {
+      try {
+        write()
+      } catch (err) {
+        // History is observability: a full cache disk at the very end must
+        // not turn a finished run's verdict into a stack and exit 1 (seen as
+        // an unprivileged user on a 2 MiB disk, 2026-09-16). The run said
+        // what happened; `vx last` and the flaky list will not know this one.
+        const message = err instanceof Error ? err.message : String(err)
+        log.status(`[vx] run history not recorded: ${message} — the verdict above stands`)
+      }
     }
+    // A server kept in the foreground can still fail the run after the
+    // cache closes: its history is written once the wait has decided, or it
+    // read `ok` over the exit 1 and fed the flaky list a pass (X-23).
+    const historyAfterWait = keepAlive.children.length > 0 && !hold && stoppedBy === undefined
+    if (stoppedBy === undefined && !historyAfterWait)
+      recordHistory(() => cache.recordRunBundle(records))
     mark('record history')
     // Drain any still-in-flight background prefetches before closing the
     // cache handle — a prefetch ingesting into a closed SQLite DB would
@@ -1317,7 +1327,7 @@ async function runOnBus(
 
     // Edge case the summary already reported: the user requested a
     // persistent task (dev server / watcher). The run is "done" in every
-    // bookkeeping sense — summary printed, history recorded — but the
+    // bookkeeping sense — summary printed, the cache closed — but the
     // server is still up and that's the point. Stay in the foreground
     // until ONE of them exits: Ctrl-C hits the whole process group (the
     // server dies; our SIGINT handler also exits 130), and a crash ends
@@ -1378,6 +1388,16 @@ async function runOnBus(
       if (!stopRun.signal.aborted && first.code !== 0) failServer(node.id, first.code)
       const final = [...outcomes.values()]
       await summarize(ok && first.code === 0, final)
+      if (historyAfterWait) {
+        recordHistory(() => {
+          const local = Cache.inspect(prepared.cacheDir)
+          try {
+            local.recordRunBundle(recordsOf(final, ok && first.code === 0))
+          } finally {
+            local.close()
+          }
+        })
+      }
       return { ok: ok && first.code === 0, outcomes: final }
     }
 

package/src/workspace/config-schema.ts

@@ -110,6 +110,15 @@ export function validateWorkspace(config: WorkspaceConfig, configPath: string):
   if (config.cacheDir !== undefined && typeof config.cacheDir !== 'string') {
     throw new UserError(`${configPath}: \`cacheDir\` must be a string`)
   }
+  // `'   '` made a directory named three spaces at the root, hidden by the
+  // cache's own `.gitignore` (X-22).
+  if (
+    typeof config.cacheDir === 'string' &&
+    config.cacheDir !== '' &&
+    config.cacheDir.trim() === ''
+  ) {
+    throw new UserError(`${configPath}: \`cacheDir\` is only whitespace — name a directory`)
+  }
   if (config.timeout !== undefined) {
     if (
       typeof config.timeout !== 'number' ||
@@ -728,7 +737,9 @@ export function validateProjectConfig(config: ProjectConfig, configPath: string)
         if (list !== undefined) {
           if (
             !Array.isArray(list) ||
-            list.some((s) => typeof s !== 'string' || s.length === 0 || s.includes('\0'))
+            // Whitespace alone ran as a no-op probe that folds nothing, as
+            // a blank `exec.command` did before item 1099 (X-22).
+            list.some((s) => typeof s !== 'string' || s.trim() === '' || s.includes('\0'))
           ) {
             throw new UserError(
               `${where}.cache.inputs.${field} must be an array of non-empty shell command strings with no NUL`,