@vzn/vx 0.0.354 → 0.0.356

package/README.md

@@ -5,8 +5,8 @@
 <h1 align="center">vx</h1>
 
 <p align="center">
-  <strong>A faster runner for your Turborepo or Nx repo.</strong><br>
-  Keep <code>turbo.json</code> or <code>nx.json</code> and run it unchanged.
+  <strong>The fastest task runner for JS monorepos.</strong><br>
+  Measured against Turborepo and Nx, each in its own native config.
 </p>
 
 <p align="center">
@@ -18,50 +18,20 @@
 
 <!-- bench:start — generated by packages/vx-bench/update-site.ts from results.json; do not hand-edit -->
 
-| 1,090 packages, 3,270 tasks      | vx         | Turborepo  | Nx       |
-| -------------------------------- | ---------- | ---------- | -------- |
-| Cold build: time the runner adds | **9 s**    | 1 min 35 s | 31 min   |
-| Cold build: CPU burned           | **34 s**   | 1 min 13 s | 114 min  |
-| Fully cached run                 | **476 ms** | 760 ms     | 3.59 s   |
-| Overhead per package             | **8 ms**   | 88 ms      | 1,712 ms |
+| 1,090 packages, 3,270 tasks      | vx         | Turborepo                  | Nx                       |
+| -------------------------------- | ---------- | -------------------------- | ------------------------ |
+| Cold build: time the runner adds | **9 s**    | 1 min 35 s (vx 91% faster) | 31 min (vx 99% faster)   |
+| Cold build: CPU burned           | **34 s**   | 1 min 13 s (vx 53% faster) | 114 min (vx 99% faster)  |
+| Fully cached run                 | **476 ms** | 760 ms (vx 37% faster)     | 3.59 s (vx 86% faster)   |
+| Overhead per package             | **8 ms**   | 88 ms (vx 91% faster)      | 1,712 ms (vx 99% faster) |
+
+vx N% faster: vx takes N% less time than that tool (1 − vx ÷ theirs); N% slower: N% more (vx ÷ theirs − 1).
 
 Time added is the wall time over the tasks' own ideal schedule (3 min 38 s).
 Same graph, commands and concurrency: [how it is measured](https://vznjs.github.io/vx/benchmarks/).
 
 <!-- bench:end -->
 
-## Tried on real repos
-
-Public monorepos, each run with its own `turbo.json` or Nx graph against
-the tool it ships with, same machine and tasks per row, medians.
-
-<!-- repos:start — generated by packages/vx-bench/update-site.ts from real-repos.json; do not hand-edit -->
-
-| 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        |
-| [unocss/unocss](https://github.com/unocss/unocss)                   | Turbo   | 45.1 s / 47.3 s       | 859 ms / **185 ms** | 770 ms / **126 ms**    |
-| [vueuse/vueuse](https://github.com/vueuse/vueuse)                   | Turbo   | 21.4 s / 29.2 s       | 263 ms / **128 ms** | 246 ms / **51–161 ms** |
-| [t3-oss/create-t3-turbo](https://github.com/t3-oss/create-t3-turbo) | Turbo   | 27.2 s / 29.6 s       | 199 ms / 340 ms     | 174 ms / 342 ms        |
-| [TanStack/query](https://github.com/TanStack/query)                 | Nx      | 34.6 s / 37.1 s       | 910 ms / 1.62 s     | 291 ms / 1.60 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      | 123.0 s / 138.0 s     | 1.27 s / 3.82 s     | 626 ms / 3.91 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        |
-
-vx first, theirs second; **bold** marks the other tool winning. These
-rows ran vx without a lock (every config evaluated per run); the harness
-now runs it from a `vx lock` snapshot (`--frozen`). How each
-repo was run, versions, dates and why a tool wins where it does:
-[vx on real Turbo and Nx repos](https://vznjs.github.io/vx/benchmarks/real-repos/).
-
-<!-- repos:end -->
-
 ## Why it is faster
 
 - **Nothing boots per task.** No daemon, no Node process per task: vx
@@ -71,46 +41,20 @@ repo was run, versions, dates and why a tool wins where it does:
 - **One pass over the repo.** One git walk per run; each stat and
   lookup happens once.
 
-## Try it on your repo
-
-In a Turborepo or Nx workspace:
-
-```sh
-npm install -D @vzn/vx @vzn/vx-migrate
-npx vx init                 # writes vx.workspace.ts, below; nothing else
-npx vx run build --all      # your turbo.json or Nx targets, run by vx
-npx vx run build --all      # again: up-to-date in milliseconds
-```
-
-The one file `vx init` writes (in an Nx repo, `nx` for `turbo`):
-
-```ts
-import type { WorkspaceConfig } from '@vzn/vx/config'
-import { turbo } from '@vzn/vx-migrate'
-
-export default { plugins: [turbo()] } satisfies WorkspaceConfig
-```
-
-Nothing is rewritten. `@vzn/vx-migrate` is not on npm yet (first publish
-pending); [`examples/turbo`](examples/turbo) runs this setup, and
-`packages/vx/tests/try-it.unsafe.test.ts` runs these exact lines on a Turbo
-and an Nx repo, on every commit. Which `turbo.json`, `nx.json` and `project.json` keys vx honours,
-key by key: [Turbo and Nx config support](https://vznjs.github.io/vx/compare/turbo-nx-support/).
-
 ## Install
 
 ```sh
 npm install -D @vzn/vx     # or: pnpm add -D -w · yarn add -D (-W on Yarn 1) · bun add -d
 ```
 
-The package ships a prebuilt binary for Linux and macOS, x64 and arm64
-(Windows via WSL); no Bun needed. The binary alone, from a
+The package ships a prebuilt binary for Linux and macOS, x64 and arm64;
+no Bun needed. The binary alone, from a
 [release](https://github.com/vznjs/vx/releases), needs no Node either.
+Windows: use WSL.
 
 ## Quick start
 
-In a git repo with a `package.json` workspace and no `turbo.json` or
-`nx.json` (those get the one file above):
+In a git repo with a `package.json` workspace:
 
 ```sh
 npx vx init               # a vx.config.ts per package, from its scripts
@@ -151,13 +95,13 @@ runs on every commit. More: [Quickstart](https://vznjs.github.io/vx/quickstart/)
 [CLI](packages/vx/docs/cli.md) · [every config field](packages/vx/docs/schema.md) ·
 [playground](https://vznjs.github.io/vx/playground/) (the planner, in your browser).
 
-## Configs of your own
+## Coming from Turbo or Nx
 
-When you want them, `bunx @vzn/vx-migrate` writes a `vx.config.ts` per
-package from `turbo.json` or the Nx graph. They derive the same cache
-keys, so what `turbo()` cached still hits. `turboCache()` and `nxCache()`
-keep your Turbo or Nx remote cache. [Parity map](packages/vx/docs/parity.md) ·
-[migration guide](https://vznjs.github.io/vx/guides/migrate/).
+`bunx @vzn/vx-migrate` writes a `vx.config.ts` per package from
+`turbo.json` or the Nx graph; `vx init` in such a repo writes a
+`vx.workspace.ts` that reads them in place. Either is a temporary start:
+move to native vx config, which is what the numbers above measure.
+[Migration guide](https://vznjs.github.io/vx/guides/migrate/).
 
 ## More than speed
 
@@ -197,7 +141,7 @@ machine.
 
 | Package                                                    | What it adds                                                                  |
 | ---------------------------------------------------------- | ----------------------------------------------------------------------------- |
-| [`@vzn/vx-migrate`](packages/vx-migrate)                   | Run a Turbo or Nx repo unchanged; write configs; keep its remote cache        |
+| [`@vzn/vx-migrate`](packages/vx-migrate)                   | Migrate from Turbo or Nx: write native configs, keep its remote cache         |
 | [`@vzn/vx-reapi`](packages/vx-reapi)                       | Remote cache and remote execution over Bazel's REAPI (NativeLink, BuildBuddy) |
 | [`@vzn/vx-lockfile`](packages/vx-lockfile)                 | Key each project on its own lockfile slice: pnpm, bun, npm, yarn              |
 | [`@vzn/vx-otel`](packages/vx-otel)                         | OpenTelemetry traces, metrics and logs, no SDK                                |

package/package.json

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

package/src/cache/archive.ts

@@ -122,10 +122,6 @@ const drain = async (body: AsyncIterable<Uint8Array>): Promise<void> => {
   }
 }
 
-const WIN32 = process.platform === 'win32'
-// A Windows link target may be spelled with either separator.
-const LINK_SEP = WIN32 ? /[\\/]/ : '/'
-
 /**
  * Sidecar shape. `files` maps an entry name to `[mode, mtimeMs]` — a
  * pair, not an object, because the sidecar is real entropy inside an
@@ -271,9 +267,7 @@ export async function planArtifact(args: PackArgs): Promise<ArtifactPlan> {
           `output ${shown} is not a regular file (a symlink to a directory?): vx stores regular files only — emit a file there, or narrow cache.outputs.files to the files the task produces, or take it back with a '!' entry`,
         )
       }
-      // Windows reports 0o666 (0o444 read-only) and never an exec bit: a
-      // Linux restore of that would be world-writable.
-      const mode = WIN32 ? 0o644 : st.mode & 0o777
+      const mode = st.mode & 0o777
       meta.files[name] = [mode, Math.floor(st.mtimeMs)]
       return {
         name,
@@ -788,9 +782,7 @@ class Extractor {
     let n = 0
     for (const s of this.staged) {
       const [mode, mtimeMs] = metaFor(s.name)
-      // Windows has no mode bits: chmod there only sets the read-only
-      // attribute, and a read-only restore refuses the next rename over it.
-      if ((mode & 0o777) !== createdMode && !WIN32) chmodSync(s.tmp, mode & 0o777)
+      if ((mode & 0o777) !== createdMode) chmodSync(s.tmp, mode & 0o777)
       if (mtimeMs !== undefined) {
         // A Date, not seconds: Bun reads a negative number of seconds as
         // "now", and a Date before 1970 as itself (Bun 1.4.2).
@@ -904,7 +896,7 @@ async function resolveThrough(p: string): Promise<string> {
       at = path.parse(link).root
       rest = link.slice(at.length)
     }
-    pending.push(...rest.split(LINK_SEP).filter(Boolean).reverse())
+    pending.push(...rest.split('/').filter(Boolean).reverse())
   }
   return at
 }

package/src/cache/cache.ts

@@ -2026,8 +2026,8 @@ const SQLITE_FCNTL_PERSIST_WAL = 10
  * Close for real. A plain `close()` leaves the connection open while any
  * statement from `db.prepare()` lives (bun:sqlite 1.4.2 defers it, as
  * `sqlite3_close_v2` does), so `cache.db` and its `-wal` and `-shm` stayed
- * open after `Cache.close()`: a leaked descriptor per run for an embedder,
- * and on Windows a cache directory nothing could delete (O-10).
+ * open after `Cache.close()`: a leaked descriptor per run for an embedder
+ * (O-10).
  * `close(true)` finalizes them and closes.
  */
 function closeDb(db: Database): void {

package/src/cache/git-inputs.ts

@@ -556,7 +556,8 @@ export interface BlobSizeMemo {
  * the ones it lacks from one `cat-file` (65 ms over 3,000 loose objects,
  * the whole of the cost, measured 2026-10-02). A smudged (racy) entry
  * records 0 and is hashed from disk. An answer that cannot be read trusts
- * nothing.
+ * nothing. A filter that keeps the size (`tr a-z A-Z`) is not caught: only
+ * a read of every trusted file would be (caching.md, step 12).
  */
 async function dropResizedOids(enumeration: GitEnumeration, memo?: BlobSizeMemo): Promise<void> {
   const { trusted, indexed } = enumeration

package/src/cache/inputs.ts

@@ -22,7 +22,6 @@ import { rm, rmdir } from 'node:fs/promises'
 import type { CacheInputs } from '../config.js'
 import {
   asTrees,
-  executablePath,
   isExecutableMissing,
   isLiteralPattern,
   normalizeGlob,
@@ -394,17 +393,15 @@ async function runRuntimeCommand(
     // vx's own `sh`, resolved on its PATH before the probe's: Bun.spawn looks
     // a bare name up on the child's PATH, which leads with the project's
     // `node_modules/.bin`, so a dependency's `sh` bin ran every probe (J-69).
-    const argv =
-      process.platform === 'win32' ? shellArgv(command) : [executablePath('sh'), '-c', command]
-    proc = Bun.spawn(argv, {
+    proc = Bun.spawn(shellArgv(command), {
       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`). Windows has no groups.
-      detached: process.platform !== 'win32',
+      // (`killProbesOnExit`).
+      detached: true,
     })
   } catch (err) {
     // The probe runs through `sh -c` like a task: a box without sh names

package/src/cli/help.ts

@@ -61,7 +61,8 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '                             foo, @scope/*, ./packages/foo, foo..., ...foo,',
     '                             foo^..., !foo, [<since>]',
     '      --affected[=<base>]  Sugar for --filter "...[<base>]". Default base =',
-    '                             affectedBase, else origin/HEAD, else HEAD~1.',
+    '                             affectedBase, else origin/HEAD, else main or',
+    '                             master, else HEAD~1.',
     "  pkg#task                 Run a specific project's task directly.",
     '',
     'Execution (for run):',

package/src/cli/init.ts

@@ -193,7 +193,7 @@ async function adopt(
           ? ''
           : `${cache}(): ${remote}, so vx shares that remote cache (inert where the variable is unset).\n`
   process.stdout.write(
-    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate runs this repo as it is; nothing else written.\n` +
+    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate, a temporary start until bunx @vzn/vx-migrate writes native config; nothing else written.\n` +
       `${wrote}\n${cacheLine}\nnext: ${adoptionNext(root, runner, source)}\n`,
   )
   return 0

package/src/cli/upgrade.ts

@@ -21,11 +21,10 @@ const REPO = 'vznjs/vx'
 
 /**
  * A Bun standalone-binary path lives under the bunfs virtual root.
- * Marker differs by platform / Bun version: `/$bunfs/...` (posix) and
- * `B:\~BUN\...` or `B:/~BUN/...` (windows).
+ * Marker: `/$bunfs/...`.
  */
 export function isBunfsPath(p: string): boolean {
-  return p.startsWith('/$bunfs') || p.startsWith('B:\\~BUN') || p.startsWith('B:/~BUN')
+  return p.startsWith('/$bunfs')
 }
 
 /**

package/src/config.ts

@@ -24,8 +24,9 @@ export interface WorkspaceConfig {
   cacheRetention?: { olderThan?: string; maxSize?: string }
   /**
    * The git ref a bare `--affected` compares with (`origin/develop`).
-   * `--affected=<base>` overrides it. Omitted → `origin/HEAD`, else
-   * `HEAD~1`. Never folded into a cache key.
+   * `--affected=<base>` overrides it. Omitted → `origin/HEAD`, then the
+   * first of `origin/main`, `origin/master`, `main`, `master` that is not
+   * HEAD, else `HEAD~1`. Never folded into a cache key.
    */
   affectedBase?: string
   /**

package/src/exec/env.ts

@@ -32,22 +32,6 @@ export const ESSENTIAL_ENV: readonly string[] = [
   'NO_COLOR',
   'CI',
   'NODE_OPTIONS',
-  'SYSTEMROOT',
-  'APPDATA',
-  'LOCALAPPDATA',
-  'PROGRAMDATA',
-  'PROGRAMFILES',
-  'PROGRAMFILES(X86)',
-  'COMSPEC',
-  'PATHEXT',
-  // Read on Windows by os.homedir(), npm and git, which break without them.
-  'SYSTEMDRIVE',
-  'WINDIR',
-  'USERPROFILE',
-  'HOMEDRIVE',
-  'HOMEPATH',
-  'NUMBER_OF_PROCESSORS',
-  'PROCESSOR_ARCHITECTURE',
 ]
 
 /**

package/src/exec/kill-tree.ts

@@ -15,25 +15,6 @@ import { executablePath, procfsIsOwn } from '../util/index.js'
 
 export type Child = ReturnType<typeof Bun.spawn>
 
-const WIN32 = process.platform === 'win32'
-
-/**
- * Windows has no process groups (`kill(-pid)` is ESRCH, which read as
- * "gone" and killed nothing) and no polite signal a console task hears
- * from another process, so every stop is `taskkill /T /F`: the child and
- * every descendant it still parents. A grandchild whose parent already
- * exited is out of the tree's reach (docs/design/windows-2026-09.md).
- */
-function killTreeWin32(child: Child): void {
-  try {
-    Bun.spawn(['taskkill', '/T', '/F', '/PID', String(child.pid)], {
-      stdio: ['ignore', 'ignore', 'ignore'],
-    })
-  } catch {
-    child.kill()
-  }
-}
-
 /**
  * A child whose polite signals go down a pipe instead of to its group: a
  * Linux sandboxed task. The group there is bwrap's, whose monitor dies of
@@ -97,8 +78,6 @@ 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',
@@ -227,7 +206,6 @@ export function killTree(child: Child, signal: 'SIGINT' | 'SIGTERM' | 'SIGKILL')
   // A pid of 0 would name OUR group (kill(0)): a child that never
   // spawned has nothing to kill.
   if (!(child.pid > 0) || goneGroups.has(child)) return
-  if (WIN32) return killTreeWin32(child)
   const fd = signal === 'SIGKILL' ? undefined : channels.get(child)
   if (fd !== undefined) {
     try {
@@ -297,8 +275,6 @@ export async function untilGroupsGone(
  */
 function groupAlive(child: Child): boolean {
   if (!(child.pid > 0) || goneGroups.has(child)) return false
-  // No groups: the tree kill is `taskkill /T`, and the leader is what is left to ask.
-  if (WIN32) return child.exitCode === null && child.signalCode === null
   try {
     process.kill(-child.pid, 0)
   } catch (err) {

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, signalExitCode } from './runner.js'
+import { runCommand, signalExitCode, stopSignal } from './runner.js'
 import { runSandboxed } from './sandbox-runtime.js'
 import type { TaskExecutor } from './executor.js'
 
@@ -29,8 +29,7 @@ export function localExecutor(): TaskExecutor {
       // 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 signal = stopSignal(req.signal.reason)
         const exitCode = signalExitCode(signal)
         return { exitCode, durationMs: 0, stdout: '', stderr: '', signal, violations: [] }
       }

package/src/exec/runner.ts

@@ -4,7 +4,7 @@
 // process exits. cpuMs / peakRssBytes are then surfaced on RunResult and
 // folded into the v11 `runs` table by the orchestrator.
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { constants as osConstants } from 'node:os'
 import {
   shellArgv,
@@ -25,9 +25,8 @@ 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' }
+/** `sh` names itself in its errors. */
+const SH_ARGV0 = { argv0: 'sh' }
 
 export interface RunResult {
   exitCode: number
@@ -224,8 +223,6 @@ 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}`
 }
@@ -254,6 +251,16 @@ export function signalExitCode(signal: string): number {
   return num === undefined ? 130 : 128 + num
 }
 
+/**
+ * The signal a run's stop sends a task, from its abort reason: a task
+ * stopped before its spawn exits as if that signal had killed it. As
+ * `forwardedSignal` (orchestrator/signals.ts): a hang-up forwards SIGTERM
+ * (to many servers SIGHUP means "reload"), so it reads as SIGTERM here.
+ */
+export function stopSignal(reason: unknown): 'SIGINT' | 'SIGTERM' {
+  return reason === 'SIGINT' ? 'SIGINT' : 'SIGTERM'
+}
+
 /**
  * The reverse: the signal an exit above 128 stands for (137 → SIGKILL),
  * by the platform's numbering; undefined for a plain exit. The shell
@@ -484,9 +491,8 @@ 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. Windows has no groups, and a
-          // detached child there has no console.
-          detached: !WIN32,
+          // never stops on a terminal read.
+          detached: true,
         },
       ),
     )
@@ -695,9 +701,8 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
         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,
+        // never stops on a terminal read.
+        detached: true,
       }),
     )
   } catch (err) {
@@ -750,18 +755,15 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
  * `true` read 44 MB through vx while its shell's `VmHWM` was 1.9 MB, and
  * 300 MB allocated in the parent made `true` read 328 MB (2026-09-12).
  * Read after the child exits so it covers the whole task's span (the mark
- * is monotonic). Linux reads `VmHWM`; elsewhere the current RSS is the
- * bound in hand.
+ * is monotonic). Linux reads its own peak (`getrusage`); elsewhere the
+ * current RSS is the bound in hand.
  */
 export function ownRssHighWater(): number {
-  if (process.platform === 'linux') {
-    try {
-      const m = /VmHWM:\s+(\d+) kB/.exec(readFileSync('/proc/self/status', 'utf8'))
-      if (m !== null) return Number(m[1]) * 1024
-    } catch {
-      // /proc unreadable: fall through to the current RSS.
-    }
-  }
+  // getrusage's own peak, not `/proc/self/status`'s `VmHWM`: one syscall
+  // where generating and parsing the status file was ~20 µs a task alone
+  // and ~70 ms of a 1,000-task cold run. It is the same mark, raised only
+  // by the image this one exec'd from (a shell), within the floor's slack.
+  if (process.platform === 'linux') return peakRssBytes(process.resourceUsage().maxRSS)
   return process.memoryUsage.rss()
 }
 

package/src/exec/sandbox-binds.ts

@@ -10,6 +10,7 @@ import {
   isMountableLiteral,
   localBindingOn,
   MOUNT_WILDCARDS,
+  toRealPath,
   unique,
 } from './sandbox-paths.js'
 import type { SandboxedRunArgs } from './sandbox-runtime.js'
@@ -27,27 +28,50 @@ type SrtModule = typeof import('@anthropic-ai/sandbox-runtime')
  * is "Device or resource busy"; binding `/w/dist` instead succeeds.
  *
  * So on Linux a file-shaped grant is widened to its directory. That IS a
- * widening — the task may write its siblings — and it is the narrowest
+ * widening — the task may write its siblings, and read them unrefused
+ * (`widenedEntries` has those reads reported) — and it is the narrowest
  * grant the mechanism can express: the alternative is a declared output
  * the task cannot produce. macOS needs none of this (seatbelt matches
  * paths, it does not mount), so the grant stays exact there.
  */
 export function bindableWrites(paths: readonly string[]): string[] {
   if (process.platform !== 'linux') return [...paths]
-  return unique(
-    paths
-      .filter((p) => !holdsGlobChar(p))
-      .map((p) => {
-        if (!isMountableLiteral(p)) return p
-        try {
-          if (statSync(p).isDirectory()) return p
-        } catch {
-          // Does not exist yet: `prepareOutputsForBind` creates a file for a
-          // file-shaped grant, so treat it as one.
-        }
-        return path.dirname(p)
-      }),
-  )
+  return unique(paths.filter((p) => !holdsGlobChar(p)).map(bindOf))
+}
+
+function bindOf(p: string): string {
+  if (!isMountableLiteral(p)) return p
+  try {
+    if (statSync(p).isDirectory()) return p
+  } catch {
+    // Does not exist yet: `prepareOutputsForBind` creates a file for a
+    // file-shaped grant, so treat it as one.
+  }
+  return path.dirname(p)
+}
+
+/**
+ * What each directory `bindableWrites` widened a file grant to held when
+ * the task started, by real path. A read there is never refused, so the
+ * strace pass reports one of these no grant covers: a task granted
+ * `write: ['out.txt']` read the whole project unreported, and a cached run
+ * replayed an undeclared file's old bytes. What the task creates there is
+ * its own, not an input, so only these entries count. Empty off Linux.
+ */
+export function widenedEntries(paths: readonly string[]): Map<string, Set<string>> {
+  const out = new Map<string, Set<string>>()
+  if (process.platform !== 'linux') return out
+  for (const p of paths) {
+    if (holdsGlobChar(p) || bindOf(p) === p) continue
+    const dir = toRealPath(path.dirname(p))
+    if (out.has(dir)) continue
+    try {
+      out.set(dir, new Set(readdirSync(dir).map((e) => path.join(dir, e))))
+    } catch {
+      // Gone or unreadable: nothing there to read.
+    }
+  }
+  return out
 }
 
 /**