@vzn/vx 0.0.595 → 0.0.597

package/src/cli/last.ts

@@ -60,7 +60,10 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       if (spaced) i++
       const n = Number(lv)
       if (!Number.isInteger(n) || n < 1 || n > 500) {
-        return { ...out, error: `invalid --list: ${lv} (expected 1..500)` }
+        return {
+          ...out,
+          error: `--list must be a whole number from 1 to 500 (got ${lv})${seeHelp('last')}`,
+        }
       }
       out.list = n
       continue
@@ -77,7 +80,7 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
     }
     const cd = parseCacheDirFlag(args, i)
     if (cd !== null) {
-      if ('error' in cd) return { ...out, error: cd.error }
+      if ('error' in cd) return { ...out, error: `${cd.error}${seeHelp('last')}` }
       out.cacheDir = cd.cacheDir
       i = cd.next
       continue
@@ -96,11 +99,14 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
   if (out.runId !== undefined && out.list !== undefined) {
     return {
       ...out,
-      error: `a run id and --list do not combine: replay ${out.runId}, or list runs`,
+      error: `a run id and --list do not combine: replay ${out.runId}, or list runs${seeHelp('last')}`,
     }
   }
   if (out.runId !== undefined && out.failed === true) {
-    return { ...out, error: `a run id and --failed do not combine: replay ${out.runId}` }
+    return {
+      ...out,
+      error: `a run id and --failed do not combine: replay ${out.runId}${seeHelp('last')}`,
+    }
   }
   return out
 }

package/src/cli/lock.ts

@@ -83,9 +83,11 @@ function bareNote(bare: number): string {
 
 async function writeLock(root: string, metas: ConfiguredMeta[], bare: number): Promise<number> {
   const entries = await Promise.all(metas.map((m) => evaluateEntry(root, m)))
-  const projects: Record<string, LockfileEntry> = {}
-  // `listProjects` sorts by name — stable lockfile diffs for free.
-  for (let i = 0; i < metas.length; i++) projects[metas[i]!.name] = entries[i]!
+  // `listProjects` sorts by name — stable lockfile diffs for free. Defined,
+  // not assigned: a project named `__proto__` set the map's prototype (D-152).
+  const projects: Record<string, LockfileEntry> = Object.fromEntries(
+    metas.map((m, i) => [m.name, entries[i]!]),
+  )
   const leaks = secretsIn(projects)
   if (leaks.length > 0) {
     process.stderr.write(

package/src/cli/plan-format.ts

@@ -1,7 +1,7 @@
 // Formatters for `--dry-run` (human / JSON) and `--graph` (DOT).
 
 import type { CacheStatus, RunPlan } from '../orchestrator/index.js'
-import { formatDuration } from '../orchestrator/index.js'
+import { formatElapsed } from '../util/index.js'
 
 /**
  * Human-readable preview. One line per real task (groups hidden, same
@@ -37,7 +37,7 @@ export function formatPlanText(plan: RunPlan): string {
     const desc = skipped ? 'noop — would not run' : describe(t.cacheStatus)
     const shortHash = t.hash ? t.hash.slice(0, 8) : ''
     const executes = !skipped && (t.cacheStatus === 'miss' || t.cacheStatus === 'no-cache')
-    const eta = executes && t.p50Ms !== undefined ? `  ~${formatDuration(t.p50Ms)}` : ''
+    const eta = executes && t.p50Ms !== undefined ? `  ~${formatElapsed(t.p50Ms)}` : ''
     // Placement, by EXECUTOR NAME rather than a local/remote word: the
     // summary line below already spends "local" and "remote" on the cache
     // tier, and a task placed on a named executor is what the reader can
@@ -94,8 +94,8 @@ export function formatPlanText(plan: RunPlan): string {
   const p = plan.predicted
   const executes = miss + nocache
   if (p !== undefined && executes > 0 && executes > p.unknownCount) {
-    const parts = [`predicted: ~${formatDuration(p.wallMs)} wall`]
-    parts.push(`~${formatDuration(p.workMs)} total execution`)
+    const parts = [`predicted: ~${formatElapsed(p.wallMs)} wall`]
+    parts.push(`~${formatElapsed(p.workMs)} total execution`)
     if (p.unknownCount > 0) {
       parts.push(`${p.unknownCount} task${p.unknownCount === 1 ? '' : 's'} without history (+?)`)
     }

package/src/cli/run.ts

@@ -1,6 +1,7 @@
 import { appendFileSync, mkdirSync } from 'node:fs'
 import path from 'node:path'
 import { isatty } from 'node:tty'
+import { findWorkspaceRoot } from '../workspace/index.js'
 import { translateForeign } from './foreign-flags.js'
 import { flagHint, seeHelp } from './help.js'
 import {
@@ -12,8 +13,13 @@ import {
   type RunOptions,
   type RunResult,
 } from '../orchestrator/index.js'
-import type { ContinueMode } from '../graph/index.js'
-import { type CachePolicy, FULL_CACHE_POLICY, parseCachePolicy } from '../cache/index.js'
+import type { ContinueMode, TaskOutcome } from '../graph/index.js'
+import {
+  type CachePolicy,
+  FULL_CACHE_POLICY,
+  gitRefusal,
+  parseCachePolicy,
+} from '../cache/index.js'
 import { affectedFilterFor, findCwdSelection, pickTask, resolveFilters } from './select.js'
 import { nxTargetHint, taskNamesHere } from './task-verb.js'
 import { MAX_TIMEOUT_MS, parseDecimalInt, machineParallelism } from '../util/index.js'
@@ -175,7 +181,7 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
       if (n === null)
         return {
           ...out,
-          error: `invalid concurrency: ${v} (a positive integer, or a share of the cores such as 50%)`,
+          error: `--concurrency must be a positive integer, or a share of the cores such as 50% (got ${v})`,
         }
       out.concurrency = n
     } else if (a === '--all') {
@@ -261,14 +267,17 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
       out.download = v
     } else if (a === '--cache-dir' || a?.startsWith('--cache-dir=')) {
       const v = a === '--cache-dir' ? before[++i] : a.slice('--cache-dir='.length)
-      if (v === undefined || v === '') return { ...out, error: `--cache-dir requires a value` }
+      if (v === undefined || v === '') return { ...out, error: `--cache-dir requires a path` }
       // Unlike every other value flag, a cache dir is an arbitrary
       // string — nothing about its shape rejects a swallowed flag. An
       // unquoted empty shell var (`--cache-dir $EMPTY --force`) would
       // otherwise create a directory literally named `--force` and drop
       // the flag. A path starting with `-` needs the `=` form.
       if (a === '--cache-dir' && v.startsWith('-')) {
-        return { ...out, error: `--cache-dir requires a path, got flag: ${v}` }
+        return {
+          ...out,
+          error: `--cache-dir requires a path (got flag ${v}; a path that starts with - needs --cache-dir=${v})`,
+        }
       }
       out.cacheDir = v
     } else if (a === '--cache' || a?.startsWith('--cache=')) {
@@ -323,14 +332,15 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
       if (v === undefined)
         return { ...out, error: `--verbosity requires a value (a non-negative integer)` }
       const n = parseDecimalInt(v)
-      if (n === null) return { ...out, error: `invalid verbosity: ${v} (a non-negative integer)` }
+      if (n === null)
+        return { ...out, error: `--verbosity must be a non-negative integer (got ${v})` }
       out.verbosity = n
     } else if (a === '--dry') {
       out.dry = 'text'
     } else if (a?.startsWith('--dry=')) {
       const fmt = a.slice('--dry='.length)
       if (fmt !== 'text' && fmt !== 'json') {
-        return { ...out, error: `invalid --dry value: ${fmt} (text or json)` }
+        return { ...out, error: `--dry must be text or json (got ${fmt})` }
       }
       out.dry = fmt
     } else if (a === '--graph') {
@@ -358,7 +368,7 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
       if (raw === undefined) return { ...out, error: `${a} requires a value (k=v)` }
       // Split on the FIRST `=` so values may contain `=` (e.g. a URL).
       const eq = raw.indexOf('=')
-      if (eq <= 0) return { ...out, error: `invalid --tag (expected k=v): ${raw}` }
+      if (eq <= 0) return { ...out, error: `--tag must be k=v (got ${raw})` }
       out.tags[raw.slice(0, eq)] = raw.slice(eq + 1)
     } else if (a === '--report-file' || a?.startsWith('--report-file=')) {
       const v = a === '--report-file' ? before[++i] : a.slice('--report-file='.length)
@@ -367,7 +377,10 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
       // nothing about its shape rejects a swallowed flag. A path starting
       // with `-` needs the `=` form.
       if (a === '--report-file' && v.startsWith('-')) {
-        return { ...out, error: `--report-file requires a path, got flag: ${v}` }
+        return {
+          ...out,
+          error: `--report-file requires a path (got flag ${v}; a path that starts with - needs --report-file=${v})`,
+        }
       }
       out.reportFile = v
     } else if (a === '--report') {
@@ -375,7 +388,7 @@ export function parseRunArgs(rawArgs: readonly string[], verb: 'run' | 'watch' =
     } else if (a?.startsWith('--report=')) {
       const fmt = a.slice('--report='.length)
       if (fmt !== 'markdown') {
-        return { ...out, error: `invalid --report value: ${fmt} (only markdown)` }
+        return { ...out, error: `--report must be markdown (got ${fmt})` }
       }
       out.report = fmt
     } else if (a !== undefined && a.startsWith('-')) {
@@ -486,6 +499,7 @@ export async function resolveRunOptions(
   parsed: RunArgs,
   cwd: string,
   tasks: readonly string[],
+  verb: 'run' | 'watch' = 'run',
 ): Promise<RunOptions | { error: string } | { nothingSelected: string }> {
   for (const t of tasks) {
     const idx = t.indexOf('#')
@@ -557,8 +571,7 @@ export async function resolveRunOptions(
       const nx = await nxTargetHint(tasks, cwd)
       if (nx !== null) return { error: nx }
       return {
-        error:
-          'not inside a project. Pass --all for every project, --filter <pattern> to filter, or run from within a project directory.',
+        error: `not inside a project: run from a project directory, or pass --all or --filter <pattern>${seeHelp(verb)}`,
       }
     }
     projects = [cwdProject.name]
@@ -620,6 +633,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
 
   const cwd = process.cwd()
   let tasks = [...parsed.tasks]
+  let picked: string | undefined
 
   // No positionals → interactive picker (TTY only). Yields a single
   // anchored pkg#task; the rest of the pipeline treats it like any
@@ -638,6 +652,12 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       )
       return 1
     }
+    // Every run needs git: refused here, not after the user has chosen.
+    const refusal = gitRefusal(await findWorkspaceRoot(cwd))
+    if (refusal !== undefined) {
+      process.stderr.write(`${refusal.message}\n`)
+      return 1
+    }
     const load = {
       ...(parsed.cacheDir !== undefined ? { cacheDir: parsed.cacheDir } : {}),
       ...(parsed.frozen ? { frozen: true } : {}),
@@ -662,10 +682,11 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       }
       only = new Set(selected.names)
     }
-    const picked = await pickTask(cwd, {}, load, only)
-    if (picked === 'interrupted') return 130
-    if (!picked) return 1
-    tasks = [`${picked.project}#${picked.task}`]
+    const chosen = await pickTask(cwd, {}, load, only)
+    if (chosen === 'interrupted') return 130
+    if (!chosen) return 1
+    picked = `${chosen.project}#${chosen.task}`
+    tasks = [picked]
   }
 
   const resolved = await resolveRunOptions(parsed, cwd, tasks)
@@ -680,8 +701,14 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   const opts = resolved
   // The raw invocation, recorded on the `invocations` row so dashboards
   // show what was actually run. `args` is everything after `run`, quoted
-  // so `vx last` replays one paste-able line.
-  opts.command = ['vx', 'run', ...args.map(shellQuote)].join(' ')
+  // so `vx last` replays one paste-able line; a picked task is named in
+  // it, or the line would open the picker again.
+  opts.command = [
+    'vx',
+    'run',
+    ...(picked !== undefined ? [shellQuote(picked)] : []),
+    ...args.map(shellQuote),
+  ].join(' ')
 
   // Planning paths short-circuit execution. Both build the full task
   // graph + probe the cache; the difference is just the formatter.
@@ -726,6 +753,25 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     return 0
   }
 
+  // The report prints above the footer: nothing prints below it (owner).
+  // Rendered once, however many sinks asked for it; a kept server's crash
+  // after the footer re-renders the file's copy (C-53).
+  const wantsReport = parsed.report === 'markdown' || parsed.reportFile !== undefined
+  let reported: { outcomes: readonly TaskOutcome[]; md: string } | undefined
+  if (wantsReport) {
+    opts.beforeFooter = (outcomes, ok) => {
+      reported = {
+        outcomes,
+        md: formatRunReportMarkdown({ ok, outcomes: outcomes.map(projectOutcome) }),
+      }
+      // `--report` writes stdout. The report ITSELF is machine-clean, but
+      // stdout is not vx's alone — the status logger writes there too, so
+      // `--report=markdown >> "$GITHUB_STEP_SUMMARY"` captures every frame,
+      // meter bar and `::group::` command above the table. `--report-file`
+      // is the redirect-free form.
+      return parsed.report === 'markdown' ? reported.md : ''
+    }
+  }
   // A run executes in THIS process, always. Where an individual task's
   // command runs is the `executor` capability's business (per task, with
   // the scheduler, cache, retries and telemetry unchanged above it); there
@@ -735,17 +781,14 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     process.stderr.write(`vx run: ${summary.refused}\n`)
     return 1
   }
-  const result: RunResult = { ok: summary.ok, outcomes: summary.outcomes.map(projectOutcome) }
-  // Report generation is post-run, gated on the flags — zero cost when
-  // both are absent. Rendered once, however many sinks asked for it.
-  if (parsed.report === 'markdown' || parsed.reportFile !== undefined) {
-    const md = formatRunReportMarkdown(result)
-    // `--report` writes stdout. The report ITSELF is machine-clean, but
-    // stdout is not vx's alone — the status logger writes there too, so
-    // `--report=markdown >> "$GITHUB_STEP_SUMMARY"` captures every frame,
-    // meter bar and `::group::` command above the table. `--report-file`
-    // is the redirect-free form.
-    if (parsed.report === 'markdown') process.stdout.write(md)
+  if (wantsReport) {
+    const md =
+      reported?.outcomes === summary.outcomes
+        ? reported.md
+        : formatRunReportMarkdown({
+            ok: summary.ok,
+            outcomes: summary.outcomes.map(projectOutcome),
+          })
     if (parsed.reportFile !== undefined) {
       const target = path.resolve(cwd, parsed.reportFile)
       try {
@@ -768,5 +811,5 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       }
     }
   }
-  return result.ok ? 0 : 1
+  return summary.ok ? 0 : 1
 }

package/src/cli/select.ts

@@ -26,7 +26,7 @@ import {
 import type { ProjectConfig } from '../config.js'
 import type { ProjectEntry } from '../workspace/index.js'
 import { parseDependencySpec } from '../graph/index.js'
-import { declaresInput } from '../cache/index.js'
+import { declaresInput, workspaceFilesReachInto } from '../cache/index.js'
 import { isUserError, listed, maskedLine, nearest, UserError } from '../util/index.js'
 import {
   claimedAffected,
@@ -60,12 +60,15 @@ export async function workspaceGlobOwners(
   load: CliLoadOptions = {},
   stagedLoad: () => Promise<ReadonlyMap<string, ProjectEntry>> = () =>
     loadCliProjects(root, projects, 'all', load),
+  /** The changed nested repositories (`AffectedChanges.nested`). */
+  nested: readonly string[] = [],
 ): Promise<string[]> {
   const declaresMatch = (config: ProjectConfig): boolean => {
     for (const task of Object.values(config.tasks ?? {})) {
       const cache = task.cache
       if (cache === undefined) continue
       if (changed.some((rel) => declaresInput(cache, null, rel))) return true
+      if (nested.some((dir) => workspaceFilesReachInto(cache, dir))) return true
     }
     return false
   }
@@ -319,8 +322,8 @@ export async function resolveFilters(
         workspaceRoot: root,
         since: f.gitSince,
         projects,
-        workspaceGlobOwners: (changed: readonly string[]) =>
-          workspaceGlobOwners(root, projects, changed, load, stagedOnce),
+        workspaceGlobOwners: (changed: readonly string[], nested: readonly string[]) =>
+          workspaceGlobOwners(root, projects, changed, load, stagedOnce, nested),
         fingerprintClaims: () => workspaceFingerprintClaims(root, projects, load),
         taskEdges: async () => edges ?? taskEdgesFrom(await stagedOnce()),
         ...(git !== undefined ? { untracked: async () => (await git.start()).untracked } : {}),

package/src/cli/show.ts

@@ -41,7 +41,12 @@ export function parseShowArgs(args: readonly string[]): ShowArgs {
     else if (a.startsWith('--format=')) format = a.slice('--format='.length)
     else if (a === '--filter') {
       const v = args[++i]
-      if (v === undefined) return { ...out, error: '--filter requires a value (a pattern)' }
+      // `--filter --format json` took `--format` as the pattern; no filter opens with `--`.
+      if (v === undefined || v === '' || v.startsWith('--'))
+        return {
+          ...out,
+          error: `--filter requires a value: a project name, glob or path${seeHelp('show')}`,
+        }
       out.filters.push(v)
     } else if (a.startsWith('--filter=')) out.filters.push(a.slice('--filter='.length))
     else if (a === '--affected') out.affected = ''
@@ -55,7 +60,8 @@ export function parseShowArgs(args: readonly string[]): ShowArgs {
       return { ...out, error: `unexpected argument: ${a}${seeHelp('show')}` }
     // An empty name is a part of every name: its "did you mean" listed the
     // whole workspace.
-    else if (a === '') return { ...out, error: 'empty target (omit it to list every project)' }
+    else if (a === '')
+      return { ...out, error: `empty target (omit it to list every project)${seeHelp('show')}` }
     else out.target = a
 
     if (format !== undefined) {

package/src/cli/upgrade.ts

@@ -200,7 +200,7 @@ export async function fetchRelease(tag: string | undefined): Promise<unknown> {
   }
   // A body that is not JSON (a captive portal's page, a proxy's error
   // page served with a 200) is the same refusal as a cut one.
-  return await readOrRefuse(() => res.json() as Promise<unknown>, url, 'read the release')
+  return await readOrRefuse(() => res.json(), url, 'read the release')
 }
 
 /**

package/src/cli/watch-filter.ts

@@ -179,9 +179,14 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
   // ignored let a pid file in the same window start cycles again. The
   // refused path is skipped and the rest asked again; a refusal before
   // any record outside a work tree is git refusing them all.
-  let rest = paths
+  // Git refuses a path beyond a symbolic link: its ignored pid file read
+  // as an edit and an uncached task re-ran forever. Asked at its real
+  // place, answered as given.
+  const real = paths.map(gitSpeller(workspaceRoot))
+  let from = 0
   let inWorkTree: boolean | undefined
-  while (rest.length > 0) {
+  while (from < paths.length) {
+    const rest = real.slice(from)
     let proc: ReturnType<typeof Bun.spawnSync>
     try {
       proc = Bun.spawnSync({
@@ -201,8 +206,8 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
     const fields = new TextDecoder('utf-8', { ignoreBOM: true }).decode(proc.stdout).split('\0')
     const records = Math.floor(fields.length / 4)
     for (let i = 0; i < records; i++) {
-      const [source, , pattern, p] = fields.slice(i * 4, i * 4 + 4)
-      if (source !== '' && !pattern!.startsWith('!')) ignored.add(p!)
+      const [source, , pattern] = fields.slice(i * 4, i * 4 + 4)
+      if (source !== '' && !pattern!.startsWith('!')) ignored.add(paths[from + i]!)
     }
     // 0: some ignored; 1: none. Anything else is git refusing.
     if (proc.exitCode === 0 || proc.exitCode === 1) return ignored
@@ -216,7 +221,7 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
         }).exitCode === 0
       if (!inWorkTree) return ignored
     }
-    rest = rest.slice(records + 1)
+    from += records + 1
   }
   return ignored
 }
@@ -351,19 +356,59 @@ export function isWorkspaceConfigFile(name: string): boolean {
  */
 const FINGERPRINT_FILES: ReadonlySet<string> = new Set(WORKSPACE_FINGERPRINT_FILES)
 
+/**
+ * Paths as git spells them under `root`: a project reached through a
+ * symlink below the root (`packages/x -> ../shared/x`) is watched at the
+ * link, and git names and answers for its files only at the real place.
+ * The root keeps its own spelling (macOS's `/var` is `/private/var`), the
+ * name its own (the file may be gone); a directory outside the root is
+ * kept as given. Directories are resolved once per speller.
+ */
+export function gitSpeller(root: string): (p: string) => string {
+  const dirs = new Map<string, string>()
+  let realRoot: string | undefined
+  return (p) => {
+    const dir = path.dirname(p)
+    let at = dirs.get(dir)
+    if (at === undefined) {
+      at = dir
+      try {
+        realRoot ??= realPath(root)
+        const rel = path.relative(realRoot, realPath(dir))
+        if (rel !== '..' && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel)) {
+          at = path.join(root, rel)
+        }
+      } catch {}
+      dirs.set(dir, at)
+    }
+    return path.join(at, path.basename(p))
+  }
+}
+
 /**
  * The files under the workspace git lists, tracked and untracked, ignored
  * ones aside, and every directory above one (git lists no directory, and
  * a project moved away whole is one event on its directory): what existed
  * when watch armed, so a path born and gone since is told from a deletion
- * (watch-judge.ts). Undefined when git cannot answer: no inventory, every
- * gone path is a deletion as before.
+ * (watch-judge.ts). `tracked` is the files git tracks: a user edits those,
+ * so a server cannot be blamed for one. Undefined when git cannot answer:
+ * no inventory, every gone path is a deletion as before.
  */
-export function gitFiles(workspaceRoot: string): Set<string> | undefined {
+export function gitFiles(
+  workspaceRoot: string,
+): { listed: Set<string>; tracked: Set<string> } | undefined {
   let proc: ReturnType<typeof Bun.spawnSync>
   try {
     proc = Bun.spawnSync({
-      cmd: [executablePath('git'), 'ls-files', '-z', '--cached', '--others', '--exclude-standard'],
+      cmd: [
+        executablePath('git'),
+        'ls-files',
+        '-z',
+        '-t',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+      ],
       cwd: workspaceRoot,
       stdout: 'pipe',
       stderr: 'ignore',
@@ -373,13 +418,19 @@ export function gitFiles(workspaceRoot: string): Set<string> | undefined {
   }
   if (proc.exitCode !== 0) return undefined
   const files = new Set<string>()
-  for (const p of new TextDecoder('utf-8', { ignoreBOM: true }).decode(proc.stdout).split('\0')) {
-    if (p.length === 0) continue
+  const tracked = new Set<string>()
+  for (const entry of new TextDecoder('utf-8', { ignoreBOM: true })
+    .decode(proc.stdout)
+    .split('\0')) {
+    if (entry.length === 0) continue
+    // `-t` prefixes a tag and a space; `?` is untracked.
+    const p = entry.slice(2)
     // An untracked nested repository is listed as `dir/`.
     let abs = path.join(workspaceRoot, p.endsWith('/') ? p.slice(0, -1) : p)
     files.add(abs)
+    if (entry[0] !== '?') tracked.add(abs)
     for (abs = path.dirname(abs); abs !== workspaceRoot && !files.has(abs); abs = path.dirname(abs))
       files.add(abs)
   }
-  return files
+  return { listed: files, tracked }
 }

package/src/cli/watch-fs.ts

@@ -349,7 +349,9 @@ export function modifiedBefore(abs: string, t: number): boolean {
     // carry a file's OLD mtime onto the new one, and judged by mtime alone
     // such an edit was "before the arm" and never ran (item 945). No
     // process can set a ctime, and a rename or a write moves it.
-    const st = fs.statSync(abs)
+    // The link's own times, not its target's: a link made after the arm
+    // to an old file is a new input, and followed it read as the target's.
+    const st = fs.lstatSync(abs)
     return Math.max(st.mtimeMs, st.ctimeMs) < t
   } catch {
     return false
@@ -398,6 +400,10 @@ export class WatcherPool {
   // network mount, a container bind — the attempt costs a denied syscall
   // and a two-second wait before the fallback takes over anyway.
   private readonly forcePoll = (process.env['VX_WATCH_POLL'] ?? '') !== ''
+  // The stop closes the pool while a cycle may still be re-arming: an arm
+  // after it, or a proof that fails because it closed the watcher, would
+  // leave a live watcher or poller nothing ever closes.
+  private closed = false
 
   constructor(private readonly skip: (dir: string, rel: string) => boolean) {
     if (this.forcePoll)
@@ -411,6 +417,7 @@ export class WatcherPool {
   // By slot, not by handle: an OS watcher that never proves delivery is
   // swapped for a poller in place, and a drop must close what is there.
   arm(dir: string, recursive: boolean, onEvent: (filename: string) => void): WatchHandle {
+    if (this.closed) return CLOSED
     const watchers = this.watchers
     const at = watchers.length
     const handle: WatchHandle = {
@@ -442,8 +449,8 @@ export class WatcherPool {
       armed.ready.then((ok) => {
         if (ok) return
         armed.watcher.close()
-        // Dropped by a rearm before its proof settled: nothing to swap in.
-        if (watchers[at] !== armed.watcher) return
+        // Dropped by a rearm or the stop before its proof settled: nothing to swap in.
+        if (this.closed || watchers[at] !== armed.watcher) return
         // The watcher never proved delivery, so it is not one: an FSEvents
         // stream the OS refused, a filesystem that reports nothing. Swap in
         // the poller rather than run a loop that silently never fires.
@@ -462,6 +469,7 @@ export class WatcherPool {
   }
 
   closeAll(): void {
+    this.closed = true
     for (const w of this.watchers) {
       try {
         w.close()

package/src/cli/watch-judge.ts

@@ -5,7 +5,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { xxh3 } from '../util/index.js'
-import { gitIgnored } from './watch-filter.js'
+import { gitIgnored, gitSpeller } from './watch-filter.js'
 import { modifiedBefore } from './watch-fs.js'
 
 const ABSENT = -1n
@@ -63,6 +63,8 @@ export interface JudgeContext {
   fenced?(ownDir: string, abs: string): boolean
   /** The files git listed at the arm; absent when git could not answer. */
   existedAtArm?: ReadonlySet<string>
+  /** The files git tracked at the arm; absent when git could not answer. */
+  trackedAtArm?: ReadonlySet<string>
 }
 
 export class ChangeJudge {
@@ -124,14 +126,14 @@ export class ChangeJudge {
   // the moment between a judgement and that cycle's keys, and gone by the
   // next judgement, was read and its deletion re-runs nothing. Git lists
   // no ignored path, so one of those is a deletion as before.
-  private sameState(abs: string, ignored = false): boolean {
+  private sameState(abs: string, ignored: boolean, spell: (p: string) => string): boolean {
     const state = settledState(abs)
     const prev = this.lastState.get(abs)
     this.lastState.set(abs, state)
     if (prev !== undefined) return prev === state
     if (state === ABSENT) {
       const listed = this.ctx.existedAtArm
-      return !ignored && listed !== undefined && !listed.has(abs) && !this.inNestedRepo(abs)
+      return !ignored && listed !== undefined && !listed.has(spell(abs)) && !this.inNestedRepo(abs)
     }
     return modifiedBefore(abs, this.ctx.armedAt)
   }
@@ -146,13 +148,17 @@ export class ChangeJudge {
     return false
   }
 
-  private writtenDuringLastCycle(abs: string, openWhileHeld = false): boolean {
+  /** `spell` (git's spelling, see `gitSpeller`) given: a held server's write counts outside a cycle too. */
+  private writtenDuringLastCycle(abs: string, spell?: (p: string) => string): boolean {
     // A server the last cycle left running is still that cycle's: its
     // writes land after the cycle ended, and with a closed window a dev
     // server that rewrites a log in its project restarted itself forever
     // with no word of it, 12 restarts in 8 s (item 948). The initial run's
-    // server is one too, from the arm on.
-    const open = openWhileHeld && this.ctx.held()
+    // server is one too, from the arm on. Not a tracked file: that is the
+    // user's edit, and three saves of one source file were told to
+    // .gitignore it as a server's write (WD-7).
+    const open =
+      spell !== undefined && this.ctx.held() && this.ctx.trackedAtArm?.has(spell(abs)) !== true
     if (this.lastCycle === undefined && !open) return false
     try {
       const m = fs.statSync(abs).mtimeMs
@@ -165,6 +171,7 @@ export class ChangeJudge {
 
   judge(): string | undefined {
     const ignored = gitIgnored(this.ctx.workspaceRoot, [...this.pending.keys()])
+    const spell = gitSpeller(this.ctx.workspaceRoot)
     let first: string | undefined
     let firstAbs: string | undefined
     // `sameState` before the `first` test, never after it: it is what
@@ -190,7 +197,7 @@ export class ChangeJudge {
     let gone: [label: string, abs: string] | undefined
     for (const [p, l] of this.pending) {
       if (ignored.has(p) && !editForUncached(p)) continue
-      if (this.sameState(p, ignored.has(p)) || first !== undefined) continue
+      if (this.sameState(p, ignored.has(p), spell) || first !== undefined) continue
       if (!fs.existsSync(p)) {
         gone ??= [l, p]
         continue
@@ -201,7 +208,7 @@ export class ChangeJudge {
     if (first === undefined && gone !== undefined) [first, firstAbs] = gone
     this.pending.clear()
     const byServer = firstAbs !== undefined && this.ctx.held()
-    if (firstAbs === undefined || !this.writtenDuringLastCycle(firstAbs, true)) {
+    if (firstAbs === undefined || !this.writtenDuringLastCycle(firstAbs, spell)) {
       this.streak.n = 0
       return first
     }