@vzn/vx 0.0.429 → 0.0.431

package/package.json

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

package/src/cli/watch-filter.ts

@@ -340,7 +340,8 @@ export function gitFiles(workspaceRoot: string): Set<string> | undefined {
   const files = new Set<string>()
   for (const p of new TextDecoder().decode(proc.stdout).split('\0')) {
     if (p.length === 0) continue
-    let abs = path.join(workspaceRoot, p)
+    // An untracked nested repository is listed as `dir/`.
+    let abs = path.join(workspaceRoot, p.endsWith('/') ? p.slice(0, -1) : p)
     files.add(abs)
     for (abs = path.dirname(abs); abs !== workspaceRoot && !files.has(abs); abs = path.dirname(abs))
       files.add(abs)

package/src/cli/watch-judge.ts

@@ -111,8 +111,8 @@ export class ChangeJudge {
   // says which side of the arm it belongs to. A path already gone is a
   // change: a deletion has no date to read.
   // One exception: a path git did not list at the arm, and gone now, was
-  // born and removed since (vim's `4913` write probe, a tool's lock file);
-  // it started a cycle with nothing changed. The blind spot: one born in
+  // born and removed since (vim's `4913` write probe, a tool's lock file),
+  // unless a nested repository holds it (`inNestedRepo`); it started a cycle with nothing changed. The blind spot: one born in
   // the moment between a judgement and that cycle's keys, and gone by the
   // next judgement, was read and its deletion re-runs nothing. Git lists
   // no ignored path, so one of those is a deletion as before.
@@ -123,11 +123,21 @@ export class ChangeJudge {
     if (prev !== undefined) return prev === state
     if (state === ABSENT) {
       const listed = this.ctx.existedAtArm
-      return !ignored && listed !== undefined && !listed.has(abs)
+      return !ignored && listed !== undefined && !listed.has(abs) && !this.inNestedRepo(abs)
     }
     return modifiedBefore(abs, this.ctx.armedAt)
   }
 
+  // Git lists a nested repository (a submodule, a vendored clone) as one
+  // entry, never the files in it, and keys read them: under one, a gone
+  // path the arm did not list may have existed, so it is a deletion.
+  private inNestedRepo(abs: string): boolean {
+    const root = this.ctx.workspaceRoot
+    for (let dir = path.dirname(abs); dir !== root && dir.startsWith(root); dir = path.dirname(dir))
+      if (fs.existsSync(path.join(dir, '.git'))) return true
+    return false
+  }
+
   private writtenDuringLastCycle(abs: string, openWhileHeld = false): boolean {
     // A server the last cycle left running is still that cycle's: its
     // writes land after the cycle ended, and with a closed window a dev

package/src/exec/executor.ts

@@ -278,9 +278,15 @@ export function selectExecutor(
   for (const executor of executors) {
     if (task.pinnedLocal && executor.remote === true) continue
     if (executor.accepts === undefined) return executor
-    let taken: boolean
+    let taken: unknown
     try {
       taken = executor.accepts(task)
+      // An `async accepts` answers a Promise: truthy, so the executor took
+      // every task, and a rejection went unheard (the shape of H-16's admit).
+      if (taken instanceof Promise) {
+        taken.catch(() => {})
+        throw new Error('returned a Promise; accepts is synchronous')
+      }
     } catch (err) {
       const m = err instanceof Error ? err.message : String(err)
       throw new UserError(`${label(executor)} failed in accepts for ${task.taskId}: ${m}`)

package/src/orchestrator/run.ts

@@ -500,13 +500,20 @@ async function runOnBus(
   // it surfaced as a bare stack, or mid-run from the completion path
   // (item 1022).
   const tellDemand = (executor: TaskExecutor, remaining: ReadonlySet<string>): void => {
-    try {
-      executor.demand!(remaining)
-    } catch (err) {
-      demandOf.delete(executor)
+    const failed = (err: unknown): void => {
+      if (!demandOf.delete(executor)) return
       const m = err instanceof Error ? err.message : String(err)
       log.status(`[vx] ${executorLabel(executor)} failed in demand: ${m}; not asked again this run`)
     }
+    try {
+      // An `async demand` that rejects did so where no one listened: an
+      // unhandled rejection, a stack, the run killed. Its rejection is a
+      // throw like any other.
+      const ret: unknown = executor.demand!(remaining)
+      if (ret instanceof Promise) ret.catch(failed)
+    } catch (err) {
+      failed(err)
+    }
   }
   for (const [executor, remaining] of demandOf) tellDemand(executor, remaining)
   const narrowDemand =

package/src/orchestrator/telemetry.ts

@@ -388,9 +388,11 @@ export function createTelemetrySource(args: {
   // Never silently. The standing rule is that a never-fail path must still
   // WARN — telemetry that vanishes without a word is indistinguishable from
   // telemetry nobody configured.
-  // Every hook call site skips a disabled sink first, so this runs at most
-  // once per sink without a guard of its own (item 654).
+  // Every hook call site skips a disabled sink first (item 654), but an
+  // async hook's rejections land later, several records' worth of them
+  // after the first: those are said once too.
   const disable = (sink: TelemetrySink, hook: string, err: unknown): void => {
+    if (disabled.has(sink)) return
     disabled.add(sink)
     warn?.(
       `[vx] telemetry sink '${label(sink)}' threw in ${hook}; disabled for this run: ${err instanceof Error ? err.message : String(err)}`,
@@ -406,7 +408,10 @@ export function createTelemetrySource(args: {
       const kinds = sink.wants ?? DEFAULT_KINDS
       if (!kinds.includes(record.kind)) continue
       try {
-        sink.onRecord(record)
+        // Typed `void`, yet an `async onRecord` rejects where no one
+        // listened: an unhandled rejection killed the run (C-101).
+        const ret: unknown = sink.onRecord(record)
+        if (ret instanceof Promise) ret.catch((err) => disable(sink, 'onRecord', err))
       } catch (err) {
         disable(sink, 'onRecord', err)
       }
@@ -483,7 +488,8 @@ export function createTelemetrySource(args: {
       for (const sink of sinks) {
         if (disabled.has(sink) || sink.onRunSummary === undefined) continue
         try {
-          sink.onRunSummary(summary)
+          const ret: unknown = sink.onRunSummary(summary)
+          if (ret instanceof Promise) ret.catch((err) => disable(sink, 'onRunSummary', err))
         } catch (err) {
           disable(sink, 'onRunSummary', err)
         }

package/src/workspace/project-loader.ts

@@ -504,7 +504,10 @@ export async function loadProjectConfigs(
       ? []
       : [
           ...restoreBuiltins(builtins, overlapping),
-          ...restoreEnv(env),
+          // Overlapping, the env is checked once at the round's end, as most
+          // built-ins are: reading all of it after every load was 15–25 µs a
+          // config (149 variables, compiled, 2026-10-03).
+          ...(overlapping ? [] : restoreEnv(env)),
           ...restoreCwd(cwd),
           // Alone in the round: nothing else reads the umask now. Beside
           // other loads the round reads it once they are done (see
@@ -591,7 +594,7 @@ export async function loadProjectConfigs(
             ...restoreUmask(umask),
           ]
         : []
-    // Overlapping loads check most built-ins only here, so a change one
+    // Overlapping loads check most built-ins and the env only here, so a change one
     // config made may have broken another's load: it is refused first, and
     // nothing the round evaluated is stored.
     const changedInRound =