@vzn/vx 0.0.94 → 0.0.96

package/package.json

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

package/src/cache/tar-stream.ts

@@ -174,8 +174,10 @@ export async function* tarEntries(stream: ReadableStream<Uint8Array>): AsyncGene
     const size = pendingSize ?? octal(h, 124, 12)
     const mtimeMs = octal(h, 136, 12) * 1000
     const padded = Math.ceil(size / BLOCK) * BLOCK
-    const magic = field(h, 257, 6)
-    const prefix = magic.startsWith('ustar') ? field(h, 345, 155) : ''
+    // POSIX `ustar\0` only: old GNU's `ustar  ` keeps atime and ctime at
+    // 345, and `-G` fills them, so a prefix read there named every entry
+    // `<atime>…/<name>`.
+    const prefix = field(h, 257, 6) === 'ustar' ? field(h, 345, 155) : ''
     const rawName = field(h, 0, 100)
     let name = pendingPath ?? (prefix ? `${prefix}/${rawName}` : rawName)
     pendingPath = undefined

package/src/cli/show.ts

@@ -83,7 +83,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const bareTask = projectName !== undefined && taskName === undefined && !byName.has(projectName)
   const scope = projectName === undefined || bareTask ? 'all' : [projectName]
 
-  const projects = await loadCliProjects(root, metas, scope)
+  const projects = await loadCliProjects(root, metas, scope, { noCreate: true })
 
   if (parsed.target === undefined) {
     process.stdout.write(renderList(root, metas, projects, parsed.format))

package/src/cli/watch-filter.ts

@@ -0,0 +1,274 @@
+// `vx watch`'s event filters: which paths never start a cycle (the ignore
+// rules, git-ignored paths, the root arm's filter) and which files reshape
+// the watched set. Pure decisions over paths; the loop acts on them.
+
+import path from 'node:path'
+import {
+  executablePath,
+  isLiteralPattern,
+  normalizeGlob,
+  staticPrefix,
+  taskGlob,
+} from '../util/index.js'
+import { asTrees } from '../cache/index.js'
+import {
+  PROJECT_CONFIG_FILENAMES,
+  WORKSPACE_CONFIG_FILENAMES,
+  WORKSPACE_FINGERPRINT_FILES,
+} from '../workspace/index.js'
+import { IGNORED_SEGMENTS } from './watch-fs.js'
+
+const IGNORED_SUFFIXES = ['.tsbuildinfo', '~']
+
+/**
+ * True for a path the ignore filter drops. Every project dir is watched
+ * RECURSIVELY, so without this a `bun install` would re-run the graph on every
+ * file it writes, and vx's own `.vx/cache` writes would trigger a cycle that
+ * writes to `.vx/cache` again.
+ *
+ * Segment-wise, not prefix-wise: `node_modules` is ignored wherever it appears
+ * in the path, not only at the root.
+ */
+export function isIgnoredWatchPath(rel: string): boolean {
+  const segments = rel.split(path.sep)
+  if (segments.some((s) => IGNORED_SEGMENTS.includes(s))) return true
+  if (IGNORED_SUFFIXES.some((suf) => rel.endsWith(suf))) return true
+  return false
+}
+
+/**
+ * The ignore predicate a watcher applies, closed over the run's ACTUAL cache
+ * directory.
+ *
+ * `IGNORED_SEGMENTS` covers the `.vx/cache` default, but `cacheDir` is a
+ * shipped `defineWorkspace` field: point it anywhere else and vx's own cache
+ * writes land in a watched subtree, so every cycle triggers the next one.
+ * Measured on a relocated cache under a recursive root watcher: ONE edit kicked
+ * it and the loop then ran **22 more times during 6 seconds of total silence**
+ * (~3.7 re-runs/second, forever) where the default `.vx` cache settles at 0.
+ * A hard-coded literal cannot see a configured path — the resolved one can.
+ */
+export function makeWatchIgnore(
+  cacheDir: string,
+  outputs: ReadonlyMap<string, readonly string[]> = new Map(),
+  inputs: ReadonlyMap<string, readonly string[]> = new Map(),
+): (base: string, filename: string) => boolean {
+  const cacheAbs = path.resolve(cacheDir)
+  // A task's own outputs are not edits: without this every cycle that
+  // writes `dist/` (or `out.txt`) re-runs once more, reporting
+  // "up-to-date" for the trouble. Matched under the directory the globs
+  // are relative to, whichever watcher delivered the event.
+  // The directory that HOLDS an output tree is the task's too: `dist/**`
+  // does not match `dist`, and since the clean before a miss prunes an
+  // emptied `dist` (2026-09-10) the task re-creates it, which the watcher
+  // reports as a change to `dist` itself — a second cycle per edit,
+  // reporting "up-to-date". The literal prefix of each glob (`dist` for
+  // `dist/**`, `build/out` for `build/out/*.js`; nothing for `*.js`) and
+  // every ancestor of it under the dir are output containers.
+  // A literal entry means the file or its whole tree — the resolver's own
+  // rule (`asTrees`), so the tree's files never count as edits.
+  const declared = [...outputs].map(
+    ([dir, globs]) =>
+      [
+        path.resolve(dir),
+        asTrees(globs).map((g) => taskGlob(g)),
+        globs.map(outputContainer).filter((c) => c !== ''),
+      ] as const,
+  )
+  // A path some task takes as an INPUT is never an output to ignore, even
+  // when another task declares it one: an in-place formatter declaring
+  // `src/**` hid every `src` edit from a `build` watched beside it, and no
+  // cycle ran (item 946). Negations are not consulted — they only narrow,
+  // and a path they would exclude costs one cache-hit cycle.
+  const read = [...inputs].map(
+    ([dir, globs]) =>
+      [
+        path.resolve(dir),
+        asTrees(globs.filter((g) => !g.startsWith('!'))).map((g) => taskGlob(g)),
+      ] as const,
+  )
+  const isInput = (abs: string): boolean =>
+    read.some(([dir, globs]) => {
+      if (!abs.startsWith(dir + path.sep)) return false
+      const rel = abs
+        .slice(dir.length + 1)
+        .split(path.sep)
+        .join('/')
+      return globs.some((g) => g.match(rel))
+    })
+  return (base, filename) => {
+    if (isIgnoredWatchPath(filename)) return true
+    const abs = path.resolve(base, filename)
+    if (abs === cacheAbs || abs.startsWith(cacheAbs + path.sep)) return true
+    if (isInput(abs)) return false
+    for (const [dir, globs, containers] of declared) {
+      if (!abs.startsWith(dir + path.sep)) continue
+      const rel = abs
+        .slice(dir.length + 1)
+        .split(path.sep)
+        .join('/')
+      if (globs.some((g) => g.match(rel))) return true
+      if (containers.some((c) => c === rel || c.startsWith(`${rel}/`))) return true
+    }
+    return false
+  }
+}
+
+/**
+ * The literal directory a glob's matches live under (`''` when the glob
+ * starts with a pattern, or negates). A literal entry is a file or its
+ * whole tree (schema: literal → tree), so the entry itself is the
+ * container; a pattern's is `staticPrefix` — the same rule the sandbox
+ * baseline and the deferral gate read.
+ */
+function outputContainer(raw: string): string {
+  const glob = normalizeGlob(raw)
+  if (glob.startsWith('!')) return ''
+  if (isLiteralPattern(glob)) return glob.replace(/\/+$/, '')
+  const prefix = staticPrefix(glob)
+  return prefix === '.' || prefix === '/' ? '' : prefix
+}
+
+/**
+ * The subset of `paths` git ignores, asked once per judgement (one
+ * `git check-ignore` per debounce window that has candidates, never per
+ * event). A git-ignored path is invisible to every cache key — inputs
+ * are tracked + untracked-not-ignored — so a cycle it starts can change
+ * nothing, and a task that writes one on every run (a pid file, a
+ * timestamped log, `.next/trace`) made the loop re-run itself forever
+ * (2026-09-16: 29 cycles in 8 s from one edit). A TRACKED file that
+ * matches a pattern is not reported, by git's own rule, so it stays an
+ * edit. Outside a repository (exit 128) nothing is ignored, as before.
+ */
+export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set<string> {
+  const ignored = new Set<string>()
+  if (paths.length === 0) return ignored
+  let proc: ReturnType<typeof Bun.spawnSync>
+  try {
+    proc = Bun.spawnSync({
+      cmd: [executablePath('git'), 'check-ignore', '-z', '--stdin'],
+      cwd: workspaceRoot,
+      stdin: Buffer.from(paths.map((p) => `${p}\0`).join('')),
+      stdout: 'pipe',
+      stderr: 'ignore',
+    })
+  } catch {
+    // No git on PATH: nothing is ignored, and the loop keeps judging —
+    // the initial run already said what vx requires.
+    return ignored
+  }
+  // 0: some ignored; 1: none. Anything else is git refusing (not a
+  // repository, a path inside a nested one): no path is ignored.
+  if (proc.exitCode !== 0) return ignored
+  for (const p of new TextDecoder().decode(proc.stdout).split('\0'))
+    if (p.length > 0) ignored.add(p)
+  return ignored
+}
+
+/**
+ * Under the recursive root watcher, the events that can move a key. The
+ * watcher hears every write in the workspace; a key can see three kinds
+ * of path and no other: a file inside a project's directory (its own
+ * `inputs.files`, or its outputs, which the ignore filter drops next), a
+ * workspace fingerprint file at the root, and a match of a declared
+ * `inputs.workspaceFiles` glob. Everything else — a log written at the
+ * root, a `coverage/` or `.turbo/` tree, an editor's scratch file — is
+ * dropped before the trigger, so it costs no cycle. Before this rule the
+ * one Turbo idiom that puts every repo on this watcher
+ * (`globalDependencies` → `workspaceFiles`) made `vx watch … > build.log`
+ * inside the repo a loop that never settled: each cycle's output grew the
+ * log, the log was an event, the event was a cycle. Negated globs are not
+ * consulted: a `!` only narrows, and an event it would have excluded costs
+ * one cache-hit cycle, which is the wrong direction to be clever in.
+ */
+export function makeRootEventFilter(
+  workspaceRoot: string,
+  projectDirs: readonly string[],
+  workspaceInputs: readonly string[],
+  claimedRootFiles: ReadonlySet<string> = new Set(),
+): (filename: string) => boolean {
+  const dirs = projectDirs.map((d) => path.resolve(d))
+  const globs = workspaceInputs
+    .map(normalizeGlob)
+    .filter((g) => !g.startsWith('!'))
+    .map((g) => taskGlob(g))
+  return (filename: string): boolean => {
+    const rel = filename.split(path.sep).join('/')
+    // The depth test is a READING AID, not a guard: both predicates below
+    // are exact membership in a set of BARE names, so a `rel` carrying a
+    // slash can never be in one. Measured with it removed (item 502) over
+    // `nested/bun.lock`, `./bun.lock`, `a/b/c/pnpm-workspace.yaml` and
+    // eight more: every answer identical. The two table rows that look
+    // like they pin it — `nested/pnpm-lock.yaml → false` and
+    // `nested/vx.workspace.ts → false` — pass either way; what they
+    // actually pin is that the predicates stay exact rather than becoming
+    // a basename or suffix match, which is the change that WOULD make
+    // this line load-bearing.
+    if (
+      !rel.includes('/') &&
+      (isWorkspaceFingerprintFile(rel) ||
+        isWorkspaceConfigFile(rel) ||
+        rel === 'package.json' ||
+        claimedRootFiles.has(rel))
+    ) {
+      return true
+    }
+    const abs = path.resolve(workspaceRoot, filename)
+    for (const d of dirs) if (abs === d || abs.startsWith(d + path.sep)) return true
+    for (const g of globs) if (g.match(rel)) return true
+    return false
+  }
+}
+
+/**
+ * A file whose edit can change what the loop watches: a `package.json`
+ * (a dependency added under `--filter` widens the closure), a project
+ * config (a task that starts declaring `workspaceFiles` needs the root
+ * watcher, a new output must stop being an event) or the workspace config
+ * (a plugin's `project` stage). Until item 891 only a member directory
+ * coming or going re-read the set, so each of these waited for a restart
+ * while the loop looked alive. A root fingerprint file too, for
+ * `pnpm-workspace.yaml`: a glob added there was a cycle that ran the new
+ * packages and watched none of them (item 1018).
+ */
+const PROJECT_CONFIGS: ReadonlySet<string> = new Set(PROJECT_CONFIG_FILENAMES)
+
+export function shapesWatchedSet(filename: string): boolean {
+  const base = path.basename(filename)
+  return (
+    base === 'package.json' ||
+    isWorkspaceFingerprintFile(base) ||
+    PROJECT_CONFIGS.has(base) ||
+    isWorkspaceConfigFile(base)
+  )
+}
+
+export function isWorkspaceFingerprintFile(name: string): boolean {
+  return FINGERPRINT_FILES.has(name)
+}
+
+/**
+ * The workspace config is the one root file that shapes a run without
+ * being any task's input — its plugins, `config` stage, concurrency, cache
+ * dir — and a cycle re-evaluates it (its import is keyed on its bytes).
+ * Until 2026-09-10 neither root arm listened for it: a plugin added under
+ * `vx watch` waited for a restart while the loop looked alive.
+ */
+const WORKSPACE_CONFIGS: ReadonlySet<string> = new Set(WORKSPACE_CONFIG_FILENAMES)
+
+export function isWorkspaceConfigFile(name: string): boolean {
+  return WORKSPACE_CONFIGS.has(name)
+}
+
+/**
+ * True for a root file that re-keys EVERY task, so a change to one must trigger
+ * a cycle even though it lives in no project dir.
+ *
+ * Reads the SHARED constant the fingerprint itself walks — this used to be a
+ * third hand-rolled copy of that list, which is precisely the drift the
+ * `--affected` wave exported the constant to prevent. A name added there but
+ * not here would re-key every task while `vx watch` silently never re-ran on
+ * it: the loop looks alive, and the one edit that invalidates the whole
+ * workspace is the one it ignores.
+ */
+const FINGERPRINT_FILES: ReadonlySet<string> = new Set(WORKSPACE_FINGERPRINT_FILES)

package/src/cli/watch.ts

@@ -14,16 +14,9 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import {
-  executablePath,
-  isLiteralPattern,
-  normalizeGlob,
-  staticPrefix,
-  taskGlob,
-  xxh3,
-} from '../util/index.js'
-import { asTrees } from '../cache/index.js'
+import { xxh3 } from '../util/index.js'
 import { parseRunArgs, resolveRunOptions, type RunArgs } from './run.js'
+import { seeHelp } from './help.js'
 import {
   fingerprintClaims,
   forwardedSignal,
@@ -40,20 +33,26 @@ import {
   loadWorkspace,
   LOCKFILE_NAME,
   memberBaseDirs,
-  PROJECT_CONFIG_FILENAMES,
   WORKSPACE_CONFIG_FILENAMES,
   configImports,
-  WORKSPACE_FINGERPRINT_FILES,
   type ProjectEntry,
   type ProjectMeta,
 } from '../workspace/index.js'
 import type { ProjectConfig } from '../config.js'
 import { type CliLoadOptions, loadCliProjects, loadCliWorkspace } from './workspace-config.js'
 import { taskEdges, taskEdgesFrom } from './select.js'
+import {
+  gitIgnored,
+  isIgnoredWatchPath,
+  isWorkspaceConfigFile,
+  isWorkspaceFingerprintFile,
+  makeRootEventFilter,
+  makeWatchIgnore,
+  shapesWatchedSet,
+} from './watch-filter.js'
 import {
   armWatcher,
   fsClockNow,
-  IGNORED_SEGMENTS,
   modifiedBefore,
   pollWatcher,
   POLL_INTERVAL_MS,
@@ -64,153 +63,6 @@ import {
 /** Wait this long after the last filesystem event before re-running. */
 const DEBOUNCE_MS = 150
 
-const IGNORED_SUFFIXES = ['.tsbuildinfo', '~']
-
-/**
- * True for a path the ignore filter drops. Every project dir is watched
- * RECURSIVELY, so without this a `bun install` would re-run the graph on every
- * file it writes, and vx's own `.vx/cache` writes would trigger a cycle that
- * writes to `.vx/cache` again.
- *
- * Segment-wise, not prefix-wise: `node_modules` is ignored wherever it appears
- * in the path, not only at the root.
- */
-export function isIgnoredWatchPath(rel: string): boolean {
-  const segments = rel.split(path.sep)
-  if (segments.some((s) => IGNORED_SEGMENTS.includes(s))) return true
-  if (IGNORED_SUFFIXES.some((suf) => rel.endsWith(suf))) return true
-  return false
-}
-
-/**
- * The ignore predicate a watcher applies, closed over the run's ACTUAL cache
- * directory.
- *
- * `IGNORED_SEGMENTS` covers the `.vx/cache` default, but `cacheDir` is a
- * shipped `defineWorkspace` field: point it anywhere else and vx's own cache
- * writes land in a watched subtree, so every cycle triggers the next one.
- * Measured on a relocated cache under a recursive root watcher: ONE edit kicked
- * it and the loop then ran **22 more times during 6 seconds of total silence**
- * (~3.7 re-runs/second, forever) where the default `.vx` cache settles at 0.
- * A hard-coded literal cannot see a configured path — the resolved one can.
- */
-export function makeWatchIgnore(
-  cacheDir: string,
-  outputs: ReadonlyMap<string, readonly string[]> = new Map(),
-  inputs: ReadonlyMap<string, readonly string[]> = new Map(),
-): (base: string, filename: string) => boolean {
-  const cacheAbs = path.resolve(cacheDir)
-  // A task's own outputs are not edits: without this every cycle that
-  // writes `dist/` (or `out.txt`) re-runs once more, reporting
-  // "up-to-date" for the trouble. Matched under the directory the globs
-  // are relative to, whichever watcher delivered the event.
-  // The directory that HOLDS an output tree is the task's too: `dist/**`
-  // does not match `dist`, and since the clean before a miss prunes an
-  // emptied `dist` (2026-09-10) the task re-creates it, which the watcher
-  // reports as a change to `dist` itself — a second cycle per edit,
-  // reporting "up-to-date". The literal prefix of each glob (`dist` for
-  // `dist/**`, `build/out` for `build/out/*.js`; nothing for `*.js`) and
-  // every ancestor of it under the dir are output containers.
-  // A literal entry means the file or its whole tree — the resolver's own
-  // rule (`asTrees`), so the tree's files never count as edits.
-  const declared = [...outputs].map(
-    ([dir, globs]) =>
-      [
-        path.resolve(dir),
-        asTrees(globs).map((g) => taskGlob(g)),
-        globs.map(outputContainer).filter((c) => c !== ''),
-      ] as const,
-  )
-  // A path some task takes as an INPUT is never an output to ignore, even
-  // when another task declares it one: an in-place formatter declaring
-  // `src/**` hid every `src` edit from a `build` watched beside it, and no
-  // cycle ran (item 946). Negations are not consulted — they only narrow,
-  // and a path they would exclude costs one cache-hit cycle.
-  const read = [...inputs].map(
-    ([dir, globs]) =>
-      [
-        path.resolve(dir),
-        asTrees(globs.filter((g) => !g.startsWith('!'))).map((g) => taskGlob(g)),
-      ] as const,
-  )
-  const isInput = (abs: string): boolean =>
-    read.some(([dir, globs]) => {
-      if (!abs.startsWith(dir + path.sep)) return false
-      const rel = abs
-        .slice(dir.length + 1)
-        .split(path.sep)
-        .join('/')
-      return globs.some((g) => g.match(rel))
-    })
-  return (base, filename) => {
-    if (isIgnoredWatchPath(filename)) return true
-    const abs = path.resolve(base, filename)
-    if (abs === cacheAbs || abs.startsWith(cacheAbs + path.sep)) return true
-    if (isInput(abs)) return false
-    for (const [dir, globs, containers] of declared) {
-      if (!abs.startsWith(dir + path.sep)) continue
-      const rel = abs
-        .slice(dir.length + 1)
-        .split(path.sep)
-        .join('/')
-      if (globs.some((g) => g.match(rel))) return true
-      if (containers.some((c) => c === rel || c.startsWith(`${rel}/`))) return true
-    }
-    return false
-  }
-}
-
-/**
- * The literal directory a glob's matches live under (`''` when the glob
- * starts with a pattern, or negates). A literal entry is a file or its
- * whole tree (schema: literal → tree), so the entry itself is the
- * container; a pattern's is `staticPrefix` — the same rule the sandbox
- * baseline and the deferral gate read.
- */
-function outputContainer(raw: string): string {
-  const glob = normalizeGlob(raw)
-  if (glob.startsWith('!')) return ''
-  if (isLiteralPattern(glob)) return glob.replace(/\/+$/, '')
-  const prefix = staticPrefix(glob)
-  return prefix === '.' || prefix === '/' ? '' : prefix
-}
-
-/**
- * The subset of `paths` git ignores, asked once per judgement (one
- * `git check-ignore` per debounce window that has candidates, never per
- * event). A git-ignored path is invisible to every cache key — inputs
- * are tracked + untracked-not-ignored — so a cycle it starts can change
- * nothing, and a task that writes one on every run (a pid file, a
- * timestamped log, `.next/trace`) made the loop re-run itself forever
- * (2026-09-16: 29 cycles in 8 s from one edit). A TRACKED file that
- * matches a pattern is not reported, by git's own rule, so it stays an
- * edit. Outside a repository (exit 128) nothing is ignored, as before.
- */
-export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set<string> {
-  const ignored = new Set<string>()
-  if (paths.length === 0) return ignored
-  let proc: ReturnType<typeof Bun.spawnSync>
-  try {
-    proc = Bun.spawnSync({
-      cmd: [executablePath('git'), 'check-ignore', '-z', '--stdin'],
-      cwd: workspaceRoot,
-      stdin: Buffer.from(paths.map((p) => `${p}\0`).join('')),
-      stdout: 'pipe',
-      stderr: 'ignore',
-    })
-  } catch {
-    // No git on PATH: nothing is ignored, and the loop keeps judging —
-    // the initial run already said what vx requires.
-    return ignored
-  }
-  // 0: some ignored; 1: none. Anything else is git refusing (not a
-  // repository, a path inside a nested one): no path is ignored.
-  if (proc.exitCode !== 0) return ignored
-  for (const p of new TextDecoder().decode(proc.stdout).split('\0'))
-    if (p.length > 0) ignored.add(p)
-  return ignored
-}
-
 /**
  * The run flags a watch loop cannot honour, as the refusal line it prints; null
  * when there is none. `WATCH_REFUSED_FLAGS` (help.ts) is the same list for
@@ -245,7 +97,9 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     return 1
   }
   if (parsed.tasks.length === 0) {
-    process.stderr.write(`vx watch: missing task name\n`)
+    process.stderr.write(
+      `vx watch: missing task name (vx watch <task>, e.g. vx watch build)${seeHelp('watch')}\n`,
+    )
     return 1
   }
 
@@ -555,61 +409,6 @@ export async function sweepConfigs(
   return result(null)
 }
 
-/**
- * Under the recursive root watcher, the events that can move a key. The
- * watcher hears every write in the workspace; a key can see three kinds
- * of path and no other: a file inside a project's directory (its own
- * `inputs.files`, or its outputs, which the ignore filter drops next), a
- * workspace fingerprint file at the root, and a match of a declared
- * `inputs.workspaceFiles` glob. Everything else — a log written at the
- * root, a `coverage/` or `.turbo/` tree, an editor's scratch file — is
- * dropped before the trigger, so it costs no cycle. Before this rule the
- * one Turbo idiom that puts every repo on this watcher
- * (`globalDependencies` → `workspaceFiles`) made `vx watch … > build.log`
- * inside the repo a loop that never settled: each cycle's output grew the
- * log, the log was an event, the event was a cycle. Negated globs are not
- * consulted: a `!` only narrows, and an event it would have excluded costs
- * one cache-hit cycle, which is the wrong direction to be clever in.
- */
-export function makeRootEventFilter(
-  workspaceRoot: string,
-  projectDirs: readonly string[],
-  workspaceInputs: readonly string[],
-  claimedRootFiles: ReadonlySet<string> = new Set(),
-): (filename: string) => boolean {
-  const dirs = projectDirs.map((d) => path.resolve(d))
-  const globs = workspaceInputs
-    .map(normalizeGlob)
-    .filter((g) => !g.startsWith('!'))
-    .map((g) => taskGlob(g))
-  return (filename: string): boolean => {
-    const rel = filename.split(path.sep).join('/')
-    // The depth test is a READING AID, not a guard: both predicates below
-    // are exact membership in a set of BARE names, so a `rel` carrying a
-    // slash can never be in one. Measured with it removed (item 502) over
-    // `nested/bun.lock`, `./bun.lock`, `a/b/c/pnpm-workspace.yaml` and
-    // eight more: every answer identical. The two table rows that look
-    // like they pin it — `nested/pnpm-lock.yaml → false` and
-    // `nested/vx.workspace.ts → false` — pass either way; what they
-    // actually pin is that the predicates stay exact rather than becoming
-    // a basename or suffix match, which is the change that WOULD make
-    // this line load-bearing.
-    if (
-      !rel.includes('/') &&
-      (isWorkspaceFingerprintFile(rel) ||
-        isWorkspaceConfigFile(rel) ||
-        rel === 'package.json' ||
-        claimedRootFiles.has(rel))
-    ) {
-      return true
-    }
-    const abs = path.resolve(workspaceRoot, filename)
-    for (const d of dirs) if (abs === d || abs.startsWith(d + path.sep)) return true
-    for (const g of globs) if (g.match(rel)) return true
-    return false
-  }
-}
-
 interface WatchLoopArgs {
   opts: RunOptions
   /** The persistent tasks the initial run left running; the next cycle stops them before it starts. */
@@ -662,29 +461,6 @@ interface Rediscovered {
   packageDirs: ReadonlySet<string>
 }
 
-const PROJECT_CONFIGS: ReadonlySet<string> = new Set(PROJECT_CONFIG_FILENAMES)
-
-/**
- * A file whose edit can change what the loop watches: a `package.json`
- * (a dependency added under `--filter` widens the closure), a project
- * config (a task that starts declaring `workspaceFiles` needs the root
- * watcher, a new output must stop being an event) or the workspace config
- * (a plugin's `project` stage). Until item 891 only a member directory
- * coming or going re-read the set, so each of these waited for a restart
- * while the loop looked alive. A root fingerprint file too, for
- * `pnpm-workspace.yaml`: a glob added there was a cycle that ran the new
- * packages and watched none of them (item 1018).
- */
-function shapesWatchedSet(filename: string): boolean {
-  const base = path.basename(filename)
-  return (
-    base === 'package.json' ||
-    isWorkspaceFingerprintFile(base) ||
-    PROJECT_CONFIGS.has(base) ||
-    isWorkspaceConfigFile(base)
-  )
-}
-
 const CLOSED: WatchHandle = { close() {} }
 
 async function runWatchLoop(args: WatchLoopArgs): Promise<number> {
@@ -1350,33 +1126,3 @@ function sameMembers(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {
   for (const name of a) if (!b.has(name)) return false
   return true
 }
-
-/**
- * True for a root file that re-keys EVERY task, so a change to one must trigger
- * a cycle even though it lives in no project dir.
- *
- * Reads the SHARED constant the fingerprint itself walks — this used to be a
- * third hand-rolled copy of that list, which is precisely the drift the
- * `--affected` wave exported the constant to prevent. A name added there but
- * not here would re-key every task while `vx watch` silently never re-ran on
- * it: the loop looks alive, and the one edit that invalidates the whole
- * workspace is the one it ignores.
- */
-const FINGERPRINT_FILES: ReadonlySet<string> = new Set(WORKSPACE_FINGERPRINT_FILES)
-
-function isWorkspaceFingerprintFile(name: string): boolean {
-  return FINGERPRINT_FILES.has(name)
-}
-
-/**
- * The workspace config is the one root file that shapes a run without
- * being any task's input — its plugins, `config` stage, concurrency, cache
- * dir — and a cycle re-evaluates it (its import is keyed on its bytes).
- * Until 2026-09-10 neither root arm listened for it: a plugin added under
- * `vx watch` waited for a restart while the loop looked alive.
- */
-const WORKSPACE_CONFIGS: ReadonlySet<string> = new Set(WORKSPACE_CONFIG_FILENAMES)
-
-function isWorkspaceConfigFile(name: string): boolean {
-  return WORKSPACE_CONFIGS.has(name)
-}

package/src/cli/workspace-config.ts

@@ -88,6 +88,12 @@ export interface CliLoadOptions {
   cacheDir?: string
   /** `--frozen`: configs come from `vx-lock.json`, not evaluation. */
   frozen?: boolean
+  /**
+   * A reading verb (`vx show`) makes nothing on disk (item 900): with no
+   * cache directory yet, it evaluates without the cache rather than
+   * create one.
+   */
+  noCreate?: boolean
 }
 
 /**
@@ -113,8 +119,11 @@ export async function loadCliProjects(
   // glob could select live what the run then treats otherwise.
   const lock = opts.frozen === true ? await readLockfile(workspaceRoot) : null
   if (opts.frozen === true && lock === null) throw new UserError(FROZEN_WITHOUT_LOCK)
-  const cache = new Cache(cacheDir, { read: true, write: true }, workspaceRoot)
-  noteSchemaReset(cache, warnToStderr)
+  const cache =
+    opts.noCreate === true && !existsSync(cacheDir)
+      ? null
+      : new Cache(cacheDir, { read: true, write: true }, workspaceRoot)
+  if (cache !== null) noteSchemaReset(cache, warnToStderr)
   try {
     const loaded = await loadProjects({
       workspaceRoot,
@@ -125,15 +134,18 @@ export async function loadCliProjects(
       seeds: scope,
       closure: false,
       lock,
-      evalCache: {
-        store: cache,
-        workspaceRoot,
-        workspaceFingerprint: await computeWorkspaceFingerprint(workspaceRoot),
-      },
+      evalCache:
+        cache === null
+          ? undefined
+          : {
+              store: cache,
+              workspaceRoot,
+              workspaceFingerprint: await computeWorkspaceFingerprint(workspaceRoot),
+            },
       warn: warnToStderr,
     })
     return loaded.projects
   } finally {
-    cache.close()
+    cache?.close()
   }
 }

package/src/exec/sandbox-runtime.ts

@@ -678,15 +678,19 @@ export function resolveSandboxConfig(
     r.weakerNetworkIsolation = cfg.weakerNetworkIsolation
   }
   if (cfg.ignore !== undefined) {
-    // Relative patterns anchor at the project dir; `~` ones are taken as
-    // written. A pattern is not a path, but its literal head is: both
+    // Relative patterns anchor at the project dir, `~` ones at the home
+    // directory, as a grant's are (a `~` pattern kept as written matched no
+    // recorded path). A pattern is not a path, but its literal head is: both
     // producers record where a denial LANDS, so the head is canonicalized
     // like every other side of the policy. Anchored at a project reached
     // through a link (macOS's `/var`), no pattern matched and the denial it
     // named failed the task (B-2).
     const anchor = (pat: string): string => {
-      if (pat.startsWith('~')) return pat
-      const abs = path.isAbsolute(pat) ? pat : path.join(projectDir, pat)
+      const abs = pat.startsWith('~')
+        ? path.join(os.homedir(), pat.slice(1))
+        : path.isAbsolute(pat)
+          ? pat
+          : path.join(projectDir, pat)
       const wild = abs.search(BUN_GLOB_WILDCARDS)
       const head = wild === -1 ? abs : abs.slice(0, abs.lastIndexOf(path.sep, wild)) || path.sep
       return toRealPath(head) + abs.slice(head.length)
@@ -906,10 +910,11 @@ function ownGroupCommand(
   // the tracer attached, so one it inherited (the watcher, SRT's network
   // bridges) that exits first sent the command on untraced, and under
   // `--seccomp-bpf` its `execve` failed ENOSYS. A fresh fork has none.
-  // An async list starts with SIGINT and SIGQUIT ignored, and a shell
-  // cannot trap what it was started ignoring: SRT's bash may put them
-  // back before the `exec` (dash may not), so a task's `trap … INT` hears
-  // vx's cancellation as it does untraced.
+  // POSIX lets an async list start with SIGINT and SIGQUIT ignored, and a
+  // shell cannot trap what it was started ignoring: bash 5.2 ignores them
+  // for a backgrounded simple command (the first cut here, whose task's
+  // `trap … INT` never fired) but not for a brace group, so the `trap -`
+  // is for a bash that does; SRT's bash may put them back (dash may not).
   const tracer = [
     executablePath('strace'),
     '-DD',