@vzn/vx 0.0.637 → 0.0.638

package/src/cli/show.ts

@@ -11,7 +11,17 @@ import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { affectedTaskProjects, isDefaultBuild } from '../orchestrator/index.js'
 import { flagHint, formatValue, refuse, seeHelp } from './help.js'
-import { listed, nearMatches, relPosix, secretMask, UserError } from '../util/index.js'
+import {
+  type ColorSupport,
+  detectColors,
+  listed,
+  nearMatches,
+  relPosix,
+  secretMask,
+  UserError,
+  sayNotice,
+  ui,
+} from '../util/index.js'
 import { affectedFilterFor, resolveFilters } from './select.js'
 import {
   discoverCliProjects,
@@ -149,7 +159,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
     }
     const r = await resolveFilters(process.cwd(), raw, {}, affected)
     if ('error' in r) throw new UserError(`vx show: ${r.error}`, r.code ?? 'VX_E_USAGE')
-    if ('empty' in r) process.stderr.write(`vx show: ${r.empty}\n`)
+    if ('empty' in r) sayNotice('info', 'vx show', r.empty)
     selected = new Set('empty' in r ? [] : r.names)
     if ('names' in r && r.affected !== undefined)
       byDiff = { changes: r.affected, outright: r.outright }
@@ -160,7 +170,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
 
   if (parsed.target === undefined) {
     const shown = metas.filter((m) => inSelection(m.name))
-    process.stdout.write(renderList(root, shown, projects, parsed.format))
+    process.stdout.write(renderList(root, shown, projects, parsed.format, colorsOut()))
     return 0
   }
 
@@ -204,7 +214,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       )
       shown = shown.filter((p) => kept.has(p.name))
     }
-    process.stdout.write(renderTaskAcross(root, shown, projectName!, parsed.format))
+    process.stdout.write(renderTaskAcross(root, shown, projectName!, parsed.format, colorsOut()))
     return 0
   }
 
@@ -215,7 +225,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
 
   if (taskName === undefined) {
     process.stdout.write(
-      renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format),
+      renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format, colorsOut()),
     )
     return 0
   }
@@ -227,7 +237,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))
+  process.stdout.write(renderTask(meta.name, dir, taskName, task, parsed.format, colorsOut()))
   return 0
 }
 
@@ -284,11 +294,20 @@ function shownConfig(config: ProjectConfig | null): ProjectConfig | null {
   }
 }
 
+const colorsOut = (): ColorSupport => detectColors(process.stdout)
+const PLAIN: ColorSupport = { enabled: false }
+
+/** One block of several, with no blank line between them. */
+const joined = (blocks: readonly ui.Block[]): ui.Block => ({
+  lines: (c) => blocks.flatMap((b) => b.lines(c)),
+})
+
 function renderList(
   root: string,
   metas: readonly ProjectMeta[],
   projects: ReadonlyMap<string, ProjectEntry>,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   const rows = metas.map((meta) => {
     const tasks = projects.get(meta.name)?.config.tasks ?? {}
@@ -309,9 +328,8 @@ function renderList(
     )}\n`
   }
   if (rows.length === 0) return ''
-  const nameW = Math.max(...rows.map((r) => r.name.length))
-  const dirW = Math.max(...rows.map((r) => r.dir.length))
-  const lines = rows.map((r) => {
+  const anyTags = rows.some((r) => r.tags.length > 0)
+  const cells = rows.map((r) => {
     const n = r.tasks.length
     const count = `${n} task${n === 1 ? '' : 's'}`
     // A package with no config file has only tasks a plugin gave it, or the
@@ -319,14 +337,14 @@ function renderList(
     const tasks = r.configured
       ? count
       : n === 0
-        ? '(no vx config)'
+        ? 'no vx config'
         : r.onlyDefault
-          ? `${count} (no vx config; default build)`
-          : `${count} (no vx config; from plugins)`
-    const tags = r.tags.length > 0 ? `  [${r.tags.join(', ')}]` : ''
-    return `${r.name.padEnd(nameW)}  ${r.dir.padEnd(dirW)}  ${tasks}${tags}`
+          ? `${count}, default build (no vx config)`
+          : `${count} from plugins (no vx config)`
+    return [ui.id(r.name), r.dir, tasks, ...(anyTags ? [r.tags.join(', ')] : [])]
   })
-  return `${lines.join('\n')}\n`
+  const columns = ['project', 'dir', 'tasks', ...(anyTags ? ['tags'] : [])]
+  return ui.render([ui.table(columns, cells)], colors)
 }
 
 function renderProject(
@@ -335,6 +353,7 @@ function renderProject(
   config: ProjectConfig | null,
   hasConfigFile: boolean,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   if (format === 'json') {
     // Round-trip so the printed object is exactly the JSON form of the
@@ -344,14 +363,17 @@ function renderProject(
   }
   const tags = config?.tags ?? []
   const tasks = Object.entries(config?.tasks ?? {})
-  const head = `${name} — ${dir}${tags.length > 0 ? `\n  tags: ${tags.join(', ')}` : ''}${
+  const head: ui.FieldRow[] = [
+    ['dir', dir],
+    ...(tags.length > 0 ? [['tags', tags.join(', ')] as const] : []),
     // A config-less package a dependant reaches has the default `build` (X-9).
-    hasConfigFile || tasks.length === 0 ? '' : '\n  (no vx config)'
-  }`
-  if (tasks.length === 0)
-    return `${head}\n  ${hasConfigFile ? '(no tasks declared)' : '(no vx config)'}\n`
-  const blocks = tasks.map(([taskName, task]) => taskBlock(taskName, task))
-  return `${head}\n\n${blocks.join('\n')}`
+    ...(hasConfigFile ? [] : [['config', 'none'] as const]),
+    ...(tasks.length === 0 && hasConfigFile ? [['tasks', 'none declared'] as const] : []),
+  ]
+  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)
 }
 
 function renderTask(
@@ -360,12 +382,13 @@ function renderTask(
   taskName: string,
   task: TaskConfig,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   if (format === 'json') {
     const obj = { name, dir, task: taskName, config: shownTask(task) }
     return `${JSON.stringify(obj)}\n`
   }
-  return `${name} — ${dir}\n\n${taskBlock(taskName, task)}`
+  return ui.render([taskReport(name, dir, taskName, task)], colors)
 }
 
 function renderTaskAcross(
@@ -373,6 +396,7 @@ function renderTaskAcross(
   declaring: readonly ProjectEntry[],
   taskName: string,
   format: 'pretty' | 'json',
+  colors: ColorSupport,
 ): string {
   if (format === 'json') {
     const list = declaring.map((p) => ({
@@ -383,18 +407,28 @@ function renderTaskAcross(
     }))
     return `${JSON.stringify(list)}\n`
   }
-  return declaring
-    .map(
-      (p) =>
-        `${p.name} — ${relPosix(root, p.dir) || '.'}\n\n${taskBlock(taskName, p.config.tasks![taskName]!)}`,
-    )
-    .join('\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,
+  )
+}
+
+/** `─ app#build ───`, 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)])
 }
 
 /** Every field the run reads, in the order the schema declares them. */
-function taskBlock(taskName: string, raw: TaskConfig): string {
+function taskRows(raw: TaskConfig): ui.FieldRow[] {
   const task = shownTask(raw)
-  const rows: [string, string][] = []
+  const rows: ui.FieldRow[] = []
   const list = (xs: readonly string[] | undefined): string | undefined =>
     xs === undefined ? undefined : xs.join(', ')
   const add = (label: string, value: string | number | boolean | undefined): void => {
@@ -437,13 +471,5 @@ function taskBlock(taskName: string, raw: TaskConfig): string {
     add('outputs.files', list(cache.outputs.files))
     add('outputs.workspaceFiles', list(cache.outputs.workspaceFiles))
   }
-  const labelW = Math.max(...rows.map(([label]) => label.length))
-  // A multi-line value (a generated `vx_script` wrapper, a heredoc)
-  // continues under its first line, not at column 0 where it reads as
-  // the next task's header.
-  const indent = `\n${' '.repeat(labelW + 4)}`
-  const body = rows.map(
-    ([label, value]) => `  ${`${label}:`.padEnd(labelW + 1)} ${value.replaceAll('\n', indent)}`,
-  )
-  return `${taskName}\n${body.join('\n')}\n`
+  return rows
 }

package/src/cli/task-verb.ts

@@ -21,7 +21,7 @@ export async function taskVerbHint(
   cwd: string,
   typo = false,
 ): Promise<string | null> {
-  if (command.includes('#')) return `\`${command}\` is a task: vx run ${command}`
+  if (command.includes('#')) return `\`${command}\` is a task (did you mean vx run ${command}?)`
   const projects = await workspaceProjects(cwd)
   if (projects === null) return null
   const tasks = new Set<string>()
@@ -40,8 +40,8 @@ export async function taskVerbHint(
         ? `vx run ${task} --all`
         : `vx run ${task}`
   return task === command
-    ? `\`${command}\` is a task here, not a command: ${run}`
-    : `unknown command: ${command}; did you mean the task \`${task}\`? ${run}`
+    ? `\`${command}\` is a task here, not a command (did you mean ${run}?)`
+    : `unknown command: ${command}, a typo of the task \`${task}\` (did you mean ${run}?)`
 }
 
 /**
@@ -54,7 +54,7 @@ export async function nxTargetHint(tasks: readonly string[], cwd: string): Promi
   if (projects === null) return null
   const specs = tasks.map((t) => nxProjectTarget(t, projects))
   if (specs.some((s) => s === undefined)) return null
-  return `\`${tasks.join(' ')}\` is Nx's project:target: vx run ${specs.join(' ')}`
+  return `\`${tasks.join(' ')}\` is Nx's project:target (did you mean vx run ${specs.join(' ')}?)`
 }
 
 /**

package/src/cli/upgrade.ts

@@ -18,7 +18,7 @@ import { createPublicKey, verify } from 'node:crypto'
 import { access, chmod, chown, link, mkdtemp, rename, rm, stat } from 'node:fs/promises'
 import path from 'node:path'
 import { flagHint, seeHelp } from './help.js'
-import { UserError } from '../util/index.js'
+import { UserError, sayNotice, ui } from '../util/index.js'
 import { VERSION } from '../version.js'
 
 const REGISTRY = 'https://registry.npmjs.org'
@@ -522,7 +522,7 @@ async function targetVersion(tag: string | undefined): Promise<string> {
 async function upgradeManaged(install: ManagedInstall, tag: string | undefined): Promise<number> {
   const version = await targetVersion(tag)
   if (version === VERSION) {
-    process.stdout.write(`vx upgrade: already at ${VERSION} — nothing to do\n`)
+    ui.print('out', ui.status('info', 'vx upgrade', `already at ${VERSION}`))
     return 0
   }
   const argv = upgradeArgv(install, version)
@@ -532,8 +532,10 @@ async function upgradeManaged(install: ManagedInstall, tag: string | undefined):
       `vx upgrade: this vx was installed by ${argv[0]}, which is not on PATH — vx does not install package managers; run it yourself: ${argv.join(' ')} (in ${install.cwd})`,
     )
   }
-  process.stdout.write(
-    `vx upgrade: ${VERSION} → ${version}: running ${argv.join(' ')} (in ${install.cwd})\n`,
+  ui.print(
+    'out',
+    ui.status('info', 'vx upgrade', `${VERSION} → ${version}`),
+    ui.text([ui.cmd(argv.join(' ')), ui.dim(` in ${install.cwd}`)]),
   )
   const proc = Bun.spawnSync({
     cmd: [bin, ...argv.slice(1)],
@@ -551,8 +553,10 @@ async function upgradeManaged(install: ManagedInstall, tag: string | undefined):
 export async function upgradeCmd(args: readonly string[]): Promise<number> {
   const unknown = args.find((a) => a.startsWith('-'))
   if (unknown !== undefined) {
-    process.stderr.write(
-      `vx upgrade: unknown flag: ${unknown}${flagHint('upgrade', unknown)}${seeHelp('upgrade')}\n`,
+    sayNotice(
+      'error',
+      'vx upgrade',
+      `unknown flag: ${unknown}${flagHint('upgrade', unknown)}${seeHelp('upgrade')}`,
     )
     return 1
   }
@@ -560,7 +564,7 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
   // the first one went in (`vx upgrade v0.0.22 v0.0.23`).
   const [tag, extra] = args
   if (extra !== undefined) {
-    process.stderr.write(`vx upgrade: unexpected argument: ${extra}${seeHelp('upgrade')}\n`)
+    sayNotice('error', 'vx upgrade', `unexpected argument: ${extra}${seeHelp('upgrade')}`)
     return 1
   }
   if (!isCompiledBinary()) {
@@ -579,7 +583,11 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
     dest,
     () =>
       releaseBinary(pkg, spec, (version) =>
-        process.stdout.write(`vx upgrade: ${VERSION} → ${version} (${dest})\n`),
+        ui.print(
+          'out',
+          ui.status('info', 'vx upgrade', `${VERSION} → ${version}`),
+          ui.text(ui.dim(dest)),
+        ),
       ),
     // The replaced binary's own version: the new build speaks for itself
     // rather than this process guessing, and one that cannot is rolled back.
@@ -588,10 +596,11 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
       return installed !== ''
     },
   )
-  process.stdout.write(
+  ui.print(
+    'out',
     replaced
-      ? `vx upgrade: installed ${installed}\n`
-      : `vx upgrade: already at ${VERSION} — nothing to do\n`,
+      ? ui.status('ok', 'vx upgrade', `installed ${installed.replace(/^vx /, '')}`)
+      : ui.status('info', 'vx upgrade', `already at ${VERSION}`),
   )
   return 0
 }

package/src/cli/watch-filter.ts

@@ -17,7 +17,7 @@ import { asTrees } from '../cache/index.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
@@ -32,8 +32,13 @@ export function isIgnoredWatchPath(rel: string): boolean {
   const segments = rel.split(path.sep)
   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
+  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 segments[segments.length - 1] === 'vx.lock.json'
+  return name === 'vx.lock.json'
 }
 
 /**

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 {

package/src/cli/watch.ts

@@ -38,12 +38,12 @@ 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 } from '../util/index.js'
+import { hangupIgnored, maskedLine, restartTimings, sayNotice, sayLine } from '../util/index.js'
 import { sweepConfigs, watchedProjects } from './watch-set.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 {
-  process.stderr.write(`vx watch: ${what}: ${err instanceof Error ? err.message : String(err)}\n`)
+  sayNotice('warn', 'vx watch', `${what}: ${err instanceof Error ? err.message : String(err)}`)
 }
 
 /** Wait this long after the last filesystem event before re-running. */
@@ -84,18 +84,20 @@ export function watchRefusal(parsed: RunArgs): string | null {
 export async function watchCmd(args: readonly string[]): Promise<number> {
   const parsed = parseRunArgs(args, 'watch')
   if (parsed.error) {
-    process.stderr.write(`vx watch: ${parsed.error}${seeHelp('watch')}\n`)
+    sayNotice('error', 'vx watch', `${parsed.error}${seeHelp('watch')}`)
     return 1
   }
 
   const refused = watchRefusal(parsed)
   if (refused !== null) {
-    process.stderr.write(`${refused}\n`)
+    sayLine('error', refused, 'vx watch')
     return 1
   }
   if (parsed.tasks.length === 0) {
-    process.stderr.write(
-      `vx watch: missing task name (vx watch <task>, e.g. vx watch build)${seeHelp('watch')}\n`,
+    sayNotice(
+      'error',
+      'vx watch',
+      `missing task name (vx watch <task>, e.g. vx watch build)${seeHelp('watch')}`,
     )
     return 1
   }
@@ -103,11 +105,11 @@ 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) {
-    process.stderr.write(`vx watch: ${resolved.error}\n`)
+    sayNotice('error', 'vx watch', resolved.error)
     return 1
   }
   if ('nothingSelected' in resolved) {
-    process.stderr.write(`vx watch: ${resolved.nothingSelected}\n`)
+    sayNotice('info', 'vx watch', resolved.nothingSelected)
     return 0
   }
   // The watch loop owns SIGINT/SIGTERM for its whole lifetime. A cycle's
@@ -216,7 +218,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   let refusedToStart = false
   initial.held = runOrchestrator(initial.cycle.opts).then(
     (run) => {
-      if (run.refused !== undefined) process.stderr.write(`vx watch: ${run.refused}\n`)
+      if (run.refused !== undefined) sayNotice('error', 'vx watch', run.refused)
       // 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
@@ -227,8 +229,10 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
       return run.persistent
     },
     (err: unknown) => {
-      process.stderr.write(
-        `vx watch: cycle failed: ${err instanceof Error ? err.message : String(err)}\n`,
+      sayNotice(
+        'error',
+        'vx watch',
+        `cycle failed: ${err instanceof Error ? err.message : String(err)}`,
       )
       return undefined
     },
@@ -247,7 +251,7 @@ export async function watchCmd(args: readonly string[]): Promise<number> {
   // run's own refusal and its "did you mean".
   if (scope.length === 0 && !unlocked) {
     await held?.stop()
-    process.stderr.write(`vx watch: no projects in scope\n`)
+    sayNotice('error', 'vx watch', 'no projects in scope')
     return 1
   }
   await armLoop(undefined, held)
@@ -491,7 +495,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             held = cycle.persistent
             // What this cycle did not take (a server whose task did not run).
             await before?.stop()
-            if (cycle.refused !== undefined) process.stderr.write(`vx watch: ${cycle.refused}\n`)
+            if (cycle.refused !== undefined) sayNotice('error', 'vx watch', cycle.refused)
             changes.lastCycle = { start, end: Date.now() }
           } catch (err) {
             // A re-run can fail catastrophically when the workspace
@@ -503,7 +507,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
             // is the canonical exit; we don't unilaterally abort here.
             // 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))
-            process.stderr.write(`vx watch: cycle failed: ${message}\n`)
+            sayNotice('error', 'vx watch', `cycle failed: ${message}`)
           }
         // 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
@@ -797,12 +801,18 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     armAncestors()
   }
 
-  // Said once the loop is armed, and again after a cycle that re-read the
-  // watched set (a member came or went, the lock or a plugin changed).
+  // Said once, when the loop first arms: a re-arm repeated it after every
+  // cycle that re-read the watched set, between task rows. `debug.watch`
+  // says each arm on stderr, for whoever needs to see the set change.
   let lastTasks: number | undefined
+  const plural = (n: number, noun: string): string => `${n} ${noun}${n === 1 ? '' : 's'}`
   const sayWatching = (count: number): void => {
-    const tasks = lastTasks === undefined ? '' : ` · ${lastTasks} task${lastTasks === 1 ? '' : 's'}`
-    process.stdout.write(`watching ${count} project${count === 1 ? '' : 's'}${tasks}\n`)
+    const tasks = lastTasks === undefined ? '' : ` · ${plural(lastTasks, 'task')}`
+    process.stdout.write(`watching ${plural(count, 'project')}${tasks}\n`)
+  }
+  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`)
   }
 
   const rearm = async (say = true): Promise<void> => {
@@ -854,7 +864,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
     // A new arm proves delivery like the first ones: an edit in the new
     // project right after this cycle is seen, not lost in the gap.
     await pool.proved()
-    if (say) sayWatching(next.projects.length)
+    if (say) sayArmed(next.projects.length)
   }
 
   armMode(projects)
@@ -872,10 +882,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>>()
+  /** Each project directory below the root as these arms first saw it (`inodeOf`). */
+  let heldDirs = new Map<string, string>()
   const armAncestors = (): void => {
     ancestorNames = new Map()
     const rootDir = path.resolve(workspaceRoot)
     const below = projectDirs.filter((d) => path.resolve(d) !== rootDir)
+    heldDirs = new Map(
+      below.flatMap((d) => {
+        const id = inodeOf(d)
+        return id === undefined ? [] : [[d, id]]
+      }),
+    )
     for (const base of [...below, ...importNames.keys()]) {
       let dir = path.dirname(base)
       let name = path.basename(base)
@@ -907,8 +925,13 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
           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
-            reread = true
             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`, M 2026-10-15).
+            if (heldDirs.get(abs) === (inodeOf(abs) ?? '')) return
+            reread = true
             trigger(path.relative(workspaceRoot, abs), abs)
           }),
         )
@@ -937,6 +960,7 @@ async function runWatchLoop(args: WatchLoopArgs): Promise<void> {
 
   lastTasks = args.tasks()
   sayWatching(projects.length)
+  sayArmed(projects.length)
 
   return await new Promise<void>((resolve) => {
     const cleanup = async (): Promise<void> => {

package/src/cli/why.ts

@@ -16,7 +16,7 @@ import {
   whyDidThisRerunQuery as whyDidThisRerun,
   resolveRunId,
 } from '../orchestrator/index.js'
-import { MASKED, nearMatches, printable, UserError } from '../util/index.js'
+import { MASKED, nearMatches, printable, refusal, UserError } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { findCwdProject } from './select.js'
 import { cliCacheDir, discoverCliProjects, parseCacheDirFlag } from './workspace-config.js'
@@ -145,6 +145,15 @@ async function resolveTarget(
     .all() as Array<{ project: string; task: string }>
   const ids = pairs.map((p) => `${p.project}#${p.task}`)
   const invoked = ids.length === 0 && db.query('SELECT 1 FROM invocations LIMIT 1').get() !== null
+  if (ids.length === 0 && !invoked) {
+    throw refusal(
+      { tone: 'info', headline: `no runs of ${target} yet`, fix: `vx run ${target}` },
+      {
+        code: 'VX_E_NO_HISTORY',
+        message: `vx why: no recorded runs for "${target}"${suggest(target, ids, invoked)}`,
+      },
+    )
+  }
   if (target.includes('#')) {
     throw new UserError(
       `vx why: no recorded runs for "${target}"${suggest(target, ids, invoked)}`,

package/src/cli/workspace-config.ts

@@ -7,7 +7,7 @@
 import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { WorkspaceConfig } from '../config.js'
-import { UserError } from '../util/index.js'
+import { UserError, sayLine } from '../util/index.js'
 import {
   discoverProjects,
   loadProjects,
@@ -33,7 +33,7 @@ interface CliWorkspace {
 }
 
 export const warnToStderr = (message: string): void => {
-  process.stderr.write(`${message}\n`)
+  sayLine('warn', message)
 }
 
 export async function loadCliWorkspace(workspaceRoot: string): Promise<CliWorkspace> {

package/src/graph/scheduler.ts

@@ -152,6 +152,12 @@ export interface TaskOutcome {
    * bounded to its first 8 KiB and last 56 KiB. The run's history keeps it.
    */
   failedOutput?: string
+  /**
+   * When the run keeps its bytes in a remote, a task that ran and saved no
+   * entry (failed, or uncached): its whole output as `encodeOutputLog`
+   * stores it, secrets masked, at the entry's bounds.
+   */
+  runLog?: string
   /**
    * On a failed persistent task: why it never became ready — the readiness
    * deadline fired, the child exited first (`exitCode` is then its own), or
@@ -171,6 +177,8 @@ export interface TaskOutcome {
    *  (`--cache-download=none`) instead of landing on this machine. Absent for
    *  every ordinary outcome. Telemetry-only. */
   outputs?: 'deferred'
+  /** The task ran here and its result went to the cache. The footer's `↑`. */
+  saved?: true
   /**
    * v11 analytics: hrtime span relative to the parent run's t=0.
    * Lets downstream analytics reconstruct the actual parallel timeline