@vzn/vx 0.0.650 → 0.0.652

package/src/cli/show.ts

@@ -13,17 +13,15 @@ import { isDefaultBuild } from '../graph/index.js'
 import { affectedTaskProjects } from '../orchestrator/index.js'
 import { flagHint, formatValue, refuse, seeHelp } from './help.js'
 import {
-  type ColorSupport,
-  detectColors,
   listed,
   nearMatches,
   relPosix,
   secretMask,
   type SecretMask,
   UserError,
-  sayNotice,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import { affectedFilterFor, resolveFilters } from './select.js'
 import {
   discoverCliProjects,
@@ -48,6 +46,8 @@ interface ShowArgs {
   filters: string[]
   /** `--affected[=<base>]`: `''` is the default base. */
   affected?: string
+  /** The word after a bare `--affected`, read as the target: the base meant, when nothing is named so. */
+  spacedBase?: string
   error?: string
 }
 
@@ -67,8 +67,11 @@ export function parseShowArgs(args: readonly string[]): ShowArgs {
           error: `--filter requires a value: a project name, glob or path${seeHelp('show')}`,
         }
       out.filters.push(v)
-    } else if (a === '--affected') out.affected = ''
-    else if (a.startsWith('--affected=')) out.affected = a.slice('--affected='.length)
+    } else if (a === '--affected') {
+      out.affected = ''
+      const next = args[i + 1]
+      if (next !== undefined && !next.startsWith('-')) out.spacedBase ??= next
+    } else if (a.startsWith('--affected=')) out.affected = a.slice('--affected='.length)
     else if (a.startsWith('-'))
       return { ...out, error: `unknown flag: ${a}${flagHint('show', a)}${seeHelp('show')}` }
     else if (out.target === 'project')
@@ -188,7 +191,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
         `no projects: ${EMPTY_LOCK.charAt(0).toLowerCase()}${EMPTY_LOCK.slice(1)}`,
       )
     const shown = metas.filter((m) => inSelection(m.name))
-    process.stdout.write(renderList(root, shown, projects, parsed.format, colorsOut()))
+    emit(renderList(root, shown, projects, parsed.format))
     return 0
   }
 
@@ -206,10 +209,12 @@ export async function showCmd(args: readonly string[]): Promise<number> {
           if (declares(task)) names.add(t)
       // `nx show projects` lists them; here a bare `vx show` does.
       const nx = projectName === 'projects' ? ' (`nx show projects` is `vx show` here)' : ''
-      throw new UserError(
-        `vx show: unknown project or task: "${projectName}"${nx}${suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`,
-        'VX_E_UNKNOWN_TASK',
-      )
+      const unknown = `vx show: unknown project or task: "${projectName}"${nx}${suggest(projectName!, [...byName.keys(), ...names], '', 'projects and tasks')}`
+      const base =
+        parsed.spacedBase === projectName
+          ? `${unknown.endsWith('.') ? '' : '.'} \`--affected\` takes its base with '=': --affected=${projectName}`
+          : ''
+      throw new UserError(`${unknown}${base}`, 'VX_E_UNKNOWN_TASK')
     }
     let shown = declaring.filter((p) => inSelection(p.name))
     if (byDiff !== undefined) {
@@ -243,7 +248,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
           : `no selected project declares ${projectName} (${n} outside the selection ${n === 1 ? 'does' : 'do'})`,
       )
     }
-    process.stdout.write(renderTaskAcross(root, shown, projectName!, parsed.format, colorsOut()))
+    emit(renderTaskAcross(root, shown, projectName!, parsed.format))
     return 0
   }
 
@@ -253,9 +258,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const dir = projectDir(root, meta)
 
   if (taskName === undefined) {
-    process.stdout.write(
-      renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format, colorsOut()),
-    )
+    emit(renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format))
     return 0
   }
 
@@ -266,7 +269,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       'VX_E_UNKNOWN_TASK',
     )
   }
-  process.stdout.write(renderTask(meta.name, dir, taskName, task, parsed.format, colorsOut()))
+  emit(renderTask(meta.name, dir, taskName, task, parsed.format))
   return 0
 }
 
@@ -339,8 +342,13 @@ function shownConfig(config: ProjectConfig | null): ProjectConfig | null {
   }
 }
 
-const colorsOut = (): ColorSupport => detectColors(process.stdout)
-const PLAIN: ColorSupport = { enabled: false }
+/** What `vx show` prints: JSON a program reads, or blocks a person does. */
+type Shown = string | readonly ui.Block[]
+
+function emit(shown: Shown): void {
+  if (typeof shown === 'string') ui.data('out', shown)
+  else if (shown.length > 0) ui.print('out', ...shown)
+}
 
 /** One block of several, with no blank line between them. */
 const joined = (blocks: readonly ui.Block[]): ui.Block => ({
@@ -352,8 +360,7 @@ function renderList(
   metas: readonly ProjectMeta[],
   projects: ReadonlyMap<string, ProjectEntry>,
   format: 'pretty' | 'json',
-  colors: ColorSupport = PLAIN,
-): string {
+): Shown {
   const rows = metas.map((meta) => {
     const tasks = projects.get(meta.name)?.config.tasks ?? {}
     return {
@@ -368,7 +375,7 @@ function renderList(
   if (format === 'json') {
     return `${JSON.stringify(rows.map(({ name, dir, tags, tasks }) => ({ name, dir, tags, tasks })))}\n`
   }
-  if (rows.length === 0) return ''
+  if (rows.length === 0) return []
   const anyTags = rows.some((r) => r.tags.length > 0)
   const cells = rows.map((r) => {
     const n = r.tasks.length
@@ -385,7 +392,7 @@ function renderList(
     return [ui.id(r.name), r.dir, tasks, ...(anyTags ? [r.tags.join(', ')] : [])]
   })
   const columns = ['project', 'dir', 'tasks', ...(anyTags ? ['tags'] : [])]
-  return ui.render([ui.table(columns, cells)], colors)
+  return [ui.section('Projects', String(rows.length), ui.table(columns, cells))]
 }
 
 function renderProject(
@@ -394,8 +401,7 @@ function renderProject(
   config: ProjectConfig | null,
   hasConfigFile: boolean,
   format: 'pretty' | 'json',
-  colors: ColorSupport = PLAIN,
-): string {
+): Shown {
   if (format === 'json') {
     // Round-trip so the printed object is exactly the JSON form of the
     // resolved config (drops `undefined` fields).
@@ -414,7 +420,7 @@ function renderProject(
   const blocks = tasks.map(([taskName, task]) =>
     joined([ui.text(ui.id(`${name}#${taskName}`)), ui.fields(taskRows(task))]),
   )
-  return ui.render([ui.report(name, head), ...blocks], colors)
+  return [ui.section(name, ui.fields(head), ...blocks)]
 }
 
 function renderTask(
@@ -423,13 +429,12 @@ function renderTask(
   taskName: string,
   task: TaskConfig,
   format: 'pretty' | 'json',
-  colors: ColorSupport = PLAIN,
-): string {
+): Shown {
   if (format === 'json') {
     const obj = { name, dir, task: taskName, config: shownTask(task) }
     return `${JSON.stringify(obj)}\n`
   }
-  return ui.render([taskReport(name, dir, taskName, task)], colors)
+  return [taskReport(name, dir, taskName, task)]
 }
 
 function renderTaskAcross(
@@ -437,8 +442,7 @@ function renderTaskAcross(
   declaring: readonly ProjectEntry[],
   taskName: string,
   format: 'pretty' | 'json',
-  colors: ColorSupport,
-): string {
+): Shown {
   if (format === 'json') {
     const list = declaring.map((p) => ({
       name: p.name,
@@ -448,22 +452,14 @@ function renderTaskAcross(
     }))
     return `${JSON.stringify(list)}\n`
   }
-  if (declaring.length === 0) return ''
-  return ui.render(
-    [
-      joined(
-        declaring.map((p) =>
-          taskReport(p.name, relPosix(root, p.dir) || '.', taskName, p.config.tasks![taskName]!),
-        ),
-      ),
-    ],
-    colors,
+  return declaring.map((p) =>
+    taskReport(p.name, relPosix(root, p.dir) || '.', taskName, p.config.tasks![taskName]!),
   )
 }
 
-/** `─ app#build ───`, the project's dir, then every field the run reads. */
+/** The `app#build` panel: the project's dir, then every field the run reads. */
 function taskReport(name: string, dir: string, taskName: string, task: TaskConfig): ui.Block {
-  return ui.report(`${name}#${taskName}`, [['dir', dir], ...taskRows(task)])
+  return ui.section(`${name}#${taskName}`, ui.fields([['dir', dir], ...taskRows(task)]))
 }
 
 /** Every field the run reads, in the order the schema declares them. */
@@ -511,17 +507,14 @@ function taskRows(raw: TaskConfig): ui.FieldRow[] {
     add('inputs.tasks', list(inputs.tasks))
     add('inputs.runtime', list(inputs.runtime))
     add('inputs.workspaceRuntime', list(inputs.workspaceRuntime))
+    add('inputs.stability.strategy', inputs.stability?.strategy)
+    add('inputs.stability.severity', inputs.stability?.severity)
   }
-  const cache = task.cache
-  if (cache !== undefined) {
-    add('outputs.files', list(cache.outputs.files))
-    add('outputs.workspaceFiles', list(cache.outputs.workspaceFiles))
-    add(
-      'outputs.clean',
-      cache.outputs.clean === undefined ? undefined : cache.outputs.clean ? 'yes' : 'no',
-    )
-    add('inputStability.strategy', cache.inputStability?.strategy)
-    add('inputStability.severity', cache.inputStability?.severity)
+  const outputs = task.outputs
+  if (outputs !== undefined) {
+    add('outputs.files', list(outputs.files))
+    add('outputs.workspaceFiles', list(outputs.workspaceFiles))
+    add('outputs.clean', outputs.clean === undefined ? undefined : outputs.clean ? 'yes' : 'no')
   }
   return rows
 }

package/src/cli/task-verb.ts

@@ -84,6 +84,28 @@ export async function taskNamesHere(cwd: string): Promise<string[] | null> {
   return [...names].sort()
 }
 
+/**
+ * "no projects declare task(s): …" for the bare names no project in the
+ * workspace declares, or undefined. A diff that matched nothing judged no
+ * name, so `vx run tset --affected` exited 0 as "nothing affected"
+ * (vercel/turborepo#12268). A workspace that does not load judges none.
+ */
+export async function undeclaredTasks(
+  tasks: readonly string[],
+  cwd: string,
+): Promise<string | undefined> {
+  const projects = await workspaceProjects(cwd)
+  if (projects === null) return undefined
+  const declared = new Set<string>()
+  for (const p of projects.values())
+    for (const [t, task] of Object.entries(p.config.tasks ?? {}))
+      if (!isDefaultBuild(task)) declared.add(t)
+  const missing = tasks.filter((t) => !t.includes('#') && !declared.has(t))
+  if (missing.length === 0) return undefined
+  const near = [...new Set(missing.map((t) => nearest(t, declared)).filter((t) => t !== undefined))]
+  return `no projects declare task(s): ${missing.join(', ')}.${near.length > 0 ? ` Did you mean ${near.join(', ')}?` : ''}`
+}
+
 async function workspaceProjects(
   cwd: string,
 ): Promise<Awaited<ReturnType<typeof loadCliProjects>> | null> {

package/src/cli/upgrade.ts

@@ -22,7 +22,9 @@ import { access, chmod, chown, link, mkdtemp, rename, rm, stat } from 'node:fs/p
 import path from 'node:path'
 import { flagHint, refuse, seeHelp } from './help.js'
 import { resolveRegistry, type Registry } from './registry.js'
-import { UserError, sayNotice, ui } from '../util/index.js'
+import { UserError } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { VERSION } from '../version.js'
 

package/src/cli/watch-fs.ts

@@ -4,7 +4,7 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { ui } from '../util/index.js'
+import * as ui from '../ui/index.js'
 
 /** Directories whose changes never trigger a re-run, wherever they appear. */
 export const IGNORED_SEGMENTS = ['node_modules', '.git']
@@ -493,6 +493,11 @@ export class WatcherPool {
     return handle
   }
 
+  /** The watchers open now, each an OS watch or the poller in its slot. */
+  get open(): number {
+    return this.watchers.filter((w) => w !== CLOSED).length
+  }
+
   /** Settles once every arm so far has proved delivery or fallen back. */
   async proved(): Promise<void> {
     await Promise.all(this.proofs)

package/src/cli/watch-judge.ts

@@ -5,7 +5,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { filesBehind } from '../cache/index.js'
-import { printable, ui, xxh3 } from '../util/index.js'
+import { printable, xxh3 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import { gitIgnored, gitSpeller } from './watch-filter.js'
 import { modifiedBefore } from './watch-fs.js'
 
@@ -318,7 +319,7 @@ export class ChangeJudge {
         'warn',
         byServer
           ? `vx watch: ${first} has started 3 cycles in a row, written while a server was running — a persistent task rewrites it. Add it to .gitignore (a git-ignored path never starts a cycle); until then every write starts a cycle.\n`
-          : `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`,
+          : `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 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`,
         'out',
       )
     }

package/src/cli/watch-set.ts

@@ -132,8 +132,8 @@ export async function sweepConfigs(
   }
   const foldTasks = (dir: string, config: ProjectConfig, names: Set<string> | null): void => {
     for (const [name, task] of Object.entries(config.tasks ?? {})) {
-      add(dir, task.cache?.outputs?.files)
-      add(workspaceRoot, task.cache?.outputs?.workspaceFiles)
+      add(dir, task.outputs?.files)
+      add(workspaceRoot, task.outputs?.workspaceFiles)
       if (names !== null && !names.has(name)) continue
       if (
         task.inputs === undefined &&
@@ -147,8 +147,8 @@ export async function sweepConfigs(
         for (const rel of named.workspaceFiles) namedIgnored.add(path.join(workspaceRoot, rel))
       }
       for (const g of task.inputs?.workspaceFiles ?? []) workspaceInputs.add(g)
-      addInputs(dir, task.inputs?.files, task.cache?.outputs?.files)
-      addInputs(workspaceRoot, task.inputs?.workspaceFiles, task.cache?.outputs?.workspaceFiles)
+      addInputs(dir, task.inputs?.files, task.outputs?.files)
+      addInputs(workspaceRoot, task.inputs?.workspaceFiles, task.outputs?.workspaceFiles)
     }
   }
   const result = (staged: Map<string, ProjectEntry> | null): ConfigSweep => ({

package/src/cli/watch.ts

@@ -14,7 +14,7 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
-import { parseRunArgs, resolveRunOptions, type RunArgs } from './run.js'
+import { parseRunArgs, resolveRunOptions, type RunArgs, spacedHint } from './run.js'
 import { refuse, seeHelp } from './help.js'
 import {
   fingerprintClaims,
@@ -45,14 +45,9 @@ import {
 import { CLOSED, fsClockNow, type WatchHandle, WatcherPool } from './watch-fs.js'
 import { ChangeJudge } from './watch-judge.js'
 import { type WatchCycle, watchCycle } from './watch-cycle.js'
-import {
-  hangupIgnored,
-  maskedLine,
-  printable,
-  restartTimings,
-  sayNotice,
-  ui,
-} from '../util/index.js'
+import { hangupIgnored, maskedLine, printable, restartTimings } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import { sweepConfigs, watchedProjects } from './watch-set.js'
 import { isCacheHit } from '../graph/index.js'
 import { resolveOutputView } from '../report/index.js'
@@ -72,7 +67,7 @@ function sayAllCached(opts: RunOptions, outcomes: readonly { status: string }[])
   const mode = resolveOutputView(opts).mode
   if (mode !== 'broad' && mode !== 'errors-only' && mode !== 'none') return
   const n = outcomes.length
-  process.stdout.write(` ${n === 1 ? '1 task' : `${n} tasks`} cached, nothing ran\n`)
+  ui.print('out', ui.line(' ', n === 1 ? '1 task' : `${n} tasks`, ' cached, nothing ran'))
 }
 
 /** Wait this long after the last filesystem event before re-running. */
@@ -129,7 +124,8 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   const cwd = process.cwd()
   const resolved = await resolveRunOptions(parsed, cwd, parsed.tasks, 'watch')
   if ('error' in resolved) {
-    sayNotice('error', 'vx watch', resolved.error)
+    const hint = resolved.code === 'VX_E_UNKNOWN_TASK' ? await spacedHint(parsed, cwd) : ''
+    sayNotice('error', 'vx watch', `${resolved.error}${hint}`)
     return 1
   }
   if ('nothingSelected' in resolved) {
@@ -166,7 +162,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   // landed, the aborted cycle's summary printed below it.
   const stopped = (): number => {
     if (stop.signal.reason === 'SIGINT') {
-      process.stdout.write('\n')
+      ui.print('out', ui.gap())
       ui.say('info', 'vx watch: stopped', 'out')
     }
     return 0
@@ -249,8 +245,13 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   // not (item 1017).
   let refusedToStart = false
   initial.held = runOrchestrator(initial.cycle.opts).then(
-    (run) => {
-      if (run.refused !== undefined) sayNotice('error', 'vx watch', run.refused)
+    async (run) => {
+      if (run.refused !== undefined) {
+        const hint = run.refused.startsWith('no projects declare')
+          ? await spacedHint(parsed, cwd)
+          : ''
+        sayNotice('error', 'vx watch', `${run.refused}${hint}`)
+      }
       sayAllCached(opts, run.outcomes)
       // A run that failed having run nothing refused to start: a requested
       // name no project declares (run() says which, with a "did you mean").
@@ -538,7 +539,8 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   const runCycle = async (first: string | undefined, initial?: InitialCycle): Promise<void> => {
     try {
       let label: string | undefined = first
-      let lockAtRun = ''
+      /** The lock this cycle's run read; none for the initial run. */
+      let lockAtRun: string | undefined
       // The initial run is collected even after a stop: its server is the
       // loop's to stop.
       while (initial !== undefined || (label !== undefined && !stop.aborted)) {
@@ -558,13 +560,14 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             // cycle ran on with no workspace config, its plugins gone and
             // its tasks named by path.
             if (!hasWorkspaceFile()) {
-              process.stdout.write(`\nchanged ${label}\n`)
+              ui.print('out', ui.gap())
+              ui.say('info', `changed ${label}`, 'out')
               throw new Error(
                 `no .vx/workspace.ts in ${workspaceRoot}; restore it, or stop vx watch`,
               )
             }
             if (reread) await rearm(false)
-            process.stdout.write('\n')
+            ui.print('out', ui.gap())
             ui.say('info', `changed ${label}`, 'out')
             if (!relocked) sayUnlocked(changes.changed)
             if (stop.aborted) break
@@ -610,13 +613,6 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             // A config's own throw or a plugin's failure may quote a secret (L-11).
             const message = maskedLine(err instanceof Error ? err.message : String(err))
             sayNotice('error', 'vx watch', `cycle failed: ${message}`)
-          } finally {
-            // A re-lock since this cycle began: the re-arm below can
-            // close the watcher its event was still on its way to (FSEvents'
-            // latency, a poller's tick), and the new lock ran nothing until
-            // the next edit (macOS CI, 2026-10-23). A cycle that read the
-            // lock mid-write failed on it, and is the same case.
-            if (lockStamp() !== lockAtRun) rootFileEvent(LOCKFILE_NAME)
           }
         // After a failed cycle too: a package added with a config that does
         // not load yet fails its cycle, and unarmed, the fix to that config
@@ -625,6 +621,15 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
           reread = false
           await rearm()
         }
+        // A re-lock since this cycle began: the re-arm can close the watcher
+        // its event was still on its way to (FSEvents' latency, a poller's
+        // tick), and the new lock ran nothing until the next edit (macOS CI,
+        // 2026-10-23). A cycle that read the lock mid-write failed on it, and
+        // is the same case. Asked after the re-arm, not when the run ends: a
+        // lock written in between was the re-arm's to read, its new pollers
+        // took it as their baseline, and it was never an event (macOS CI,
+        // 2026-11-06).
+        if (lockAtRun !== undefined && lockStamp() !== lockAtRun) rootFileEvent(LOCKFILE_NAME)
         // What landed mid-run is judged on settled state, one window
         // after the run, under the label of what actually arrived.
         current = undefined
@@ -738,6 +743,33 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     }
   }
   const stale = (dir: string): boolean => armedAs.get(dir) !== inodeOf(dir)
+  // Bun keeps ONE FSEvents stream for every `fs.watch` of a process and
+  // rebuilds it, from "now", on each watch opened or closed: what lands
+  // while it is down is lost to every watch, the proved root stream
+  // included, and a close proves nothing after it. A re-arm that swapped
+  // `apps/`'s arms lost `apps/` made again, and the edit after it, for good
+  // (macOS CI, 2026-11-04). So inside the root the one stream serves the
+  // ancestor and import arms too, and a re-arm there opens or closes none.
+  /** Whether the one stream hears `dir`'s children: under the root by its real path. */
+  const inStream = (dir: string): boolean => {
+    if (!oneStream) return false
+    const rel = path.relative(workspaceRoot, dir)
+    if (rel.startsWith('..') || path.isAbsolute(rel)) return false
+    try {
+      return fs.realpathSync(dir) === path.join(realRoot, rel)
+    } catch {
+      return false
+    }
+  }
+  /** The ancestor and import directories the one stream serves (`inStream`). */
+  let streamedAncestors = new Set<string>()
+  let streamedImports = new Set<string>()
+  const heardInStream = (filename: string): void => {
+    const abs = path.join(workspaceRoot, filename)
+    const dir = path.dirname(abs)
+    if (streamedAncestors.has(dir)) ancestorEvent(dir, path.basename(abs))
+    if (streamedImports.has(dir)) importEvent(dir, path.basename(abs))
+  }
   /** The projects the workspace-wide arm names an event by. */
   let wide: readonly ProjectMeta[] = []
   // The deepest, as a nested project's file is its own.
@@ -800,6 +832,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
    * it from the outer), so each listener decides exactly as its own arm did.
    */
   const streamEvent = (filename: string): void => {
+    heardInStream(filename)
     const rel = filename.split(path.sep).join('/')
     if (!rel.includes('/')) rootFileEvent(rel)
     else if (rel.startsWith('.vx/') && rel.indexOf('/', 4) < 0) dotVxEvent(rel.slice(4))
@@ -819,6 +852,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
           // the rest of the tree; the ignore filter then keeps node_modules
           // / .git / .vx and declared outputs out of what remains.
           arm(workspaceRoot, true, (filename) => {
+            if (oneStream) heardInStream(filename)
             if (!matters(filename) || isIgnoredPath(workspaceRoot, filename)) return
             const abs = path.join(workspaceRoot, filename)
             if (
@@ -900,6 +934,17 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
       'out',
     )
   }
+  const importEvent = (dir: string, filename: string): void => {
+    if (!(importNames.get(dir)?.has(filename) ?? false)) return
+    const abs = path.join(dir, filename)
+    const rel = path.relative(workspaceRoot, abs)
+    if (configImportFiles.includes(abs)) {
+      reread = true
+      trigger(`config import ${rel}`, abs)
+      return
+    }
+    sayStaleImport(abs)
+  }
   const armImports = (): void => {
     const inProject = (f: string): boolean => projectDirs.some((d) => f.startsWith(d + path.sep))
     const want = new Map<string, Set<string>>()
@@ -910,29 +955,20 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
       want.set(path.dirname(f), names)
     }
     importNames = want
+    streamedImports = new Set([...want.keys()].filter(inStream))
     for (const [dir, handle] of importArms) {
-      if (want.has(dir) && !stale(dir)) continue
+      if (want.has(dir) && !streamedImports.has(dir) && !stale(dir)) continue
       handle.close()
       importArms.delete(dir)
     }
     for (const dir of want.keys()) {
-      if (importArms.has(dir)) continue
+      if (importArms.has(dir) || streamedImports.has(dir)) continue
       // Gone for now: its ancestor's arm (`armAncestors`) hears it return.
       if (inodeOf(dir) === undefined) continue
       try {
         importArms.set(
           dir,
-          arm(dir, false, (filename) => {
-            if (!(importNames.get(dir)?.has(filename) ?? false)) return
-            const abs = path.join(dir, filename)
-            const rel = path.relative(workspaceRoot, abs)
-            if (configImportFiles.includes(abs)) {
-              reread = true
-              trigger(`config import ${rel}`, abs)
-              return
-            }
-            sayStaleImport(abs)
-          }),
+          arm(dir, false, (filename) => importEvent(dir, filename)),
         )
         armedAs.set(dir, inodeOf(dir) ?? '')
       } catch (err) {
@@ -1012,7 +1048,11 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   }
   const debugArms = resolveSetting('debug.watch', undefined).value === true
   const sayArmed = (count: number): void => {
-    if (debugArms) ui.say('info', `vx watch: armed ${plural(count, 'project')}`)
+    if (debugArms)
+      ui.say(
+        'info',
+        `vx watch: armed ${plural(count, 'project')} (${pool.open} watch${pool.open === 1 ? '' : 'es'})`,
+      )
   }
 
   const rearm = async (say = true): Promise<void> => {
@@ -1089,6 +1129,18 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   // never heard `packages/` removed under `packages/a` (inotify did).
   const ancestorArms = new Map<string, WatchHandle>()
   let ancestorNames = new Map<string, Set<string>>()
+  const ancestorEvent = (dir: string, filename: string): void => {
+    // A project's parent's `.gitignore` shapes what its keys read, as the root's does.
+    if (!ancestorNames.get(dir)?.has(filename) && filename !== '.gitignore') return
+    const abs = path.join(dir, filename)
+    // A project directory still the one its arm holds is no change:
+    // its arm judges what is in it. macOS reports the directory's
+    // mtime here on every write at its top level, and a cycle's own
+    // write started the next (solid's `types`, 2026-10-15).
+    if (heldDirs.get(abs) === (inodeOf(abs) ?? '')) return
+    reread = true
+    trigger(path.relative(workspaceRoot, abs), abs)
+  }
   /** Each project directory below the root as these arms first saw it (`inodeOf`). */
   let heldDirs = new Map<string, string>()
   const armAncestors = (): void => {
@@ -1119,28 +1171,18 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
         dir = path.dirname(dir)
       }
     }
+    streamedAncestors = new Set([...ancestorNames.keys()].filter(inStream))
     for (const [dir, handle] of ancestorArms) {
-      if (ancestorNames.has(dir) && !stale(dir)) continue
+      if (ancestorNames.has(dir) && !streamedAncestors.has(dir) && !stale(dir)) continue
       handle.close()
       ancestorArms.delete(dir)
     }
     for (const dir of ancestorNames.keys()) {
-      if (ancestorArms.has(dir)) continue
+      if (ancestorArms.has(dir) || streamedAncestors.has(dir)) continue
       try {
         ancestorArms.set(
           dir,
-          arm(dir, false, (filename) => {
-            // A project's parent's `.gitignore` shapes what its keys read, as the root's does.
-            if (!ancestorNames.get(dir)?.has(filename) && filename !== '.gitignore') return
-            const abs = path.join(dir, filename)
-            // A project directory still the one its arm holds is no change:
-            // its arm judges what is in it. macOS reports the directory's
-            // mtime here on every write at its top level, and a cycle's own
-            // write started the next (solid's `types`, 2026-10-15).
-            if (heldDirs.get(abs) === (inodeOf(abs) ?? '')) return
-            reread = true
-            trigger(path.relative(workspaceRoot, abs), abs)
-          }),
+          arm(dir, false, (filename) => ancestorEvent(dir, filename)),
         )
         armedAs.set(dir, inodeOf(dir) ?? '')
       } catch (err) {