@vzn/vx 0.0.57 → 0.0.59

package/package.json

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

package/src/cache/cache.ts

@@ -116,6 +116,15 @@ function unreadableIndex(err: unknown): boolean {
   return typeof code === 'string' && (code.startsWith('SQLITE_CORRUPT') || code === 'SQLITE_NOTADB')
 }
 
+/** The refusal for an index SQLite cannot read, at the open or at any later read or write (A-8). */
+function unreadableIndexError(dbFile: string, err: unknown): UserError {
+  return new UserError(
+    `the cache index ${dbFile} is not a database SQLite can read (${(err as Error).message}) — ` +
+      `it holds nothing a run cannot rebuild: remove it with its -wal and -shm files and ` +
+      `re-run, and \`vx cache prune\` reclaims the artifacts it indexed`,
+  )
+}
+
 /** Say once, on the channel the opener has, that an upgrade emptied the index. */
 export function noteSchemaReset(cache: Cache, warn: (message: string) => void): void {
   if (cache.formatChange !== null) {
@@ -417,6 +426,7 @@ export class Cache implements CacheLayer {
   private readonly inspecting: boolean
   /** Why this process cannot write into `cacheDir`, or `null`; decided at open. */
   private readonly writeBlocked: string | null
+  private readonly dbFile: string
 
   /**
    * Set when THIS open found an index written by another `SCHEMA_VERSION`
@@ -508,6 +518,7 @@ export class Cache implements CacheLayer {
     // created the typo's directory, a `.gitignore` and a database, then
     // said "no recorded runs yet" (item 900).
     const dbFile = path.join(cacheDir, 'cache.db')
+    this.dbFile = dbFile
     const absent = mode === 'inspect' && !existsSync(dbFile)
     this.writeBlocked = absent ? 'no index there yet' : openCacheDir(cacheDir)
     this.write = localPolicy.write && this.writeBlocked === null
@@ -530,11 +541,7 @@ export class Cache implements CacheLayer {
       } catch (err) {
         if (!unreadableIndex(err)) throw err
         this.db.close()
-        throw new UserError(
-          `the cache index ${dbFile} is not a database SQLite can read (${(err as Error).message}) — ` +
-            `it holds nothing a run cannot rebuild: remove it with its -wal and -shm files and ` +
-            `re-run, and \`vx cache prune\` reclaims the artifacts it indexed`,
-        )
+        throw unreadableIndexError(dbFile, err)
       }
     }
     readable(() => {
@@ -627,10 +634,10 @@ export class Cache implements CacheLayer {
     `)
 
     this.db.exec(`
-      -- stdout/stderr live in the <hash>.tar.zst artifact, not here
-      -- (v14+) — so they survive remote round-trips. The entries
-      -- table is the queryable index: command, exit_code, duration,
-      -- size, timestamps.
+      -- The queryable index: command, exit_code, duration, size,
+      -- timestamps, and stdout, which the <hash>.tar.zst artifact also
+      -- carries so it survives a remote round trip; a local hit
+      -- replays it from here.
       CREATE TABLE IF NOT EXISTS entries (
         hash         TEXT PRIMARY KEY,
         project      TEXT NOT NULL,
@@ -873,37 +880,57 @@ export class Cache implements CacheLayer {
     }
   }
 
+  /**
+   * Run `op` against the index, mapping SQLite's "not a database" — a page
+   * corrupt past the ones the open reads — to the open's own refusal. The
+   * open reads the header and `schema_meta` alone (item 1005), so a file
+   * corrupt deeper answered the first lookup that reached the bad page: every
+   * task of a run failed as an "internal error", and `vx cache prune` printed
+   * a stack (A-8). Every other error passes through as it was.
+   */
+  private guard<T>(op: () => T): T {
+    const refuse = (err: unknown): never => {
+      throw unreadableIndex(err) ? unreadableIndexError(this.dbFile, err) : err
+    }
+    try {
+      const out = op()
+      return (out instanceof Promise ? out.catch(refuse) : out) as T
+    } catch (err) {
+      return refuse(err)
+    }
+  }
+
   // --- config evaluations: `ConfigEvalStore`, delegated to `ConfigEvalTable` ---
   getConfigEval(key: string): string | null {
-    return this.configEvals.getConfigEval(key)
+    return this.guard(() => this.configEvals.getConfigEval(key))
   }
   getConfigClosures(configPaths: readonly string[]): Map<string, string[]> {
-    return this.configEvals.getConfigClosures(configPaths)
+    return this.guard(() => this.configEvals.getConfigClosures(configPaths))
   }
   putConfigClosure(configPath: string, files: readonly string[]): void {
-    this.configEvals.putConfigClosure(configPath, files)
+    return this.guard(() => this.configEvals.putConfigClosure(configPath, files))
   }
   getConfigEvals(keys: readonly string[]): Map<string, string> {
-    return this.configEvals.getConfigEvals(keys)
+    return this.guard(() => this.configEvals.getConfigEvals(keys))
   }
   putConfigEval(key: string, json: string): void {
-    this.configEvals.putConfigEval(key, json)
+    return this.guard(() => this.configEvals.putConfigEval(key, json))
   }
   putConfigEvals(entries: ReadonlyArray<readonly [string, string]>): void {
-    this.configEvals.putConfigEvals(entries)
+    return this.guard(() => this.configEvals.putConfigEvals(entries))
   }
   putConfigClosures(entries: ReadonlyArray<readonly [string, readonly string[]]>): void {
-    this.configEvals.putConfigClosures(entries)
+    return this.guard(() => this.configEvals.putConfigClosures(entries))
   }
   // --- input file hashes: delegated to `FileHashStore` (see file-hashes.ts) ---
   hashFile(filePath: string): Promise<string> {
-    return this.files.hashFile(filePath)
+    return this.guard(() => this.files.hashFile(filePath))
   }
   hashBytes(bytes: Uint8Array, nearPath: string): string {
     return this.files.hashBytes(bytes, nearPath)
   }
   hashFiles(paths: readonly string[]): Promise<Map<string, string>> {
-    return this.files.hashFiles(paths)
+    return this.guard(() => this.files.hashFiles(paths))
   }
   /**
    * `relPosix` against the run's workspace root, memoized: the same three
@@ -939,7 +966,7 @@ export class Cache implements CacheLayer {
     // Local reads disabled (e.g. `--force` / `--cache=local:w`): report a
     // miss so the task re-executes. The artifact + index are untouched.
     if (!this.read) return null
-    return this.readEntry(hash)
+    return this.guard(() => this.readEntry(hash))
   }
 
   /**
@@ -952,7 +979,7 @@ export class Cache implements CacheLayer {
    * every single run.
    */
   getIngested(hash: string): Promise<CacheEntry | null> {
-    return this.readEntry(hash)
+    return this.guard(() => this.readEntry(hash))
   }
 
   private async readEntry(hash: string): Promise<CacheEntry | null> {
@@ -989,6 +1016,10 @@ export class Cache implements CacheLayer {
    * the lazy path.
    */
   async getMany(hashes: readonly string[]): Promise<Map<string, CacheEntry>> {
+    return this.guard(() => this.getManyEntries(hashes))
+  }
+
+  private async getManyEntries(hashes: readonly string[]): Promise<Map<string, CacheEntry>> {
     const out = new Map<string, CacheEntry>()
     if (!this.read || hashes.length === 0) return out
     const rows: EntryRow[] = []
@@ -1019,6 +1050,10 @@ export class Cache implements CacheLayer {
   // Existence probe: SQL row + artifact-on-disk check, no byte reads
   // and no accessed_at bump (the plan path must stay read-only).
   async has(hash: string): Promise<'local' | 'remote' | null> {
+    return this.guard(() => this.hasEntry(hash))
+  }
+
+  private async hasEntry(hash: string): Promise<'local' | 'remote' | null> {
     if (!this.read) return null
     const row = this.selectEntry.get(hash) as EntryRow | undefined
     if (!row) return null
@@ -1038,7 +1073,7 @@ export class Cache implements CacheLayer {
   // a microtask hop per call, and a 1,000-hit warm run pays the proofs
   // 2,000 times (measured 2026-09-10: +3 ms on `classify + probe`).
   loadOutputFilesBatch(hashes: readonly string[]): Map<string, OutputFileRow[]> {
-    return this.outputs.loadOutputFilesBatch(hashes)
+    return this.guard(() => this.outputs.loadOutputFilesBatch(hashes))
   }
   isOutputsCurrent(projectDir: string, expected: readonly OutputFileRow[]): Promise<boolean> {
     return this.outputs.isOutputsCurrent(projectDir, expected)
@@ -1059,7 +1094,7 @@ export class Cache implements CacheLayer {
     this.outputs.recordOutputStamps(hash, projectDir, workspaceRoot)
   }
   loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
-    return this.outputs.loadOutputDirsBatch(hashes)
+    return this.guard(() => this.outputs.loadOutputDirsBatch(hashes))
   }
   outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): Promise<boolean> {
     return this.outputs.outputDirsCurrent(projectDir, rows)
@@ -1258,12 +1293,14 @@ export class Cache implements CacheLayer {
     const endPack = span('save: pack')
     const compressed = await this.packArtifactToTemp(this.tempPath(args.hash), args)
     endPack()
-    await this.writeArtifactAndIndex(args.hash, compressed, {
-      taskId: args.entry.taskId,
-      command: args.entry.command,
-      durationMs: args.entry.durationMs,
-      ...(args.inputComponents !== undefined ? { inputComponents: args.inputComponents } : {}),
-    })
+    await this.guard(() =>
+      this.writeArtifactAndIndex(args.hash, compressed, {
+        taskId: args.entry.taskId,
+        command: args.entry.command,
+        durationMs: args.entry.durationMs,
+        ...(args.inputComponents !== undefined ? { inputComponents: args.inputComponents } : {}),
+      }),
+    )
   }
 
   /**
@@ -1301,7 +1338,7 @@ export class Cache implements CacheLayer {
       await unlink(tmpPath).catch(() => undefined)
       throw err
     }
-    await this.writeArtifactAndIndex(hash, { tmpPath }, meta)
+    await this.guard(() => this.writeArtifactAndIndex(hash, { tmpPath }, meta))
   }
 
   /** Archive name → absolute source path for every declared output. */
@@ -1612,15 +1649,19 @@ export class Cache implements CacheLayer {
 
   // --- run history: delegated to `RunHistory` (see run-history.ts) ---
   recordRun(run: RunRecord): void {
-    this.history.recordRun(run)
+    return this.guard(() => this.history.recordRun(run))
   }
   recordRuns(runs: readonly RunRecord[]): void {
-    this.history.recordRuns(runs)
+    return this.guard(() => this.history.recordRuns(runs))
   }
   recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
-    this.history.recordRunBundle(bundle)
+    return this.guard(() => this.history.recordRunBundle(bundle))
   }
   stats(opts: CacheStatsOptions = {}): CacheStats {
+    return this.guard(() => this.statsOf(opts))
+  }
+
+  private statsOf(opts: CacheStatsOptions): CacheStats {
     this.flushAccessed()
     this.outputs.flushOutputDirs()
     const project = opts.project
@@ -1664,6 +1705,13 @@ export class Cache implements CacheLayer {
   async evictIfDue(
     policy: { maxAgeMs?: number; maxBytes?: number },
     now: number = Date.now(),
+  ): Promise<PruneResult | null> {
+    return this.guard(() => this.evictIfDueNow(policy, now))
+  }
+
+  private async evictIfDueNow(
+    policy: { maxAgeMs?: number; maxBytes?: number },
+    now: number,
   ): Promise<PruneResult | null> {
     if (this.writeBlocked !== null || this.inspecting) return null
     // First: an entry this run restored still carries its old `accessed_at`
@@ -1698,6 +1746,10 @@ export class Cache implements CacheLayer {
   }
 
   async prune(options: PruneOptions): Promise<PruneResult> {
+    return this.guard(() => this.pruneIndex(options))
+  }
+
+  private async pruneIndex(options: PruneOptions): Promise<PruneResult> {
     this.flushAccessed()
     // Before any entry is deleted, so a kept entry's pending snapshot is on
     // disk whatever the eviction does next. A pruned hash's snapshot cannot

package/src/exec/kill-tree.ts

@@ -103,18 +103,31 @@ function guardWrite(line: string): void {
 }
 
 /**
- * Spawn a task child and list its group for the guard to kill if vx dies
- * holding it. The guard starts BEFORE the spawn: started after it, the
- * guard's own spawn was a window in which the task ran and a `kill -9`
- * of vx found its group unlisted — under a traced sandbox, a third of
- * the kills landed there. What is left is the step from the spawn's
- * return to one pipe write.
+ * Spawn a task child whose group the guard kills if vx dies holding it.
+ * The CHILD lists its own group, before it runs anything: vx wrote the
+ * line after the spawn returned, and under load the child ran first, so a
+ * `kill -9` of vx in between left its group unlisted and alive (4 of 40
+ * runs at tenfold load; B-9). `spawn` gets the guard's pipe, to hand the
+ * child at some descriptor `n`, and runs `guardLine(n)` in the child's
+ * shell first. The child holds the pipe until it has written, so the
+ * guard cannot reach EOF before the line: vx's death alone no longer
+ * races it. The guard starts BEFORE the spawn, so there is a pipe to hand.
+ * `undefined` when the guard could not start: nothing lists anything.
  */
-export function spawnGuarded(spawn: () => Child): Child {
+export function spawnGuarded(spawn: (guard: number | undefined) => Child): Child {
   startGuard()
-  const child = spawn()
-  if (child.pid > 0) guardWrite(`+${child.pid}\n`)
-  return child
+  return spawn(typeof guardFd === 'number' ? guardFd : undefined)
+}
+
+/**
+ * The shell line that lists `$$`'s group on the guard's pipe at `fd` and
+ * closes it, so the task never holds the guard open. `$$` is the spawned
+ * shell, which leads its group (every guarded spawn is `detached`); a
+ * program that is not a shell is `exec`'d after it. A write to a guard
+ * that has died is ignored rather than a SIGPIPE that kills the task.
+ */
+export function guardLine(fd: number): string {
+  return `trap '' PIPE; printf '+%s\\n' $$ >&${fd} 2>/dev/null; trap - PIPE; exec ${fd}>&-; `
 }
 
 /**

package/src/exec/runner.ts

@@ -14,6 +14,7 @@ import {
   markGroupIfGone,
   releaseGroup,
   signalThrough,
+  guardLine,
   spawnGuarded,
   untilGroupsGone,
 } from './kill-tree.js'
@@ -435,27 +436,40 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
 
   let child: ReturnType<typeof Bun.spawn>
   try {
-    child = spawnGuarded(() =>
-      Bun.spawn([executablePath('sh'), '-c', execWrap(opts.command)], {
-        argv0: 'sh',
-        cwd: opts.cwd,
-        env: opts.env as Record<string, string>,
-        // A pipe vx holds and never writes: stdin stays open while vx
-        // lives and ends when it does. A dev server that exits on stdin
-        // EOF (esbuild --watch, Vite's case in turborepo#8915) became ready
-        // and exited 0 under 'ignore'. Not the terminal: several servers
-        // would steal each other's keystrokes, and a CI's /dev/null stdin
-        // is the same EOF. The one-shot spawn below keeps 'ignore', so a
-        // task that reads stdin can never hang CI.
-        stdio:
-          opts.signalChannel === true ? ['pipe', 'pipe', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe'],
-        // Its own session and process group, so a kill reaches what it
-        // forked (kill-tree.ts). stdin is a pipe, so a background group
-        // never stops on a terminal read.
-        detached: true,
-      }),
+    const signalFd = opts.signalChannel === true
+    child = spawnGuarded((guard) =>
+      Bun.spawn(
+        [
+          executablePath('sh'),
+          '-c',
+          (guard === undefined ? '' : guardLine(signalFd ? 4 : 3)) + execWrap(opts.command),
+        ],
+        {
+          argv0: 'sh',
+          cwd: opts.cwd,
+          env: opts.env as Record<string, string>,
+          // A pipe vx holds and never writes: stdin stays open while vx
+          // lives and ends when it does. A dev server that exits on stdin
+          // EOF (esbuild --watch, Vite's case in turborepo#8915) became ready
+          // and exited 0 under 'ignore'. Not the terminal: several servers
+          // would steal each other's keystrokes, and a CI's /dev/null stdin
+          // is the same EOF. The one-shot spawn below keeps 'ignore', so a
+          // task that reads stdin can never hang CI.
+          stdio: [
+            'pipe',
+            'pipe',
+            'pipe',
+            ...(signalFd ? ['pipe' as const] : []),
+            ...(guard === undefined ? [] : [guard]),
+          ],
+          // Its own session and process group, so a kill reaches what it
+          // forked (kill-tree.ts). stdin is a pipe, so a background group
+          // never stops on a terminal read.
+          detached: true,
+        },
+      ),
     )
-    if (opts.signalChannel === true) {
+    if (signalFd) {
       signalThrough(child, child.stdio[3] as number)
       const spawned = child
       void spawned.exited.then(() => closeSignalChannel(spawned))
@@ -651,19 +665,24 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
 
   let proc: ReturnType<typeof Bun.spawn>
   try {
-    proc = spawnGuarded(() =>
-      Bun.spawn([executablePath('sh'), '-c', execWrap(fullCommand)], {
-        argv0: 'sh',
-        cwd: opts.cwd,
-        env: opts.env as Record<string, string>,
-        stdin: 'ignore',
-        stdout: 'pipe',
-        stderr: 'pipe',
-        // Its own session and process group, so a kill reaches what it
-        // forked (kill-tree.ts). stdin is ignored, so a background group
-        // never stops on a terminal read.
-        detached: true,
-      }),
+    proc = spawnGuarded((guard) =>
+      Bun.spawn(
+        [
+          executablePath('sh'),
+          '-c',
+          (guard === undefined ? '' : guardLine(3)) + execWrap(fullCommand),
+        ],
+        {
+          argv0: 'sh',
+          cwd: opts.cwd,
+          env: opts.env as Record<string, string>,
+          stdio: ['ignore', 'pipe', 'pipe', ...(guard === undefined ? [] : [guard])],
+          // Its own session and process group, so a kill reaches what it
+          // forked (kill-tree.ts). stdin is ignored, so a background group
+          // never stops on a terminal read.
+          detached: true,
+        },
+      ),
     )
   } catch (err) {
     const stderr = spawnFailureText(err, opts.cwd)

package/src/exec/sandbox-runtime.ts

@@ -64,6 +64,7 @@ import {
   killTree,
   releaseGroup,
   signalThrough,
+  guardLine,
   spawnGuarded,
 } from './kill-tree.js'
 
@@ -902,13 +903,20 @@ function spawnHostBridges(ports: readonly number[], tag: string): void {
       // listening on the port under init, where the next run's bridge
       // could not bind it (item 873).
       procs.push(
-        spawnGuarded(() =>
-          Bun.spawn(portBridgeHostArgv(tag, p), {
-            stdin: 'ignore',
-            stdout: 'ignore',
-            stderr: 'ignore',
-            detached: true,
-          }),
+        spawnGuarded((guard) =>
+          guard === undefined
+            ? Bun.spawn(portBridgeHostArgv(tag, p), {
+                stdio: ['ignore', 'ignore', 'ignore'],
+                detached: true,
+              })
+            : Bun.spawn(
+                [
+                  executablePath('sh'),
+                  '-c',
+                  `${guardLine(3)}exec ${portBridgeHostArgv(tag, p).map(shellQuote).join(' ')}`,
+                ],
+                { stdio: ['ignore', 'ignore', 'ignore', guard], detached: true },
+              ),
         ),
       )
     } catch {
@@ -1086,16 +1094,35 @@ async function runSandboxedOnce(
           wrapped,
         ]
       : [sh, '-c', wrapped]
-    proc = spawnGuarded(() =>
-      Bun.spawn(spawnArgv, {
-        argv0: straceLog ? 'strace' : 'sh',
-        cwd: args.cwd,
-        env: args.env as Record<string, string>,
-        // fd 3 is the signal channel the in-sandbox watcher reads.
-        stdio: forwardsSignals ? ['ignore', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
-        // As the unsandboxed spawn: its own process group (kill-tree.ts).
-        detached: true,
-      }),
+    // With the guard, a shell lists the group first and `exec`s the
+    // spawn: strace itself would hold the guard's pipe for its lifetime.
+    const guardAt = forwardsSignals ? 4 : 3
+    proc = spawnGuarded((guard) =>
+      Bun.spawn(
+        guard === undefined
+          ? spawnArgv
+          : [
+              sh,
+              '-c',
+              guardLine(guardAt) +
+                (straceLog ? `exec ${spawnArgv.map(shellQuote).join(' ')}` : wrapped),
+            ],
+        {
+          argv0: straceLog && guard === undefined ? 'strace' : 'sh',
+          cwd: args.cwd,
+          env: args.env as Record<string, string>,
+          // fd 3 is the signal channel the in-sandbox watcher reads.
+          stdio: [
+            'ignore',
+            'pipe',
+            'pipe',
+            ...(forwardsSignals ? ['pipe' as const] : []),
+            ...(guard === undefined ? [] : [guard]),
+          ],
+          // As the unsandboxed spawn: its own process group (kill-tree.ts).
+          detached: true,
+        },
+      ),
     )
     if (forwardsSignals) signalThrough(proc, proc.stdio[3] as number)
   } catch (err) {

package/src/orchestrator/execute-task.ts

@@ -449,13 +449,10 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
   // The PROBE hash is computed WITHOUT capture — a warm all-cache-hit
   // run allocates no component array and pushes nothing (the warm path
   // does zero extra Tier-3 work). The cache-key components for the
-  // Tier-3 input fingerprint are captured only on a MISS, right before
-  // `cache.save`, by a second `computeTaskHash` with `captureInto` set
-  // — the HashCache memos (package.json bytes, task config, runtime
-  // command output) plus the gitFilesCache OID map make that second
-  // pass a fold + array pushes, no re-stat / re-hash I/O. It runs on
-  // the miss path only, where the task is about to spawn a subprocess
-  // anyway, so its cost is in the noise.
+  // Tier-3 input fingerprint are captured only on a MISS, by
+  // `describeTaskInputs` just before the command spawns (with
+  // `captureInto` set) — the HashCache memos plus the gitFilesCache OID
+  // map make that pass a fold + array pushes, no re-stat / re-hash I/O.
   //
   // Local short-circuit reuse: when the classify phase already derived
   // this task's stable key + probed it, reuse the up-front hash verbatim

package/src/util/edit-distance.ts

@@ -1,10 +1,11 @@
 /**
- * Levenshtein distance, capped: anything past two edits reads as 3. Used
- * by the "did you mean" hints for task names and flags, where a hint
- * beyond two edits would guess rather than help.
+ * Levenshtein distance, capped: anything at or past `cap` edits reads as
+ * `cap` (3 by default: past two edits a hint would guess rather than
+ * help). A caller that allows three edits needs a cap of four — under a
+ * cap of 3, a candidate nine edits away read as 3 and was offered.
  */
-export function editDistance(a: string, b: string): number {
-  if (Math.abs(a.length - b.length) > 2) return 3
+export function editDistance(a: string, b: string, cap = 3): number {
+  if (Math.abs(a.length - b.length) >= cap) return cap
   let prev = Array.from({ length: b.length + 1 }, (_, i) => i)
   for (let i = 1; i <= a.length; i++) {
     const cur = [i]
@@ -17,7 +18,7 @@ export function editDistance(a: string, b: string): number {
     }
     prev = cur
   }
-  return Math.min(prev[b.length]!, 3)
+  return Math.min(prev[b.length]!, cap)
 }
 
 /**
@@ -35,7 +36,10 @@ export function nearest(
   let best: string | undefined
   let bestD = maxEdits + 1
   for (const c of candidates) {
-    const d = editDistance(name, c)
+    // Capped one past the budget, so "past it" never reads as within it:
+    // `--continue-on-error` was nine edits from `--concurrency`, capped to
+    // the three `vx run`'s same-prefix hint allows, and offered.
+    const d = editDistance(name, c, maxEdits + 1)
     if (d < bestD) {
       bestD = d
       best = c