@vzn/vx 0.0.636 → 0.0.638

package/src/cli/watch-cycle.ts

@@ -15,6 +15,8 @@ export interface WatchCycle {
   /** Stop the run as a SIGTERM would; watch keeps going. */
   interrupt(): void
   readonly interrupted: boolean
+  /** The run's task count, once it has started. */
+  readonly tasks: number | undefined
 }
 
 /** `onWaiting` hears each task event after which the cycle waits on readiness alone. */
@@ -23,21 +25,26 @@ export function watchCycle(opts: RunOptions, stop: AbortSignal, onWaiting: () =>
   const bus = createEventBus()
   // id → persistent; a group task has no process and holds nothing up.
   const active = new Map<string, boolean>()
+  let tasks: number | undefined
   const waitsOnReadiness = (): boolean =>
     active.size > 0 && [...active.values()].every((persistent) => persistent)
   bus.subscribe((e) => {
-    if (e.kind === 'task:start' && e.node.config.exec !== undefined)
+    if (e.kind === 'run:start') tasks = e.info.total
+    else if (e.kind === 'task:start' && e.node.config.exec !== undefined)
       active.set(e.node.id, e.node.config.exec.persistent !== undefined)
     else if (e.kind === 'task:complete') active.delete(e.node.id)
     else return
     if (waitsOnReadiness()) onWaiting()
   })
   return {
-    opts: { ...opts, bus, signal: AbortSignal.any([stop, own.signal]) },
+    opts: { ...opts, bus, footer: false, signal: AbortSignal.any([stop, own.signal]) },
     waitsOnReadiness,
     interrupt: () => own.abort('SIGTERM'),
     get interrupted() {
       return own.signal.aborted
     },
+    get tasks() {
+      return tasks
+    },
   }
 }

package/src/cli/watch-filter.ts

@@ -5,6 +5,7 @@
 import path from 'node:path'
 import {
   executablePath,
+  gitEnv,
   isLiteralPattern,
   normalizeGlob,
   outputMatcher,
@@ -13,14 +14,10 @@ import {
   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'
+import { PROJECT_CONFIG_FILENAMES, WORKSPACE_CONFIG_FILENAMES } from '../workspace/index.js'
+import { isIgnoredDir } from './watch-fs.js'
 
-const IGNORED_SUFFIXES = ['.tsbuildinfo', '~']
+const IGNORED_SUFFIXES = ['~']
 
 /**
  * True for a path the ignore filter drops. Every project dir is watched
@@ -33,16 +30,22 @@ const IGNORED_SUFFIXES = ['.tsbuildinfo', '~']
  */
 export function isIgnoredWatchPath(rel: string): boolean {
   const segments = rel.split(path.sep)
-  if (segments.some((s) => IGNORED_SEGMENTS.includes(s))) return true
+  for (let i = 1; i <= segments.length; i++) if (isIgnoredDir(segments.slice(0, i))) return true
   if (IGNORED_SUFFIXES.some((suf) => rel.endsWith(suf))) return true
-  return false
+  const name = segments[segments.length - 1]!
+  // A restore's own temporary file, never an input (`ALWAYS_IGNORE`):
+  // renamed away before the judgement, it read as a deletion and ran one
+  // more cycle where an uncached task makes ignored paths count.
+  if (name.startsWith('.vx-tmp-')) return true
+  // `vx lock`'s review copy: no input, so a re-lock is no cycle.
+  return name === 'vx.lock.json'
 }
 
 /**
  * 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
+ * `isIgnoredDir` 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
@@ -54,6 +57,8 @@ export function makeWatchIgnore(
   cacheDir: string,
   outputs: ReadonlyMap<string, readonly string[]> = new Map(),
   inputs: ReadonlyMap<string, ReadonlyArray<readonly string[]>> = new Map(),
+  /** What git tracked at the arm (`gitFiles`): never an output, so an edit there is one. */
+  tracked?: ReadonlySet<string>,
 ): (base: string, filename: string) => boolean {
   // Watchers report under the real root; a cache dir named through a link
   // (`VX_CACHE_DIR`, macOS `/var` -> `/private/var`) is matched as its target.
@@ -122,6 +127,14 @@ export function makeWatchIgnore(
     const abs = path.resolve(base, filename)
     if (abs === cacheAbs || abs.startsWith(cacheAbs + path.sep)) return true
     if (isInput(abs)) return false
+    // Core never cleans or saves a file git tracks and keys it under the
+    // task's own output glob (2026-10-14); a submodule is listed as its
+    // gitlink alone, so a path under a tracked one counts.
+    if (tracked !== undefined)
+      for (let p = abs; p.length > 1; p = path.dirname(p)) {
+        if (tracked.has(p)) return false
+        if (p === path.dirname(p)) break
+      }
     for (const [dir, isOutput, containers] of declared) {
       if (!abs.startsWith(dir + path.sep)) continue
       const rel = abs
@@ -191,6 +204,7 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
     try {
       proc = Bun.spawnSync({
         cmd: [executablePath('git'), 'check-ignore', '-v', '-n', '-z', '--stdin'],
+        env: gitEnv(),
         cwd: workspaceRoot,
         stdin: Buffer.from(rest.map((p) => `${p}\0`).join('')),
         stdout: 'pipe',
@@ -215,6 +229,7 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
       inWorkTree ??=
         Bun.spawnSync({
           cmd: [executablePath('git'), 'rev-parse', '--is-inside-work-tree'],
+          env: gitEnv(),
           cwd: workspaceRoot,
           stdout: 'ignore',
           stderr: 'ignore',
@@ -231,7 +246,7 @@ export function gitIgnored(workspaceRoot: string, paths: readonly string[]): Set
  * 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
+ * root file a plugin claims, 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
@@ -257,24 +272,10 @@ export function makeRootEventFilter(
   )
   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' ||
-        rel === '.gitignore' ||
-        claimedRootFiles.has(rel))
-    ) {
+    // Exact membership, not a basename match: `nested/pnpm-lock.yaml` and
+    // `nested/.vx/workspace.ts` are no root file. The workspace config and
+    // a claimed file carry their `.vx/` prefix.
+    if (isWorkspaceConfigFile(rel) || claimedRootFiles.has(rel) || rel === '.gitignore') {
       return true
     }
     const abs = path.resolve(workspaceRoot, filename)
@@ -305,30 +306,19 @@ export function makeFence(fenceDirs: readonly string[]): (ownDir: string, abs: s
 }
 
 /**
- * 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).
+ * A file whose edit can change what the loop watches: 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 each of these waited for a
+ * restart while the loop looked alive. The lock and a file a plugin
+ * claims re-read the set as well (the caller asks: the projects come from
+ * the lock, a lockfile plugin's `discover` names and edges from its file).
  */
 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)
+  return PROJECT_CONFIGS.has(base) || isWorkspaceConfigFile(filename.split(path.sep).join('/'))
 }
 
 /**
@@ -344,19 +334,6 @@ 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)
-
 /**
  * Paths as git spells them under `root`: a project reached through a
  * symlink below the root (`packages/x -> ../shared/x`) is watched at the
@@ -410,6 +387,7 @@ export function gitFiles(
         '--others',
         '--exclude-standard',
       ],
+      env: gitEnv(),
       cwd: workspaceRoot,
       stdout: 'pipe',
       stderr: 'ignore',

package/src/cli/watch-fs.ts

@@ -5,8 +5,19 @@
 import fs from 'node:fs'
 import path from 'node:path'
 
-/** Paths whose changes never trigger a re-run. */
-export const IGNORED_SEGMENTS = ['node_modules', '.git', '.vx']
+/** Directories whose changes never trigger a re-run, wherever they appear. */
+export const IGNORED_SEGMENTS = ['node_modules', '.git']
+
+/**
+ * True for a directory, as `/`-separated segments, the watchers skip: an
+ * `IGNORED_SEGMENTS` name, or vx's machine-local `.vx/cache`. The
+ * workspace config and the lock beside it in `.vx` are watched.
+ */
+export function isIgnoredDir(segments: readonly string[]): boolean {
+  const last = segments.length - 1
+  if (IGNORED_SEGMENTS.includes(segments[last]!)) return true
+  return segments[last] === 'cache' && segments[last - 1] === '.vx'
+}
 
 /**
  * The file `armWatcher` writes under a watched directory to prove the
@@ -41,7 +52,7 @@ const POLL_INTERVAL_MS = 250
  * `node_modules` is the difference between a cheap fallback and one that
  * re-stats 40 000 files four times a second.
  *
- * That justification is exactly `IGNORED_SEGMENTS`, so this IS that set.
+ * That justification is exactly `isIgnoredDir`, so this IS that test.
  * It used to carry a fourth name, `dist`, which the justification does NOT
  * cover: `dist` is dropped only when a project DECLARES it as an output, and
  * a project that does not declare it had its `dist/` sources silently
@@ -50,7 +61,6 @@ const POLL_INTERVAL_MS = 250
  * delivered them. Two watchers disagreeing about what an edit is (item 482).
  * The real per-project answer is the caller's `skipDir`, below.
  */
-const POLL_SKIP = new Set(IGNORED_SEGMENTS)
 
 /**
  * A watcher built from `stat`, for when the OS one cannot deliver.
@@ -75,7 +85,7 @@ export function pollWatcher(
    * what the filter would drop anyway — every declared output container, not
    * a hard-coded name. The default covers the unconditional segments alone.
    */
-  skipDir: (rel: string) => boolean = (rel) => POLL_SKIP.has(path.basename(rel)),
+  skipDir: (rel: string) => boolean = (rel) => isIgnoredDir(rel.split('/')),
 ): WatchHandle {
   let previous = new Map<string, string>()
   let first = true
@@ -275,7 +285,7 @@ function treeWatcher(root: string, listener: (filename: string) => void): WatchH
         if (name == null || typeof name !== 'string' || name === '' || name === '.') return
         const child = rel === '' ? name : `${rel}/${name}`
         listener(child)
-        if (IGNORED_SEGMENTS.includes(name)) return
+        if (isIgnoredDir(child.split('/'))) return
         let st: fs.Stats
         try {
           st = fs.statSync(path.join(abs, name))
@@ -321,7 +331,7 @@ function treeWatcher(root: string, listener: (filename: string) => void): WatchH
     for (const e of entries) {
       const child = rel === '' ? e.name : `${rel}/${e.name}`
       if (e.isDirectory()) {
-        if (!IGNORED_SEGMENTS.includes(e.name)) watchDir(child, report)
+        if (!isIgnoredDir(child.split('/'))) watchDir(child, report)
       } else if (report) listener(child)
     }
   }
@@ -389,25 +399,28 @@ export const CLOSED: WatchHandle = { close() {} }
 /**
  * Every watcher `vx watch` arms. Each OS watcher proves delivery or is
  * swapped for the poller in its slot; an OS watch limit (ENOSPC, EMFILE)
- * goes straight to the poller; `VX_WATCH_POLL=1` polls from the start.
+ * goes straight to the poller; `watch.poll` (`--poll`, `VX_WATCH_POLL`)
+ * polls from the start.
  * `skip` is what the poller leaves unsampled, asked on each walk.
  */
 export class WatcherPool {
   private readonly watchers: WatchHandle[] = []
   private readonly proofs: Promise<void>[] = []
-  // `VX_WATCH_POLL=1` skips the OS watcher entirely. Where it is known not
-  // to work — a sandbox with no `machLookup` for `com.apple.FSEvents`, a
-  // 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)
-      process.stderr.write(`vx watch: polling every ${POLL_INTERVAL_MS} ms (VX_WATCH_POLL)\n`)
+  // `forcePoll` skips the OS watcher entirely. Where it is known not to
+  // work — a sandbox with no `machLookup` for `com.apple.FSEvents`, a
+  // network mount, a container bind — the attempt costs a denied syscall
+  // and a two-second wait before the fallback takes over anyway.
+  constructor(
+    private readonly skip: (dir: string, rel: string) => boolean,
+    private readonly forcePoll = false,
+  ) {
+    if (forcePoll)
+      process.stderr.write(`vx watch: polling every ${POLL_INTERVAL_MS} ms (watch.poll)\n`)
   }
 
   private poll(dir: string, recursive: boolean, onEvent: (filename: string) => void): WatchHandle {

package/src/cli/watch-judge.ts

@@ -161,7 +161,12 @@ export class ChangeJudge {
       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
+      // The later of the two clocks: a cache hit restores an output with
+      // the mtime it was saved with, and read by mtime alone the restore
+      // was the user's edit and ran one more cycle (solid, M 2026-10-15).
+      // The restore's write moves the ctime.
+      const st = fs.statSync(abs)
+      const m = Math.max(st.mtimeMs, st.ctimeMs)
       const start = this.lastCycle?.start ?? this.ctx.armedAt
       return m >= start && (open || m <= this.lastCycle!.end)
     } catch {
@@ -195,22 +200,31 @@ export class ChangeJudge {
     // `sed -i` saving through a temporary file fires that file first, and
     // the cycle was announced by a name already renamed away.
     let gone: [label: string, abs: string] | undefined
+    // "+N more" counts the changes of the winner's kind: an edit's count
+    // leaves out the editor's temporary file renamed away.
+    let live = 0
+    let goneCount = 0
     for (const [p, l] of this.pending) {
       if (ignored.has(p) && !editForUncached(p)) continue
-      if (this.sameState(p, ignored.has(p), spell) || first !== undefined) continue
+      if (this.sameState(p, ignored.has(p), spell)) continue
       if (!fs.existsSync(p)) {
+        goneCount++
         gone ??= [l, p]
         continue
       }
+      live++
+      if (first !== undefined) continue
       first = l
       firstAbs = p
     }
     if (first === undefined && gone !== undefined) [first, firstAbs] = gone
     this.pending.clear()
+    const more = (live > 0 ? live : goneCount) - 1
+    const named = more > 0 ? `${first} (+${more} more)` : first
     const byServer = firstAbs !== undefined && this.ctx.held()
     if (firstAbs === undefined || !this.writtenDuringLastCycle(firstAbs, spell)) {
       this.streak.n = 0
-      return first
+      return named
     }
     this.streak.n = this.streak.abs === firstAbs ? this.streak.n + 1 : 1
     this.streak.abs = firstAbs
@@ -222,6 +236,6 @@ export class ChangeJudge {
           : `vx watch: ${first} has started 3 cycles in a row, written by the cycle before each — a task rewrites it every run. Declare it in cache.outputs (an output never starts a cycle) or add it to .gitignore (a git-ignored path never does); until then every run re-runs.\n`,
       )
     }
-    return first
+    return named
   }
 }

package/src/cli/watch-set.ts

@@ -3,13 +3,13 @@
 // directories a package glob can grow. Read at start and again whenever an
 // edit reshapes the set; the loop in watch.ts decides when.
 
-import fs from 'node:fs'
 import path from 'node:path'
 import type { ProjectConfig } from '../config.js'
 import {
   buildPackageGraph,
+  lockKey,
   configImports,
-  loadProjectConfig,
+  readLockfile,
   WORKSPACE_CONFIG_FILENAMES,
   type ProjectEntry,
   type ProjectMeta,
@@ -79,10 +79,9 @@ export interface ConfigSweep {
  * declared outputs, so their writes are not taken for edits. The run
  * path's load (`loadProjects`): the plugin `project` stage applies, so an
  * output a plugin gave a config-less package is ignored like a declared
- * one, and a pure config is served from its cached evaluation rather than
- * re-evaluated in a worker. A config that fails to load is out of this
+ * one. Configs come from the lock. A load that fails is out of this
  * concern's scope — the run that just happened already said so, or will —
- * and the sweep falls back to the files that do load, one by one.
+ * and the sweep falls back to the lock's entries, one by one.
  */
 export async function sweepConfigs(
   projects: readonly ProjectMeta[],
@@ -175,16 +174,18 @@ export async function sweepConfigs(
     foldAll()
     return result(staged)
   }
-  await Promise.all(
-    projects.map(async (p) => {
-      if (p.configPath === null) return
-      try {
-        fold(p.dir, await loadProjectConfig(p.configPath))
-      } catch {
-        // broken config — out of this concern's scope
-      }
-    }),
-  )
+  // The lock's entries one by one: a project it does not hold, or a
+  // hand-edited entry, is out of this concern's scope.
+  const lock = await readLockfile(workspaceRoot).catch(() => null)
+  for (const p of projects) {
+    const dir = lockKey(workspaceRoot, p.dir)
+    if (p.configPath === null || lock === null || !Object.hasOwn(lock.projects, dir)) continue
+    try {
+      fold(p.dir, lock.projects[dir]!.config)
+    } catch {
+      // malformed entry
+    }
+  }
   foldAll()
   return result(null)
 }
@@ -218,30 +219,3 @@ function reachableNames(
   }
   return [...names].some((n) => n.includes('*')) ? null : names
 }
-
-/**
- * The directory entries under a package glob's directory that can be
- * members: directories (or links) whose name is not dotted and not
- * `node_modules`, the same rule discovery applies. A watcher on that
- * directory reacts only when this set changes.
- */
-export function memberEntries(base: string): ReadonlySet<string> {
-  const out = new Set<string>()
-  let entries: fs.Dirent[]
-  try {
-    entries = fs.readdirSync(base, { withFileTypes: true })
-  } catch {
-    return out
-  }
-  for (const e of entries) {
-    if (e.name.startsWith('.') || e.name === 'node_modules') continue
-    if (e.isDirectory() || e.isSymbolicLink()) out.add(e.name)
-  }
-  return out
-}
-
-export function sameMembers(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {
-  if (a.size !== b.size) return false
-  for (const name of a) if (!b.has(name)) return false
-  return true
-}