@vzn/vx 0.0.339 → 0.0.341

package/README.md

@@ -120,7 +120,7 @@ Give a task a cache block (what it reads, what it writes):
 
 ```ts
 // packages/app/vx.config.ts
-import { defineProject } from '@vzn/vx'
+import { defineProject } from '@vzn/vx/config'
 
 export default defineProject({
   tasks: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.339",
+  "version": "0.0.341",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.339",
-    "@vzn/vx-linux-arm64": "0.0.339",
-    "@vzn/vx-darwin-x64": "0.0.339",
-    "@vzn/vx-darwin-arm64": "0.0.339"
+    "@vzn/vx-linux-x64": "0.0.341",
+    "@vzn/vx-linux-arm64": "0.0.341",
+    "@vzn/vx-darwin-x64": "0.0.341",
+    "@vzn/vx-darwin-arm64": "0.0.341"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/output-index.ts

@@ -67,6 +67,8 @@ export class OutputIndex {
    * hash refreshes rather than appends).
    */
   replaceFileRows(hash: string, rows: ReadonlyArray<[string, number, number, number]>): void {
+    // A stamp taken for the rows this replaces describes their files, not these.
+    this.pendingStamps.delete(hash)
     this.deleteOutputFiles.run(hash)
     for (const [rel, size, mode, mtime] of rows) {
       this.insertOutputFile.run(hash, rel, size, mode, mtime)
@@ -83,8 +85,9 @@ export class OutputIndex {
     // warm-hit path (called up to 3× per hit) reuses one statement instead of
     // recompiling on every call.
     // A reader in the same process (`vx watch`'s next cycle, a test) sees
-    // the stamps taken, not only the ones flushed.
-    this.flushOutputDirs()
+    // the stamps taken, not only the ones flushed: overlaid below from
+    // memory. A flush here committed a transaction per read, and a restore
+    // reads its rows twice.
     const placeholders = hashes.map(() => '?').join(',')
     const stmt = this.db.query(
       `SELECT entry_hash, path, size_bytes, mode, mtime_ms, ino, ctime_ms FROM output_files WHERE entry_hash IN (${placeholders})`,
@@ -114,6 +117,15 @@ export class OutputIndex {
         row.ino = r.ino
         row.ctimeMs = r.ctime_ms
       }
+      const pending = this.pendingStamps.get(r.entry_hash)
+      if (pending !== undefined) {
+        for (const [rel, ino, ctime] of pending) {
+          if (rel !== r.path) continue
+          row.ino = ino
+          row.ctimeMs = ctime
+          break
+        }
+      }
       list.push(row)
     }
     return out

package/src/cli/foreign-flags.ts

@@ -163,6 +163,74 @@ export const FOREIGN_FLAGS: readonly ForeignFlag[] = [
     vx: '`--exclude-dependencies`',
     to: () => ['--exclude-dependencies'],
   },
+  {
+    runner: 'turbo',
+    names: ['--color'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'set `FORCE_COLOR=1`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--no-color'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'set `NO_COLOR=1`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--heap', '--trace'],
+    value: true,
+    outcome: 'refuse',
+    vx: "use `--profile[=<path>]` for vx's own trace",
+  },
+  {
+    runner: 'turbo',
+    names: ['--login'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'vx has no login: a remote cache is a plugin (`turboCache()` from @vzn/vx-migrate)',
+  },
+  {
+    runner: 'turbo',
+    names: ['--no-update-notifier'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'vx prints no update notice: drop it',
+  },
+  {
+    runner: 'turbo',
+    names: ['--skip-infer'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'vx runs the binary it is: drop it',
+  },
+  {
+    runner: 'turbo',
+    names: ['--root-turbo-json'],
+    value: true,
+    outcome: 'refuse',
+    vx: '`turbo()` reads the `turbo.json` at the workspace root: move it there',
+  },
+  {
+    runner: 'turbo',
+    names: [
+      '--experimental-otel-enabled',
+      '--experimental-otel-protocol',
+      '--experimental-otel-endpoint',
+      '--experimental-otel-timeout-ms',
+      '--experimental-otel-interval-ms',
+      '--experimental-otel-header',
+      '--experimental-otel-resource',
+      '--experimental-otel-metrics-run-summary',
+      '--experimental-otel-metrics-task-details',
+      '--experimental-otel-use-remote-cache-token',
+    ],
+    value: true,
+    shown: '`--experimental-otel-*`',
+    outcome: 'refuse',
+    vx: 'telemetry is a plugin: `otel()` from @vzn/vx-otel in vx.workspace.ts',
+  },
   {
     runner: 'nx',
     names: ['--parallel'],

package/src/exec/executor.ts

@@ -143,10 +143,10 @@ export interface ExecuteRequest {
    * Aborted when the run stops (Ctrl-C, SIGTERM, SIGHUP or an embedder's
    * `RunOptions.signal`) or when `timeoutMs` elapses. An executor ends its
    * work and returns: a child an executor spawned is not one core can
-   * reach (H-10, H-12). A non-zero exit after the timeout's abort is
-   * recorded `timedOut`. Core waits the kill grace (`VX_KILL_GRACE_MS`,
-   * 2 s) after the abort, then settles the attempt without `execute` and
-   * abandons it (H-14).
+   * reach (H-10, H-12). One already aborted is work not to start (B-55).
+   * A non-zero exit after the timeout's abort is recorded `timedOut`. Core
+   * waits the kill grace (`VX_KILL_GRACE_MS`, 2 s) after the abort, then
+   * settles the attempt without `execute` and abandons it (H-14).
    */
   readonly signal?: AbortSignal
   /** See `RunOptions.liveChildren`: the run's SIGINT/SIGTERM registry. */

package/src/exec/local-executor.ts

@@ -4,7 +4,7 @@
 // plugin claims the task, so it sits at the TAIL of every executor list
 // (owner, 2026-09-05). An executor plugin places work ELSEWHERE; its
 // absence is "here".
-import { runCommand } from './runner.js'
+import { runCommand, signalExitCode } from './runner.js'
 import { runSandboxed } from './sandbox-runtime.js'
 import type { TaskExecutor } from './executor.js'
 
@@ -24,6 +24,16 @@ export function localExecutor(): TaskExecutor {
   const executor: TaskExecutor = {
     name: 'local',
     async execute(req) {
+      // A stop that landed before the spawn (during the output clean, the
+      // request's build) leaves nothing to kill yet: a command spawned now
+      // runs after the teardown swept the run's children, and held the run
+      // to the signal's bound.
+      if (req.signal?.aborted === true) {
+        const reason: unknown = req.signal.reason
+        const signal = reason === 'SIGINT' || reason === 'SIGHUP' ? reason : 'SIGTERM'
+        const exitCode = signalExitCode(signal)
+        return { exitCode, durationMs: 0, stdout: '', stderr: '', signal, violations: [] }
+      }
       const common = {
         command: req.command,
         cwd: req.cwd,

package/src/orchestrator/run.ts

@@ -908,7 +908,7 @@ async function runOnBus(
     // change the run's exit code — the run already happened.
     // Written again after the keep-alive wait: a kept server's crash or a
     // Ctrl-C there is the process's exit, and the first write said ok.
-    const summarize = async (runOk: boolean): Promise<void> => {
+    const summarize = async (runOk: boolean, final = list): Promise<void> => {
       if (options.summarize === undefined) return
       try {
         const wrote = await writeRunSummary({
@@ -921,7 +921,7 @@ async function runOnBus(
           totalMs,
           ok: runOk,
           ...(stoppedBy !== undefined && { exitCode: signalExitCode(stoppedBy) }),
-          outcomes: list,
+          outcomes: final,
           flaky,
         })
         log.status(`vx: summary written to ${wrote}`)
@@ -1113,8 +1113,13 @@ async function runOnBus(
         )
       }
       await terminateChildren(() => keepAlive.children)
-      await summarize(ok && first.code === 0)
-      return { ok: ok && first.code === 0, outcomes: list }
+      // The server that ended the session on its own, not cleanly, failed:
+      // the rewritten summary said `ok: false` over every task `success`
+      // and `failed: 0`, and so did the outcomes `--report` renders (C-53).
+      if (!stopRun.signal.aborted && first.code !== 0) failServer(node.id, first.code)
+      const final = [...outcomes.values()]
+      await summarize(ok && first.code === 0, final)
+      return { ok: ok && first.code === 0, outcomes: final }
     }
 
     return { ok, outcomes: list }