@vzn/vx 0.0.646 → 0.0.649

package/src/cli/watch-judge.ts

@@ -5,11 +5,13 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { filesBehind } from '../cache/index.js'
-import { xxh3 } from '../util/index.js'
+import { printable, ui, xxh3 } from '../util/index.js'
 import { gitIgnored, gitSpeller } from './watch-filter.js'
 import { modifiedBefore } from './watch-fs.js'
 
 const ABSENT = -1n
+/** `settledState` of a directory with no entries. */
+const EMPTY_DIR = xxh3(Buffer.from(''))
 
 function settledState(abs: string): bigint {
   let st: fs.Stats
@@ -52,6 +54,14 @@ function settledState(abs: string): bigint {
   return xxh3(Buffer.from(entries.join('\n')))
 }
 
+function isDirectory(abs: string): boolean {
+  try {
+    return fs.statSync(abs).isDirectory()
+  } catch {
+    return false
+  }
+}
+
 /**
  * What a link points to, as change detection reads it: a file's bytes and
  * mode, a directory's files by size and times (cache/linked-inputs.ts keys
@@ -93,6 +103,8 @@ export interface JudgeContext {
   namedIgnored?(): readonly string[]
   /** Whether `abs`, under the project at `ownDir`, lies in a project nested there (`makeFence`). */
   fenced?(ownDir: string, abs: string): boolean
+  /** Whether a watch waits on `abs` itself: a project's directory, or one above it. */
+  awaited?(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. */
@@ -111,6 +123,8 @@ export class ChangeJudge {
   // are judged one window after the run ends, all together — an edit made
   // meanwhile still differs from what the loop last saw and re-runs.
   readonly pending = new Map<string, string>()
+  /** The paths the last judgement found changed. */
+  changed: readonly string[] = []
   /** The last cycle's window, its start on the mtime clock (`fsClockNow`); a write inside it is the run's own. */
   lastCycle: { start: number; end: number } | undefined
   // Declared outputs are ignored by PATH above. A task with no `cache`
@@ -172,6 +186,11 @@ export class ChangeJudge {
     const prev = this.lastState.get(abs)
     this.lastState.set(abs, state)
     if (prev !== undefined) return prev === state
+    // A new empty directory holds nothing a key reads, and the poller,
+    // sampling files, never reported one: a file made in it is the edit.
+    // One a watch waits on (a project directory made again) is a change:
+    // its cycle re-arms the project.
+    if (state === EMPTY_DIR && isDirectory(abs) && this.ctx.awaited?.(abs) !== true) return true
     if (state === ABSENT) {
       const listed = this.ctx.existedAtArm
       return !ignored && listed !== undefined && !listed.has(spell(abs)) && !this.inNestedRepo(abs)
@@ -189,6 +208,11 @@ export class ChangeJudge {
     return false
   }
 
+  /** Whether git tracked `abs` when the loop armed; false when git could not answer. */
+  trackedAtArm(abs: string): boolean {
+    return this.ctx.trackedAtArm?.has(gitSpeller(this.ctx.workspaceRoot)(abs)) === true
+  }
+
   /** `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
@@ -204,7 +228,7 @@ export class ChangeJudge {
     try {
       // 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).
+      // was the user's edit and ran one more cycle (solid, 2026-10-15).
       // The restore's write moves the ctime.
       const st = fs.statSync(abs)
       const m = Math.max(st.mtimeMs, st.ctimeMs)
@@ -220,6 +244,7 @@ export class ChangeJudge {
     const spell = gitSpeller(this.ctx.workspaceRoot)
     let first: string | undefined
     let firstAbs: string | undefined
+    let firstIsFile = false
     // `sameState` before the `first` test, never after it: it is what
     // RECORDS a path's settled state, and every path this judgement saw
     // must be recorded even though only the first change names the cycle.
@@ -248,25 +273,40 @@ export class ChangeJudge {
     // leaves out the editor's temporary file renamed away.
     let live = 0
     let goneCount = 0
+    const changed: string[] = []
     for (const [p, l] of this.pending) {
       if (ignored.has(p) && !editForUncached(p)) continue
       if (this.sameState(p, ignored.has(p), spell)) continue
+      changed.push(p)
       if (!fs.existsSync(p)) {
         goneCount++
         gone ??= [l, p]
         continue
       }
       live++
-      if (first !== undefined) continue
+      // A file names the cycle before a directory: `mkdir -p` and a write
+      // in it fire the directory first, and the cycle was named by it.
+      if (first !== undefined && (firstIsFile || isDirectory(p))) continue
       first = l
       firstAbs = p
+      firstIsFile = !isDirectory(p)
     }
     if (first === undefined && gone !== undefined) [first, firstAbs] = gone
+    // A path is anyone's bytes, and a file named `ESC ]0;…` printed raw
+    // in `changed …` retitled the terminal.
+    if (first !== undefined) first = printable(first)
     this.pending.clear()
+    this.changed = changed
     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)) {
+    // A judgement that found nothing starts no cycle, so it breaks no
+    // streak. A server's log stamped to the second rewrites the same bytes
+    // between its changes, and an event can land after the judgement that
+    // read its write; resetting on either, the storm ran on unnamed (macOS
+    // CI, 2026-10-29).
+    if (firstAbs === undefined) return named
+    const byServer = this.ctx.held()
+    if (!this.writtenDuringLastCycle(firstAbs, spell)) {
       this.streak.n = 0
       return named
     }
@@ -274,10 +314,12 @@ export class ChangeJudge {
     this.streak.abs = firstAbs
     if (this.streak.n >= 3 && !this.noticed.has(firstAbs)) {
       this.noticed.add(firstAbs)
-      process.stdout.write(
+      ui.say(
+        '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`,
+        'out',
       )
     }
     return named

package/src/cli/watch.ts

@@ -15,7 +15,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { parseRunArgs, resolveRunOptions, type RunArgs } from './run.js'
-import { seeHelp } from './help.js'
+import { refuse, seeHelp } from './help.js'
 import {
   fingerprintClaims,
   forwardedSignal,
@@ -24,10 +24,17 @@ import {
   type RunOptions,
   shellQuote,
 } from '../orchestrator/index.js'
-import { findWorkspaceRoot, LOCKFILE_NAME, NO_LOCK, type ProjectMeta } from '../workspace/index.js'
+import {
+  findWorkspaceRoot,
+  LOCKFILE_NAME,
+  NO_LOCK,
+  type ProjectMeta,
+  WORKSPACE_CONFIG_FILENAMES,
+} from '../workspace/index.js'
 import { type CliLoadOptions, discoverCliProjects, loadCliWorkspace } from './workspace-config.js'
 import { resolveSetting } from '../settings.js'
 import {
+  isProjectConfigFile,
   isWorkspaceConfigFile,
   gitFiles,
   makeFence,
@@ -38,14 +45,36 @@ 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, restartTimings, sayNotice, sayLine } from '../util/index.js'
+import {
+  hangupIgnored,
+  maskedLine,
+  printable,
+  restartTimings,
+  sayNotice,
+  ui,
+} from '../util/index.js'
 import { sweepConfigs, watchedProjects } from './watch-set.js'
+import { isCacheHit } from '../graph/index.js'
+import { resolveOutputView } from '../report/index.js'
 
 /** One line for a watcher or re-read the OS refused; the loop goes on without it. */
 function sayCannot(what: string, err: unknown): void {
   sayNotice('warn', 'vx watch', `${what}: ${err instanceof Error ? err.message : String(err)}`)
 }
 
+/**
+ * One line for a cycle every task of which was a cache hit, where hits
+ * print no row: watch prints no footer, so such a cycle said nothing, and
+ * a failure the cycle before stayed the last outcome on screen.
+ */
+function sayAllCached(opts: RunOptions, outcomes: readonly { status: string }[]): void {
+  if (outcomes.length === 0 || !outcomes.every((o) => isCacheHit(o.status))) return
+  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`)
+}
+
 /** Wait this long after the last filesystem event before re-running. */
 const DEBOUNCE_MS = 150
 /**
@@ -78,16 +107,16 @@ export function watchRefusal(parsed: RunArgs): string | null {
 
 export async function watchCmd(args: readonly string[]): Promise<number> {
   const parsed = parseRunArgs(args, 'watch')
-  if (parsed.error) {
-    sayNotice('error', 'vx watch', `${parsed.error}${seeHelp('watch')}`)
-    return 1
-  }
+  if (parsed.error) return refuse('watch', args, `${parsed.error}${seeHelp('watch')}`, 'VX_E_USAGE')
 
   const refused = watchRefusal(parsed)
-  if (refused !== null) {
-    sayLine('error', refused, 'vx watch')
-    return 1
-  }
+  if (refused !== null)
+    return refuse(
+      'watch',
+      args,
+      `${refused.replace(/^vx watch: /, '')}${seeHelp('watch')}`,
+      'VX_E_USAGE',
+    )
   if (parsed.tasks.length === 0) {
     sayNotice(
       'error',
@@ -136,7 +165,10 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   // Said once the loop is down, the last line: written as the signal
   // landed, the aborted cycle's summary printed below it.
   const stopped = (): number => {
-    if (stop.signal.reason === 'SIGINT') process.stdout.write('\nvx watch: stopped\n')
+    if (stop.signal.reason === 'SIGINT') {
+      process.stdout.write('\n')
+      ui.say('info', 'vx watch: stopped', 'out')
+    }
     return 0
   }
   process.once('SIGTERM', () => stop.abort('SIGTERM'))
@@ -158,28 +190,33 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   // No lock yet is no project yet: the first cycle fails saying so, and
   // the lock `vx lock` writes is the event that arms the set.
   let unlocked = false
-  const allProjects = await discoverCliProjects(workspaceRoot).catch((err: unknown) => {
+  // The watch's own reads say no plugin warning: each cycle's run says it.
+  const quiet = (): void => {}
+  const stageLoad: CliLoadOptions = {
+    warn: quiet,
+    ...(opts.cacheDir !== undefined ? { cacheDir: opts.cacheDir } : {}),
+  }
+  const allProjects = await discoverCliProjects(workspaceRoot, stageLoad).catch((err: unknown) => {
     if (!(err instanceof Error) || err.message !== NO_LOCK) throw err
     unlocked = true
     return []
   })
-  // `//#check` is the root project's task, under the name the run gives
-  // it (prepare.ts, D-39): taken literally, no project was in scope and
-  // the watch exited 1 after a green run.
-  const rootDir = path.resolve(workspaceRoot)
-  const rootName = allProjects.find((p) => path.resolve(p.dir) === rootDir)?.name
-  const anchored = opts.tasks
-    .filter((t) => t.includes('#'))
-    .map((t) => t.slice(0, t.indexOf('#')))
-    .map((p) => (p === '//' && rootName !== undefined ? rootName : p))
+  const anchored = opts.tasks.filter((t) => t.includes('#')).map((t) => t.slice(0, t.indexOf('#')))
   const named =
     anchored.length === opts.tasks.length
       ? new Set(anchored)
       : opts.projects === undefined
         ? undefined
         : new Set([...opts.projects, ...anchored])
+  // `//#check` is the root project's task, under the name the run gives
+  // it (prepare.ts, D-39): taken literally, no project was in scope and
+  // the watch exited 1 after a green run. Resolved per discovery: started
+  // with no lock, the root has no name until `vx lock` writes one.
+  const rootDir = path.resolve(workspaceRoot)
   const inScope = (all: readonly ProjectMeta[]): ProjectMeta[] =>
-    named === undefined ? [...all] : all.filter((p) => named.has(p.name))
+    named === undefined
+      ? [...all]
+      : all.filter((p) => named.has(p.name) || (named.has('//') && path.resolve(p.dir) === rootDir))
   const scope = inScope(allProjects)
 
   // Initial run — same code path as `vx run`.
@@ -214,6 +251,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   initial.held = runOrchestrator(initial.cycle.opts).then(
     (run) => {
       if (run.refused !== undefined) sayNotice('error', 'vx watch', run.refused)
+      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").
       // `vx run` exits 1 on it; `vx watch buidl` watched on, re-running the
@@ -259,10 +297,10 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
     delete opts.affected
     delete opts.selectedOutright
 
-    const load: CliLoadOptions = opts.cacheDir !== undefined ? { cacheDir: opts.cacheDir } : {}
+    const load = stageLoad
     const swept = await sweepConfigs(allProjects, workspaceRoot, load, opts.tasks)
     const watched = await watchedProjects(workspaceRoot, allProjects, scope, load, swept.staged)
-    const ws = await loadCliWorkspace(workspaceRoot)
+    const ws = await loadCliWorkspace(workspaceRoot, quiet)
     const claimsOf = (plugins: Parameters<typeof fingerprintClaims>[0]): Set<string> =>
       new Set([...fingerprintClaims(plugins).keys(), LOCKFILE_NAME])
     await runWatchLoop({
@@ -288,7 +326,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
       // set. The scope is the one resolved at start; a new project joins
       // it only as a dependency of it.
       rediscover: async () => {
-        const all = await discoverCliProjects(workspaceRoot)
+        const all = await discoverCliProjects(workspaceRoot, load)
         const sweep = await sweepConfigs(all, workspaceRoot, load, opts.tasks)
         const now = await watchedProjects(workspaceRoot, all, inScope(all), load, sweep.staged)
         return {
@@ -296,7 +334,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
           // A plugin the workspace config gained since claims its file from
           // the cycle that loaded it; read once, its edits started nothing
           // until a restart.
-          claimedRootFiles: claimsOf((await loadCliWorkspace(workspaceRoot)).plugins),
+          claimedRootFiles: claimsOf((await loadCliWorkspace(workspaceRoot, quiet)).plugins),
           workspaceWide: sweep.workspaceWide,
           workspaceInputs: sweep.workspaceInputs,
           outputs: sweep.outputs,
@@ -420,6 +458,8 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   /** What stopped a cycle that waited on a server's readiness; the loop runs it next. */
   let interruptedBy: string | undefined
   let interruptTimer: ReturnType<typeof setTimeout> | null = null
+  /** The server's own writes among the paths that stopped the last cycle waiting on readiness. */
+  let stoppedLast = new Set<string>()
   // Judged on settled state one window later, as an idle edit is, and only
   // if the cycle still waits on readiness alone by then.
   const interruptIfWaiting = (): void => {
@@ -431,12 +471,49 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
       if (c === undefined || c.interrupted || !c.waitsOnReadiness() || stop.aborted) return
       const label = changes.judge()
       if (label === undefined) return
+      // What a server writes in its project as it boots (a timestamped
+      // config bundle, a route tree) is an edit: it stopped the cycle, the
+      // next server wrote it again, and the loop restarted it for good,
+      // never ready. A path that stopped the last such cycle, untracked
+      // and in a waiting server's project, is that server's own write.
+      const dirs = c.serverDirs()
+      const own = changes.changed.filter(
+        (p) => !changes.trackedAtArm(p) && dirs.some((d) => p.startsWith(d + path.sep)),
+      )
+      const again = own.length === changes.changed.length && own.every((p) => stoppedLast.has(p))
+      stoppedLast = new Set(own)
+      if (again) return
       interruptedBy = label
       c.interrupt()
     }, DEBOUNCE_MS)
   }
   let windowOpened = 0
 
+  const hasWorkspaceFile = (): boolean =>
+    WORKSPACE_CONFIG_FILENAMES.some((n) => fs.existsSync(path.join(workspaceRoot, n)))
+  const lockAbs = path.join(workspaceRoot, LOCKFILE_NAME)
+  const lockStamp = (): string => {
+    try {
+      const st = fs.statSync(lockAbs)
+      return `${st.ino}:${st.size}:${st.mtimeMs}:${st.ctimeMs}`
+    } catch {
+      return ''
+    }
+  }
+  /** The lock as the last cycle found it: a config edit with no re-lock since changes no command. */
+  let lockSeen = lockStamp()
+  // Every cycle's configs are the lock's, so a config edit alone ran a cycle
+  // that printed `changed` and nothing else, read as the edit applied. A
+  // config gone is the run's own refusal to name.
+  const sayUnlocked = (paths: readonly string[]): void => {
+    for (const abs of paths)
+      if ((isProjectConfigFile(abs) || configImportFiles.includes(abs)) && fs.existsSync(abs))
+        sayNotice(
+          'warn',
+          'vx watch',
+          `${printable(path.relative(workspaceRoot, abs))} changed; runs read the lock, so run \`vx lock\` to apply it`,
+        )
+  }
   const trigger = (label: string, abs: string): void => {
     if (!changes.pending.has(abs)) changes.pending.set(abs, label)
     if (running) return interruptIfWaiting()
@@ -461,6 +538,7 @@ 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 initial run is collected even after a stop: its server is the
       // loop's to stop.
       while (initial !== undefined || (label !== undefined && !stop.aborted)) {
@@ -473,9 +551,31 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             // new package while its first cycle runs queues like any other; armed
             // only after, it fell in the gap and ran nothing (X-138). The re-read
             // after the run stays, for what the run itself changed.
+            lockAtRun = lockStamp()
+            const relocked = lockAtRun !== lockSeen
+            lockSeen = lockAtRun
+            // The file marks the root, and `vx run` refuses without it; a
+            // cycle ran on with no workspace config, its plugins gone and
+            // its tasks named by path.
+            if (!hasWorkspaceFile()) {
+              process.stdout.write(`\nchanged ${label}\n`)
+              throw new Error(
+                `no .vx/workspace.ts in ${workspaceRoot}; restore it, or stop vx watch`,
+              )
+            }
             if (reread) await rearm(false)
-            process.stdout.write(`\nchanged ${label}\n`)
+            process.stdout.write('\n')
+            ui.say('info', `changed ${label}`, 'out')
+            if (!relocked) sayUnlocked(changes.changed)
             if (stop.aborted) break
+            // A file a `.gitignore` edit stops ignoring is an input from this
+            // cycle on, and was not on the arm's inventory: its deletion read
+            // as a file born and gone since, and ran nothing.
+            if (
+              atArm !== undefined &&
+              changes.changed.some((p) => path.basename(p) === '.gitignore')
+            )
+              for (const p of gitFiles(workspaceRoot)?.listed ?? []) atArm.listed.add(p)
             restartTimings()
             // On the mtime clock, as the arm is: from `Date.now()` a write the
             // run made within a tick of it carried an earlier mtime and read as
@@ -491,6 +591,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
               interruptIfWaiting,
             )
             const cycle = await runOrchestrator(current.opts)
+            sayAllCached(opts, cycle.outcomes)
             lastTasks = current.tasks ?? lastTasks
             current = undefined
             held = cycle.persistent
@@ -509,11 +610,18 @@ 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
         // was never an event.
-        if (reread && !stop.aborted) {
+        if (reread && !stop.aborted && hasWorkspaceFile()) {
           reread = false
           await rearm()
         }
@@ -521,6 +629,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
         // after the run, under the label of what actually arrived.
         current = undefined
         if (stop.aborted) break
+        if (interruptedBy === undefined) stoppedLast = new Set()
         if (interruptedBy !== undefined) {
           label = interruptedBy
           interruptedBy = undefined
@@ -561,7 +670,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   // unconditional segments AND this run's declared output containers. Read
   // through `isIgnoredPath` rather than captured, because `rearm` replaces
   // the filter when the selection changes.
-  const pool = new WatcherPool((dir, rel) => isIgnoredPath(dir, rel), args.poll)
+  const pool = new WatcherPool((dir, rel) => isIgnoredPath(dir, rel, true), args.poll)
   const arm = (dir: string, recursive: boolean, onEvent: (filename: string) => void): WatchHandle =>
     pool.arm(dir, recursive, onEvent)
 
@@ -575,6 +684,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     uncached: () => uncached,
     namedIgnored: () => namedIgnored,
     fenced: (ownDir, abs) => fenced(ownDir, abs),
+    awaited: (abs) => ancestorNames.get(path.dirname(abs))?.has(path.basename(abs)) === true,
     ...(atArm !== undefined ? { existedAtArm: atArm.listed, trackedAtArm: atArm.tracked } : {}),
   })
   /** Per-project arms by directory, so `rearm` can add and drop them. */
@@ -651,6 +761,8 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     // too: its edit can add an output or a `workspaceFiles` input.
     if (shapesWatchedSet(filename) || configImportFiles.includes(abs) || linkChanged(abs))
       reread = true
+    // Inside a project (any repo whose root is one) no import arm hears it.
+    if (wsConfigImportFiles.includes(abs)) sayStaleImport(abs)
     trigger(`${proj.name} ${filename}`, abs)
   }
   const armProject = (proj: ProjectMeta): void => {
@@ -716,6 +828,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
               configImportFiles.includes(abs)
             )
               reread = true
+            if (wsConfigImportFiles.includes(abs)) sayStaleImport(abs)
             const owner = ownerOf(abs)
             trigger(
               owner === undefined
@@ -776,6 +889,17 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   const importArms = new Map<string, WatchHandle>()
   let importNames = new Map<string, Set<string>>()
   const staleNamed = new Map<string, number>()
+  const sayStaleImport = (abs: string): void => {
+    // One line per save, not per event: a save is often two.
+    const now = Date.now()
+    if (now - (staleNamed.get(abs) ?? 0) < 1_000) return
+    staleNamed.set(abs, now)
+    ui.say(
+      'warn',
+      `vx watch: ${printable(path.relative(workspaceRoot, abs))} changed; the workspace config imports it, and this process loaded it at start — restart vx watch to apply the edit\n`,
+      'out',
+    )
+  }
   const armImports = (): void => {
     const inProject = (f: string): boolean => projectDirs.some((d) => f.startsWith(d + path.sep))
     const want = new Map<string, Set<string>>()
@@ -807,13 +931,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
               trigger(`config import ${rel}`, abs)
               return
             }
-            // One line per save, not per event: a save is often two.
-            const now = Date.now()
-            if (now - (staleNamed.get(abs) ?? 0) < 1_000) return
-            staleNamed.set(abs, now)
-            process.stdout.write(
-              `vx watch: ${rel} changed; the workspace config imports it, and this process loaded it at start — restart vx watch to apply the edit\n`,
-            )
+            sayStaleImport(abs)
           }),
         )
         armedAs.set(dir, inodeOf(dir) ?? '')
@@ -890,11 +1008,11 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
   const plural = (n: number, noun: string): string => `${n} ${noun}${n === 1 ? '' : 's'}`
   const sayWatching = (count: number): void => {
     const tasks = lastTasks === undefined ? '' : ` · ${plural(lastTasks, 'task')}`
-    process.stdout.write(`watching ${plural(count, 'project')}${tasks}\n`)
+    ui.say('info', `watching ${plural(count, 'project')}${tasks}`, 'out')
   }
   const debugArms = resolveSetting('debug.watch', undefined).value === true
   const sayArmed = (count: number): void => {
-    if (debugArms) process.stderr.write(`vx watch: armed ${plural(count, 'project')}\n`)
+    if (debugArms) ui.say('info', `vx watch: armed ${plural(count, 'project')}`)
   }
 
   const rearm = async (say = true): Promise<void> => {
@@ -902,7 +1020,9 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     try {
       next = await args.rediscover()
     } catch (err) {
-      sayCannot(`cannot re-read the workspace`, err)
+      // No lock is the cycle's own failure to say; said here too, it was two lines.
+      if (!(err instanceof Error && err.message === NO_LOCK))
+        sayCannot(`cannot re-read the workspace`, err)
       return
     }
     projectDirs = next.projects.map((p) => p.dir)
@@ -931,7 +1051,8 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
       dropMode()
       workspaceWide = next.workspaceWide
       armMode(next.projects)
-    } else if (!workspaceWide) {
+    } else if (workspaceWide) wide = next.projects
+    else {
       streamed = oneStream ? toStream(next.projects) : []
       const inStream = new Set(streamed.map((s) => s.proj))
       const own = next.projects.filter((p) => !inStream.has(p))
@@ -1015,7 +1136,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             // 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`, M 2026-10-15).
+            // 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)