@vzn/vx 0.0.649 → 0.0.651

package/src/cli/select.ts

@@ -37,12 +37,13 @@ import {
   nearest,
   relPosix,
   UserError,
-  sayNotice,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import {
   claimedAffected,
   claimedExtraFiles,
+  claimedDigests,
   fingerprintClaims,
   gitOfDiscovery,
   hasHook,
@@ -132,6 +133,7 @@ async function workspaceFingerprintClaims(
     files: new Set(claims.keys()),
     affected: (change) => claimedAffected(claims.get(change.file)!, change, ctx),
     extraFiles: (file, bytes) => claimedExtraFiles(claims.get(file)!, file, bytes, ctx),
+    digests: (file) => claimedDigests(claims.get(file)!, file, ctx),
   }
 }
 
@@ -705,6 +707,31 @@ function didYouMean(
   return best !== undefined ? `. Did you mean tag:${best}?` : `. Tags: ${listed(known)}`
 }
 
+/**
+ * The patterns a comma list names, or one when it is none. A comma inside
+ * a glob's braces is no list (`./packages/{a,b}`), and a braced directory
+ * list (Turbo's `{cli,docs}`) is one braced directory each: split at every
+ * comma, it hinted `--filter {cli --filter docs}`.
+ */
+function commaList(pattern: string): string[] {
+  const braced = pattern.length > 2 && pattern.startsWith('{') && pattern.endsWith('}')
+  const body = braced ? pattern.slice(1, -1) : pattern
+  const parts: string[] = []
+  let depth = 0
+  let start = 0
+  for (let i = 0; i <= body.length; i++) {
+    const c = body[i]
+    if (c === '{') depth++
+    else if (c === '}') depth--
+    else if (i === body.length || (c === ',' && depth === 0)) {
+      const part = body.slice(start, i)
+      if (part !== '') parts.push(braced ? `{${part}}` : part)
+      start = i + 1
+    }
+  }
+  return parts
+}
+
 /** `. Did you mean @acme/app?` for the first unmatched pattern within two edits of a project name. */
 function didYouMeanProject(
   unmatched: readonly string[],
@@ -725,15 +752,26 @@ function didYouMeanProject(
       return '. `//` is the workspace root, which is no project here: add a vx.config there and run `vx lock`'
     }
     // Nx's `--projects=a,b`: the edit distance hinted the first name alone.
-    const parts = pattern.split(',').filter((p) => p !== '')
+    const parts = commaList(pattern)
     if (parts.length > 1) {
       return `. A filter is one pattern: ${parts.map((p) => `--filter ${p}`).join(' ')}`
     }
+    // The pattern as typed with the name put right: `apq...` hinted `app`,
+    // and the run it was copied into dropped the dependencies.
+    const meant = (name: string): string => `. Did you mean ${pattern.replace(typed, name)}?`
+    // A task id where a project goes (`--filter app#build`): the filter
+    // takes the project, and the projects listed beside it hid why.
+    const hash = typed.indexOf('#')
+    const project = typed.slice(0, Math.max(hash, 0))
+    const owner =
+      hash <= 0 ? undefined : names.includes(project) ? project : nearest(project, names)
+    if (owner !== undefined)
+      return `. A filter names projects; did you mean ${pattern.replace(typed, owner)}?`
     const best = nearest(typed, names)
-    if (best !== undefined) return `. Did you mean ${best}?`
+    if (best !== undefined) return meant(best)
     const bare = byBare.has(typed) ? typed : nearest(typed, byBare.keys())
     const scoped = bare === undefined ? undefined : byBare.get(bare)
-    if (scoped?.length === 1) return `. Did you mean ${scoped[0]}?`
+    if (scoped?.length === 1) return meant(scoped[0]!)
   }
   return names.length === 0 ? '' : `. Projects: ${listed(names)}`
 }

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. */

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'
 

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").
@@ -558,13 +559,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
@@ -738,6 +740,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 +829,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 +849,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 +931,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 +952,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 +1045,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 +1126,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 +1168,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) {