@vzn/vx 0.0.637 → 0.0.639

package/src/cli/select.ts

@@ -32,6 +32,7 @@ import {
   maskedLine,
   nearest,
   UserError,
+  sayNotice,
 } from '../util/index.js'
 import {
   claimedAffected,
@@ -434,8 +435,10 @@ export async function resolveFilters(
   // Something matched, so the run proceeds; a pattern that matched nothing
   // alongside it is still worth a line — it is probably a typo.
   for (const f of unmatched)
-    process.stderr.write(
-      `vx: filter "${f}" matched no projects${didYouMean([f], projects, tags)}\n`,
+    sayNotice(
+      'warn',
+      'vx run',
+      `filter "${f}" matched no projects${didYouMean([f], projects, tags)}`,
     )
   // Each include is a union: what `--filter other` selected runs its tasks
   // whether or not the `--affected` diff reaches them, and an exclude
@@ -511,14 +514,18 @@ export async function pickTask(
     }
   }
   if (entries.length === 0 && only !== undefined) {
-    process.stderr.write(
-      `vx run: no tasks declared in the selected projects (${[...only].sort().join(', ')})\n`,
+    sayNotice(
+      'error',
+      'vx run',
+      `no tasks declared in the selected projects (${[...only].sort().join(', ')})`,
     )
     return null
   }
   if (entries.length === 0) {
-    process.stderr.write(
-      'vx run: no tasks declared in any project; declare one under `tasks` in a vx.config, or run `vx init` to write them from package.json scripts, then `vx lock`\n',
+    sayNotice(
+      'error',
+      'vx run',
+      'no tasks declared in any project. Declare one under `tasks` in a vx.config, or run `vx init` to write them from package.json scripts, then `vx lock`',
     )
     return null
   }
@@ -562,13 +569,15 @@ export async function pickTask(
       if (!(err instanceof Error) || err.name !== 'AbortError') throw err
       if (interrupted) return 'interrupted'
       out.write('\n')
-      process.stderr.write(`vx run: no task picked\n`)
+      sayNotice('info', 'vx run', 'no task picked')
       return null
     }
     const n = Number(answer)
     if (!Number.isInteger(n) || n < 1 || n > entries.length) {
-      process.stderr.write(
-        `vx run: invalid selection: ${answer} (type a number from 1 to ${entries.length})\n`,
+      sayNotice(
+        'error',
+        'vx run',
+        `invalid selection: ${answer} (type a number from 1 to ${entries.length})`,
       )
       return null
     }

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 }
@@ -159,8 +169,14 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const projects = await loadCliProjects(root, metas, scope, { closure: true })
 
   if (parsed.target === undefined) {
+    if (metas.length === 0)
+      sayNotice(
+        'info',
+        'vx show',
+        'no projects: no directory holds a vx.config — run `vx init` to write them, then `vx lock`',
+      )
     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 +220,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 +231,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 +243,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 +300,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 +334,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 +343,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 +359,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 +369,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 +388,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 +402,7 @@ function renderTaskAcross(
   declaring: readonly ProjectEntry[],
   taskName: string,
   format: 'pretty' | 'json',
+  colors: ColorSupport,
 ): string {
   if (format === 'json') {
     const list = declaring.map((p) => ({
@@ -383,18 +413,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 +477,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

@@ -10,6 +10,8 @@
 // package manager (npm, pnpm, bun, yarn; global or a project's
 // dependency) is upgraded by that package manager, never by a rename over
 // a file it owns. vx never installs Node or a package manager.
+// Handed a call by a global vx, the project's vx moves that global too,
+// to the same version (`upgradeGlobal`).
 // Named `upgrade` (not `update`) per CLI convention: bun upgrade,
 // deno upgrade — "update" is what package managers do to indexes.
 
@@ -18,7 +20,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'
@@ -290,17 +292,19 @@ export function binaryFromTarball(tgz: Uint8Array): Uint8Array {
 /**
  * The binary of `pkg@spec`, verified: the registry document's signature,
  * then the tarball's integrity, then the extraction, each refusing before
- * the next step runs. Null when the release is this vx's own version;
- * `announce` hears the version before the download starts.
+ * the next step runs. Null when the release is `current`, the version of
+ * the vx being replaced; `announce` hears the version before the download
+ * starts.
  */
 export async function releaseBinary(
   pkg: string,
   spec: string,
   announce: (version: string) => void,
   key: SigningKey = NPM_SIGNING_KEY,
+  current = VERSION,
 ): Promise<Uint8Array | null> {
   const release = verifiedRelease(await fetchManifest(pkg, spec), pkg, key)
-  if (release.version === VERSION) return null
+  if (release.version === current) return null
   announce(release.version)
   return binaryFromTarball(await downloadVerified(release))
 }
@@ -518,22 +522,33 @@ async function targetVersion(tag: string | undefined): Promise<string> {
   return v
 }
 
-/** Run the package manager that owns this vx; vx never installs one. */
-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`)
-    return 0
+/**
+ * Run the package manager that owns a vx at `current` to bring it to
+ * `version`; vx never installs one. `step` names the install when a run
+ * moves two (`project `, `global `).
+ */
+async function upgradeManaged(
+  install: ManagedInstall,
+  version: string,
+  current = VERSION,
+  step = '',
+): Promise<void> {
+  if (version === current) {
+    ui.print('out', ui.status('info', 'vx upgrade', `${step}already at ${current}`))
+    return
   }
   const argv = upgradeArgv(install, version)
-  const bin = Bun.which(argv[0]!)
+  // PATH as it is now: `Bun.which` alone reads the one the process started with.
+  const bin = Bun.which(argv[0]!, { PATH: process.env['PATH'] ?? '' })
   if (bin === null) {
     throw new UserError(
       `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', `${step}${current} → ${version}`),
+    ui.text([ui.cmd(argv.join(' ')), ui.dim(` in ${install.cwd}`)]),
   )
   const proc = Bun.spawnSync({
     cmd: [bin, ...argv.slice(1)],
@@ -545,14 +560,99 @@ async function upgradeManaged(install: ManagedInstall, tag: string | undefined):
       `vx upgrade: ${argv.join(' ')} failed (exit ${proc.exitCode}) — vx changed nothing itself`,
     )
   }
-  return 0
+}
+
+/**
+ * Replace the binary at `dest`, at `current`, with the verified release
+ * `spec` names (`latest` or a version). `step` as in `upgradeManaged`.
+ */
+async function upgradeBinary(
+  dest: string,
+  spec: string,
+  current = VERSION,
+  step = '',
+  key: SigningKey = NPM_SIGNING_KEY,
+): Promise<void> {
+  const pkg = platformPackage()
+  let installed: string | undefined
+  const replaced = await replaceBinary(
+    dest,
+    () =>
+      releaseBinary(
+        pkg,
+        spec,
+        (version) =>
+          ui.print(
+            'out',
+            ui.status('info', 'vx upgrade', `${step}${current} → ${version}`),
+            ui.text(ui.dim(dest)),
+          ),
+        key,
+        current,
+      ),
+    // The replaced binary's own version: the new build speaks for itself
+    // rather than this process guessing, and one that cannot is rolled back.
+    (bin) => {
+      installed = answeredVersion(bin)
+      return installed !== undefined
+    },
+  )
+  ui.print(
+    'out',
+    replaced
+      ? ui.status('ok', 'vx upgrade', `${step}installed ${installed}`)
+      : ui.status('info', 'vx upgrade', `${step}already at ${current}`),
+  )
+}
+
+/** The version `bin --version` answers, without the hand-off note a handed-off run adds. */
+function answeredVersion(bin: string): string | undefined {
+  return startedVersion(bin)?.split(' ')[1]
+}
+
+/**
+ * Bring `from`, the global vx that handed this run to the project's own
+ * (`VX_HANDED_OFF`), to `version`, the way it was installed: a binary
+ * installed by hand is replaced, a package manager's global install is
+ * updated by that manager. A refusal names it.
+ */
+export async function upgradeGlobal(
+  from: string,
+  version: string,
+  key: SigningKey = NPM_SIGNING_KEY,
+): Promise<void> {
+  await named(`global vx ${from}`, async () => {
+    const current = answeredVersion(from)
+    if (current === undefined) {
+      throw new UserError('vx upgrade: it did not answer `--version`, so it is left as it is')
+    }
+    if (current === version) {
+      ui.print('out', ui.status('info', 'vx upgrade', `global already at ${current}`))
+      return
+    }
+    const install = managedInstall(from, path.dirname(from))
+    if (install === null) await upgradeBinary(from, version, current, 'global ', key)
+    else await upgradeManaged(install, version, current, 'global ')
+  })
+}
+
+/** `run`, its refusal naming `what` after the verb: a run that moves two installs says which failed. */
+async function named(what: string, run: () => Promise<void>): Promise<void> {
+  try {
+    await run()
+  } catch (err) {
+    if (!(err instanceof UserError)) throw err
+    throw new UserError(err.message.replace(/^vx upgrade: /, `vx upgrade: ${what}: `), err.code)
+  }
 }
 
 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 +660,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()) {
@@ -571,28 +671,21 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
   }
   const dest = process.execPath
   const install = managedInstall(dest, process.cwd())
-  if (install !== null) return await upgradeManaged(install, tag)
-  const pkg = platformPackage()
-  const spec = versionSpec(tag)
-  let installed = ''
-  const replaced = await replaceBinary(
-    dest,
-    () =>
-      releaseBinary(pkg, spec, (version) =>
-        process.stdout.write(`vx upgrade: ${VERSION} → ${version} (${dest})\n`),
-      ),
-    // The replaced binary's own version: the new build speaks for itself
-    // rather than this process guessing, and one that cannot is rolled back.
-    (bin) => {
-      installed = startedVersion(bin) ?? ''
-      return installed !== ''
-    },
-  )
-  process.stdout.write(
-    replaced
-      ? `vx upgrade: installed ${installed}\n`
-      : `vx upgrade: already at ${VERSION} — nothing to do\n`,
-  )
+  // A global vx handed this run to the project's own: both move, to one
+  // version, the project first (owner, 2026-10-15).
+  const from = process.env['VX_HANDED_OFF']
+  if (from !== undefined) {
+    const version = await targetVersion(tag)
+    await named('project vx', () =>
+      install === null
+        ? upgradeBinary(dest, version, VERSION, 'project ')
+        : upgradeManaged(install, version, VERSION, 'project '),
+    )
+    await upgradeGlobal(from, version)
+    return 0
+  }
+  if (install !== null) await upgradeManaged(install, await targetVersion(tag))
+  else await upgradeBinary(dest, versionSpec(tag))
   return 0
 }
 

package/src/cli/watch-cycle.ts

@@ -5,7 +5,8 @@
 // as Ctrl-C would and the loop starts the next one; a cycle running any
 // other work is never stopped.
 
-import { createEventBus, type RunOptions } from '../orchestrator/index.js'
+import { type RunOptions } from '../orchestrator/index.js'
+import { createEventBus } from '../report/index.js'
 
 export interface WatchCycle {
   /** The options for this cycle's run: its own bus and a stop of its own beside watch's. */

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 {