@vzn/vx 0.0.101 → 0.0.102

package/README.md

@@ -38,10 +38,7 @@ burns 35 s of CPU in vx, 73 s in Turborepo and 114 minutes in Nx; a
 fully cached run replays the graph in 510 ms.
 <!-- bench:end -->
 
-On a real Turbo repo (`solidjs/solid`, its own `turbo.json`, nothing
-rewritten) vx replays a cached build in 51 ms where Turbo takes 95,
-restores every output in 66 ms against 127, and builds cold in 40.6 s
-against 45.5 s ([benchmarks](packages/vx/docs/benchmarks.md)).
+Measured on eleven real Turborepo and Nx repos too: [tried on real repos](#tried-on-real-repos).
 
 ## Install
 
@@ -146,25 +143,59 @@ Turbo and Nx feature is in vx, pinned by a test:
   Vite does it. Core ships none and needs none.
 - **Free.** MIT. No paywall, no cloud, no account.
 
+## Tried on real repos
+
+Eleven public monorepos, each run with its own `turbo.json` or Nx graph
+and nothing rewritten, against the tool it ships with. Both tools on the same machine and
+tasks per row, medians; vx first, theirs second. Where the other tool
+wins, the row says so.
+
+| Repo                                                        | Against | Cold build            | Restore outputs | Nothing to do       |
+| ----------------------------------------------------------- | ------- | --------------------- | --------------- | ------------------- |
+| [solidjs/solid](https://github.com/solidjs/solid)           | Turbo   | 40.6 s / 45.5 s       | 66 ms / 127 ms  | 51 ms / 95 ms       |
+| [withastro/astro](https://github.com/withastro/astro)       | Turbo   | 48.0 s / 57.9 s       | 478 ms / 1.43 s | 249 ms / 1.38 s     |
+| [payloadcms/payload](https://github.com/payloadcms/payload) | Turbo   | 126.9 s / 127.5 s     | 3.44 s / 3.46 s | 256 ms / **237 ms** |
+| [medusajs/medusa](https://github.com/medusajs/medusa)       | Turbo   | 308 s / 315 s         | 3.86 s / 7.16 s | 947 ms / 3.29 s     |
+| [n8n-io/n8n](https://github.com/n8n-io/n8n)                 | Turbo   | 137.2 s / **133.7 s** | 8.27 s / 12.5 s | 842 ms / 1.36 s     |
+| [calcom/cal.com](https://github.com/calcom/cal.com)         | Turbo   | 245.7 s / 250.7 s     | 17.4 s / 19.9 s | 14.7 s / 18.5 s     |
+| [TanStack/query](https://github.com/TanStack/query)         | Nx      | 47.4 s / 55.1 s       | 656 ms / 1.98 s | 174 ms / 1.88 s     |
+| [strapi/strapi](https://github.com/strapi/strapi)           | Nx      | 238.2 s / 245.7 s     | 1.61 s / 3.94 s | 341 ms / 4.02 s     |
+| [novuhq/novu](https://github.com/novuhq/novu)               | Nx      | 291.2 s / 299.4 s     | 3.10 s / 9.05 s | 655 ms / 8.55 s     |
+| [TanStack/router](https://github.com/TanStack/router)       | Nx      | 199.9 s / 226.7 s     | 1.00 s / 3.33 s | 505 ms / 3.21 s     |
+| [refinedev/refine](https://github.com/refinedev/refine)     | Nx      | 96.2 s / 105.9 s      | 1.06 s / 1.19 s | 303 ms / 1.16 s     |
+
+**Bold** marks the other tool winning. Versions, revisions, scopes and
+harness per repo: [benchmarks](packages/vx/docs/benchmarks.md) (astro
+and refine as re-measured on 2026-09-27, the rest 2026-09-10 and -11).
+
 ## How it compares
 
-|                           | vx                                        | Turborepo                      | Nx               |
-| ------------------------- | ----------------------------------------- | ------------------------------ | ---------------- |
-| Fully cached, 1,090 pkgs¹ | **510 ms**                                | 760 ms                         | 3.59 s           |
-| Config                    | TypeScript, evaluated into the cache key  | JSON (static)                  | JSON (static)    |
-| Output ownership          | **Strict**: wiped before exec and restore | Additive (stale files survive) | Additive         |
-| Clean-tree hashing        | **Zero reads** (git index OIDs)           | git OIDs                       | re-hash / daemon |
-| Daemon required for speed | **No**                                    | Optional                       | Yes              |
-| Per-task sandbox          | **Yes**: kernel-level, opt-in             | No                             | No               |
-| Plugin API                | **Yes**: every pipeline stage             | No                             | Yes (TS-tied)    |
-| OTel CI/CD spans          | **Yes**: `otel()` plugin, no OTel SDK     | No                             | Paid             |
-| Install                   | **Single binary**; no Bun, Node optional  | npm + Node                     | npm + Node       |
+|                           | vx                                        | Turborepo                      | Nx               | moon²                          |
+| ------------------------- | ----------------------------------------- | ------------------------------ | ---------------- | ------------------------------ |
+| Fully cached, 1,090 pkgs¹ | **510 ms**                                | 760 ms                         | 3.59 s           | not measured                   |
+| Config                    | TypeScript, evaluated into the cache key  | JSON (static)                  | JSON (static)    | YAML, Pkl and others (static)  |
+| Output ownership          | **Strict**: wiped before exec and restore | Additive (stale files survive) | Additive         | Glob outputs pruned on restore |
+| Clean-tree hashing        | **Zero reads** (git index OIDs)           | git OIDs                       | re-hash / daemon | `git hash-object`              |
+| Daemon required for speed | **No**                                    | Optional                       | Yes              | Optional (experimental)        |
+| Per-task sandbox          | **Yes**: kernel-level, opt-in             | No                             | No               | No                             |
+| Plugin API                | **Yes**: every pipeline stage             | No                             | Yes (TS-tied)    | WASM toolchains, extensions    |
+| OTel CI/CD spans          | **Yes**: `otel()` plugin, no OTel SDK     | No                             | Paid             | No                             |
+| Install                   | **Single binary**; no Bun, Node optional  | npm + Node                     | npm + Node       | Single binary                  |
 
 ¹ Warm, nothing to rebuild, the graph charted above. Every gap, and
 when another tool is the better pick:
 [comparison](packages/vx/docs/comparison.md) ·
 [vx, Turborepo, Nx, Bazel](https://vznjs.github.io/vx/compare/).
 
+² From moon's own docs (2026-09-28): [config](https://github.com/moonrepo/moon/blob/master/website/docs/config/overview.mdx),
+[outputs](https://github.com/moonrepo/moon/blob/master/website/docs/config/project.mdx),
+[hashing](https://github.com/moonrepo/moon/blob/master/website/docs/guides/debug-task.mdx),
+[daemon](https://github.com/moonrepo/moon/blob/master/website/docs/guides/daemon.mdx),
+[plugins](https://github.com/moonrepo/moon/blob/master/website/docs/guides/wasm-plugins.mdx),
+[install](https://github.com/moonrepo/moon/blob/master/website/docs/install.mdx);
+they describe no per-task sandbox and no OpenTelemetry export. Already on
+moon: `moon()` runs it unchanged.
+
 ## Plugins
 
 Declared in `vx.workspace.ts`. Without one, vx runs and caches on this

package/package.json

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

package/src/bin.ts

@@ -1,6 +1,12 @@
 #!/usr/bin/env -S bun --no-env-file
 import { registerCoreAlias, run } from './cli/index.js'
-import { fsRefusalHint, isFsRefusal, isUserError } from './util/index.js'
+import {
+  fsRefusalHint,
+  isFsRefusal,
+  isOutOfFds,
+  isUserError,
+  OUT_OF_FDS_HINT,
+} from './util/index.js'
 
 // Every `import … from '@vzn/vx'` this process evaluates — a plugin
 // package, a workspace or project config — resolves to THIS core, not to
@@ -38,6 +44,8 @@ async function main(): Promise<void> {
       // it produced `vx: vx why: …` (walkthrough, 2026-09-04).
       const m = err.message
       process.stderr.write(m.startsWith('vx ') ? `${m}\n` : `vx: ${m}\n`)
+    } else if (isOutOfFds(err)) {
+      process.stderr.write(`vx: ${err.message} — ${OUT_OF_FDS_HINT}\n`)
     } else if (isFsRefusal(err)) {
       // The file system's refusal names the path; the stack would name
       // the verb's write, which the reader cannot act on either.

package/src/cache/inputs.ts

@@ -25,6 +25,7 @@ import {
   isExecutableMissing,
   isLiteralPattern,
   normalizeGlob,
+  shellArgv,
   slashBraceExpansions,
   taskGlob,
   UserError,
@@ -382,15 +383,16 @@ async function runRuntimeCommand(
   const prefix = binDirs.join(path.delimiter)
   let proc
   try {
-    proc = Bun.spawn(['sh', '-c', command], {
+    const argv = process.platform === 'win32' ? shellArgv(command) : ['sh', '-c', command]
+    proc = Bun.spawn(argv, {
       cwd,
       env: { ...process.env, PATH: ambient ? `${prefix}${path.delimiter}${ambient}` : prefix },
       stdin: 'ignore',
       stdout: 'pipe',
       stderr: 'pipe',
       // Its own group, so the probe's whole tree can be taken down with vx
-      // (`killProbesOnExit`).
-      detached: true,
+      // (`killProbesOnExit`). Windows has no groups.
+      detached: process.platform !== 'win32',
     })
   } catch (err) {
     // The probe runs through `sh -c` like a task: a box without sh names

package/src/cli/index.ts

@@ -40,6 +40,23 @@ export async function run(argv: readonly string[]): Promise<number> {
       // reference, which lists the plugin verbs.
       const verb = rest[0]
       const core = verb !== undefined && (CORE_VERBS as readonly string[]).includes(verb)
+      if (verb !== undefined && !core) {
+        // A name that is no verb here is the typo `vx rnu` is, not a request
+        // for the whole reference: it printed 145 lines and no hint.
+        const resolved = await resolvePluginCommand(verb)
+        const unknown = resolved === null || 'declaredVerbs' in resolved
+        if (unknown && MOVED_VERBS[verb] !== undefined) {
+          process.stderr.write(`${MOVED_VERBS[verb]}\n`)
+          return 1
+        }
+        if (unknown) {
+          const declared = resolved === null ? [] : resolved.declaredVerbs
+          process.stderr.write(
+            `vx help: unknown command: ${verb}${didYouMeanVerb(verb, declared)} (see \`vx help\`)\n`,
+          )
+          return 1
+        }
+      }
       printHelp(await pluginCommandHelp(), core ? verb : undefined)
       return 0
     }

package/src/cli/last.ts

@@ -17,7 +17,7 @@ import {
 import { formatElapsed, UserError } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { cliCacheDir, parseCacheDirFlag, warnToStderr } from './workspace-config.js'
-import { resolveRunId } from './run-id.js'
+import { resolveRunId, shortRunId } from './run-id.js'
 
 interface LastArgs {
   runId?: string
@@ -51,7 +51,13 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
     if (a === '--format' || a.startsWith('--format=')) {
       const fv = a === '--format' ? args[++i] : a.slice(9)
       if (fv !== 'pretty' && fv !== 'json') {
-        return { ...out, error: `invalid --format: ${fv ?? ''} (expected pretty | json)` }
+        return {
+          ...out,
+          error:
+            fv === undefined || fv === ''
+              ? '--format requires a value (pretty | json)'
+              : `invalid --format: ${fv} (expected pretty | json)`,
+        }
       }
       out.format = fv
       continue
@@ -196,7 +202,7 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
       for (const inv of invocations) {
         const verdict = inv.exitOk ? 'ok    ' : 'FAILED'
         process.stdout.write(
-          `${verdict} ${fmtWhen(inv.startedAt)}  ${inv.runId}  ` +
+          `${verdict} ${fmtWhen(inv.startedAt)}  ${shortRunId(db, inv.runId)}  ` +
             `${inv.taskCount} task${inv.taskCount === 1 ? '' : 's'} · ${inv.hitCount} hit${inv.hitCount === 1 ? '' : 's'}` +
             `${inv.failedCount > 0 ? ` · ${inv.failedCount} failed` : ''} · ${fmtMs(inv.totalDurationMs)}  $ ${inv.command}\n`,
         )
@@ -237,6 +243,15 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         `${inv.failedCount > 0 ? ` · ${inv.failedCount} failed` : ''}`,
     )
     lines.push(...formatTaskRows(detail?.tasks ?? []))
+    // The next command after reading a failed run, with the arguments the
+    // run forwarded (a failure under `-- --shard 2` is that shard's).
+    const failed = (detail?.tasks ?? []).filter((t) => t.status === 'failed')
+    if (failed.length > 0) {
+      const at = inv.command.indexOf(' -- ')
+      const forwarded = at === -1 ? '' : inv.command.slice(at)
+      const ids = failed.map((t) => `${t.project}#${t.task}`).join(' ')
+      lines.push('', `  re-run what failed: vx run ${ids}${forwarded}`)
+    }
     process.stdout.write(`${lines.join('\n')}\n`)
     return 0
   } finally {

package/src/cli/run-id.ts

@@ -1,6 +1,5 @@
 // A run id as a user types it: the whole id, or a prefix of one, as git
-// takes a short sha. `vx last --list` prints 36-character ids; nobody
-// retypes one whole.
+// takes a short sha, and as `vx last --list` prints it.
 
 import type { Database } from 'bun:sqlite'
 import { UserError } from '../util/index.js'
@@ -25,3 +24,25 @@ export function resolveRunId(db: Database, raw: string, verb: string): string |
     `${verb}: run id ${raw} is the start of ${rows.length > 5 ? 'more than 5' : rows.length} runs — type more of it:\n${shown.join('\n')}`,
   )
 }
+
+/**
+ * The shortest prefix of `id` no other recorded run shares, and never
+ * shorter than 13 characters: a UUIDv7's first 13 are its millisecond
+ * clock, so a shorter one is part of a timestamp. Two indexed lookups, the
+ * ids sorted either side of it, since the longest prefix any id shares
+ * with it is shared with one of those two.
+ */
+export function shortRunId(db: Database, id: string): string {
+  const next = db.query('SELECT run_id FROM invocations WHERE run_id > ? ORDER BY run_id LIMIT 1')
+  const prev = db.query(
+    'SELECT run_id FROM invocations WHERE run_id < ? ORDER BY run_id DESC LIMIT 1',
+  )
+  let shared = 0
+  for (const row of [next.get(id), prev.get(id)] as Array<{ run_id: string } | null>) {
+    if (row === null) continue
+    let n = 0
+    while (n < id.length && id[n] === row.run_id[n]) n++
+    shared = Math.max(shared, n)
+  }
+  return id.slice(0, Math.max(13, shared + 1))
+}

package/src/cli/show.ts

@@ -9,7 +9,7 @@
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { flagHint, seeHelp } from './help.js'
-import { nearMatches, relPosix, UserError } from '../util/index.js'
+import { nearMatches, relPosix, secretMask, UserError } from '../util/index.js'
 import { loadCliProjects } from './workspace-config.js'
 import {
   findWorkspaceRoot,
@@ -153,6 +153,45 @@ function projectDir(root: string, meta: ProjectMeta): string {
   return rel === '' ? '.' : rel
 }
 
+/**
+ * A task as `vx show` prints it: a secret-named variable's value masked
+ * wherever it appears, in `env.define` and in the command a TS config
+ * built from `process.env` (L-11).
+ */
+function shownTask(task: TaskConfig): TaskConfig {
+  const exec = task.exec
+  if (exec === undefined) return task
+  const define = exec.env?.define
+  const secrets = secretMask(process.env, define)
+  if (secrets === null) return task
+  return {
+    ...task,
+    exec: {
+      ...exec,
+      ...(exec.command !== undefined ? { command: secrets.mask(exec.command) } : {}),
+      ...(define !== undefined
+        ? {
+            env: {
+              ...exec.env,
+              define: Object.fromEntries(
+                Object.entries(define).map(([k, v]) => [k, secrets.mask(v)]),
+              ),
+            },
+          }
+        : {}),
+    },
+  }
+}
+
+/** A project config with each task as `shownTask` prints it. */
+function shownConfig(config: ProjectConfig | null): ProjectConfig | null {
+  if (config?.tasks === undefined) return config
+  return {
+    ...config,
+    tasks: Object.fromEntries(Object.entries(config.tasks).map(([n, t]) => [n, shownTask(t)])),
+  }
+}
+
 function renderList(
   root: string,
   metas: readonly ProjectMeta[],
@@ -198,7 +237,8 @@ function renderProject(
   if (format === 'json') {
     // Round-trip so the printed object is exactly the JSON form of the
     // resolved config (drops `undefined` fields).
-    return `${JSON.stringify(JSON.parse(JSON.stringify({ name, dir, config })), null, 2)}\n`
+    const shown = shownConfig(config)
+    return `${JSON.stringify(JSON.parse(JSON.stringify({ name, dir, config: shown })), null, 2)}\n`
   }
   const head = `${name} — ${dir}`
   const tasks = Object.entries(config?.tasks ?? {})
@@ -216,7 +256,7 @@ function renderTask(
   format: 'pretty' | 'json',
 ): string {
   if (format === 'json') {
-    const obj = { name, dir, task: taskName, config: task }
+    const obj = { name, dir, task: taskName, config: shownTask(task) }
     return `${JSON.stringify(JSON.parse(JSON.stringify(obj)), null, 2)}\n`
   }
   return `${name} — ${dir}\n\n${taskBlock(taskName, task)}`
@@ -233,7 +273,7 @@ function renderTaskAcross(
       name: p.name,
       dir: relPosix(root, p.dir) || '.',
       task: taskName,
-      config: p.config.tasks![taskName],
+      config: shownTask(p.config.tasks![taskName]!),
     }))
     return `${JSON.stringify(JSON.parse(JSON.stringify(list)), null, 2)}\n`
   }
@@ -246,7 +286,8 @@ function renderTaskAcross(
 }
 
 /** Every field the run reads, in the order the schema declares them. */
-function taskBlock(taskName: string, task: TaskConfig): string {
+function taskBlock(taskName: string, raw: TaskConfig): string {
+  const task = shownTask(raw)
   const rows: [string, string][] = []
   const list = (xs: readonly string[] | undefined): string | undefined =>
     xs === undefined ? undefined : xs.join(', ')

package/src/cli/watch.ts

@@ -595,7 +595,20 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
       watchers.push(pollWatcher(dir, recursive, onEvent, POLL_INTERVAL_MS, skipUnder(dir)))
       return handle
     }
-    const armed = armWatcher(dir, recursive, onEvent)
+    let armed: ReturnType<typeof armWatcher>
+    try {
+      armed = armWatcher(dir, recursive, onEvent)
+    } catch (err) {
+      // The OS's watch limit, not the directory: the loop said "watching"
+      // and never fired. The poller needs no watch slot.
+      const code = (err as NodeJS.ErrnoException).code
+      if (code !== 'ENOSPC' && code !== 'EMFILE') throw err
+      watchers.push(pollWatcher(dir, recursive, onEvent, POLL_INTERVAL_MS, skipUnder(dir)))
+      process.stderr.write(
+        `vx watch: ${dir}: the OS watch limit is reached (${code}); polling every ${POLL_INTERVAL_MS} ms instead — raise it (Linux: sysctl fs.inotify.max_user_watches) to watch natively\n`,
+      )
+      return handle
+    }
     watchers.push(armed.watcher)
     proofs.push(
       armed.ready.then((ok) => {

package/src/cli/why.ts

@@ -61,7 +61,8 @@ export function parseWhyArgs(args: readonly string[]): WhyArgs {
     // got two different diagnoses depending on how it was typed.
     if (a === '--run' || a.startsWith('--run=')) {
       const rv = a === '--run' ? args[++i] : a.slice(6)
-      if (rv === undefined || rv === '') return { ...out, error: 'invalid --run: empty' }
+      if (rv === undefined || rv === '')
+        return { ...out, error: '--run requires a run id (`vx last --list` shows them)' }
       out.runId = rv
       continue
     }
@@ -71,7 +72,10 @@ export function parseWhyArgs(args: readonly string[]): WhyArgs {
         // An omitted value reads as empty, not as the literal word "undefined".
         return {
           ...out,
-          error: `invalid --format: ${fv ?? ''} (expected pretty | json)`,
+          error:
+            fv === undefined || fv === ''
+              ? '--format requires a value (pretty | json)'
+              : `invalid --format: ${fv} (expected pretty | json)`,
         }
       }
       out.format = fv
@@ -240,7 +244,19 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
       const kinds = [...new Set(diff.entries.map((e) => e.kind))].filter((k) => k in WHAT_TO_DO)
       if (kinds.length > 0) {
         lines.push('', '  what to do:')
-        for (const k of kinds) lines.push(`    ${k.padEnd(kindW)}  ${WHAT_TO_DO[k]}`)
+        // An upstream row names the task to ask next: the command, not a
+        // placeholder to fill in from the row above.
+        const upstream = diff.entries.filter((e) => e.kind === 'upstream').map((e) => e.name)
+        for (const k of kinds) {
+          const todo =
+            k === 'upstream'
+              ? WHAT_TO_DO[k]!.replace(
+                  '`vx why <that task>`',
+                  upstream.map((n) => `\`vx why ${n}\``).join(', '),
+                )
+              : WHAT_TO_DO[k]
+          lines.push(`    ${k.padEnd(kindW)}  ${todo}`)
+        }
       }
     } else if (why.hashChanged === true) {
       lines.push(`  detail     ${diff.note}`)

package/src/exec/kill-tree.ts

@@ -78,6 +78,8 @@ const GUARD_SCRIPT = [
 function startGuard(): void {
   if (guardFd !== undefined) return
   guardFd = null
+  // The guard is an `sh` script over process groups; Windows has neither.
+  if (process.platform === 'win32') return
   try {
     const guard = Bun.spawn([executablePath('sh'), '-c', GUARD_SCRIPT], {
       argv0: 'vx-group-guard',

package/src/exec/runner.ts

@@ -6,7 +6,7 @@
 
 import { existsSync, readFileSync } from 'node:fs'
 import { constants as osConstants } from 'node:os'
-import { executablePath, isExecutableMissing, killGraceMs } from '../util/index.js'
+import { shellArgv, isExecutableMissing, killGraceMs } from '../util/index.js'
 import {
   closeSignalChannel,
   holdGroups,
@@ -19,6 +19,10 @@ import {
   untilGroupsGone,
 } from './kill-tree.js'
 
+const WIN32 = process.platform === 'win32'
+/** `sh` names itself in its errors; `bun exec` on Windows keeps its own. */
+const SH_ARGV0 = WIN32 ? {} : { argv0: 'sh' }
+
 export interface RunResult {
   exitCode: number
   durationMs: number
@@ -204,6 +208,8 @@ const SHELL_BUILTINS = new Set([
  * the shell.
  */
 export function execWrap(command: string): string {
+  // Bun's shell, the task shell on Windows, has no `exec`.
+  if (WIN32) return command
   const first = execWord(command)
   return first === undefined ? command : `exec ${command}`
 }
@@ -439,13 +445,11 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
     const signalFd = opts.signalChannel === true
     child = spawnGuarded((guard) =>
       Bun.spawn(
-        [
-          executablePath('sh'),
-          '-c',
+        shellArgv(
           (guard === undefined ? '' : guardLine(signalFd ? 4 : 3)) + execWrap(opts.command),
-        ],
+        ),
         {
-          argv0: 'sh',
+          ...SH_ARGV0,
           cwd: opts.cwd,
           env: opts.env as Record<string, string>,
           // A pipe vx holds and never writes: stdin stays open while vx
@@ -464,8 +468,9 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
           ],
           // 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,
+          // never stops on a terminal read. Windows has no groups, and a
+          // detached child there has no console.
+          detached: !WIN32,
         },
       ),
     )
@@ -666,23 +671,17 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
   let proc: ReturnType<typeof Bun.spawn>
   try {
     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,
-        },
-      ),
+      Bun.spawn(shellArgv((guard === undefined ? '' : guardLine(3)) + execWrap(fullCommand)), {
+        ...SH_ARGV0,
+        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. Windows has no groups, and a
+        // detached child there has no console.
+        detached: !WIN32,
+      }),
     )
   } catch (err) {
     const stderr = spawnFailureText(err, opts.cwd)

package/src/exec/sandbox-binds.ts

@@ -157,9 +157,10 @@ export function punchWritePaths(readPath: string, writePaths: readonly string[])
  * produce the SRT customConfig. Path arrays are unioned and deduped; every
  * read grant is punched around the write grants (`punchWritePaths`).
  *
- * Network: `allow.network` missing → block all (allowedDomains: []);
- * `true` → allow all (['*']); a domain list → exactly that list.
- * `deny.network` is always passed as deniedDomains.
+ * Network: the lists are passed as the task declared them, but SRT's
+ * proxy filters by the RUN's lists from `initialize()`, never these: a
+ * task reaches the run's allowlist union less its deny union
+ * (`sandboxRunUnion`, B-21), whatever it declared here.
  */
 export function buildCustomConfig(
   args: Pick<SandboxedRunArgs, 'config'>,
@@ -185,9 +186,8 @@ export function buildCustomConfig(
     },
   }
 
-  // `allow.network` / `deny.network` become SRT's domain lists. SRT requires
-  // both to be present on any network config, so we always supply both;
-  // omitted means no network at all.
+  // SRT requires both lists on any network config, so both are supplied;
+  // its proxy filters by the run's lists, not these (see above).
   custom.network = {
     allowedDomains: c.network === true ? ['*'] : [...(c.network ?? [])],
     deniedDomains: [...(c.denyNetwork ?? [])],