@vzn/vx 0.0.637 → 0.0.639

package/src/cli/help.ts

@@ -1,14 +1,21 @@
-import type { ColorSupport, paint as Paint } from '../orchestrator/index.js'
-import { CORE_VERBS, errorDocument, maskedLine, nearest, wantsJson } from '../util/index.js'
+import {
+  CORE_VERBS,
+  detectColors,
+  errorDocument,
+  maskedLine,
+  nearest,
+  paint,
+  refusalNotice,
+  ui,
+  wantsJson,
+  type ColorSupport,
+} from '../util/index.js'
 
 export async function printHelp(
   pluginCommands: readonly string[] = [],
   verb?: string,
 ): Promise<void> {
   const text = verb === undefined ? helpText(pluginCommands) : verbHelpText(verb)
-  // The orchestrator is already loaded by the plugin-verb lookup every
-  // caller awaits first, so this import costs `vx --version` nothing.
-  const { detectColors, paint } = await import('../orchestrator/index.js')
   process.stdout.write(paintHelp(text, helpColors(process.stdout, detectColors), paint))
 }
 
@@ -33,7 +40,7 @@ const TERM = '#22d3ee' // cyan-400 — a flag, a selector, an example
  * `(for <verb>)` dim), `vx <verb>` bold cyan, and the term an option or
  * example line opens with cyan. Prose and continuation lines stay plain.
  */
-export function paintHelp(text: string, colors: ColorSupport, paint: typeof Paint): string {
+export function paintHelp(text: string, colors: ColorSupport, paint: Paint): string {
   if (!colors.enabled) return text
   const lines = text.split('\n')
   return lines
@@ -164,12 +171,6 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     "      --timeout <duration>        A task's time limit (30s, 10m), for tasks",
     '                                  without their own exec.timeout. A task past it',
     '                                  is killed and fails.',
-    '      --kill-grace <duration>     How long a task that ignores SIGTERM gets',
-    '                                  before SIGKILL (default 2s).',
-    "      --teardown-timeout <duration>  The bound on each plugin's end-of-run flush",
-    '                                  (default 3s).',
-    '      --ready-notice <duration>   When vx says a persistent task still waits for',
-    '                                  readyWhen (default 10s).',
     '      --continue[=<mode>]         What a failed task takes down: never | deps-ok',
     '                                  (default, skips its dependents) | always (bare',
     '                                  form; dependents run, never save).',
@@ -183,18 +184,9 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     'Planning (for run — skips execution):',
     "      --dry[=text|json]    Print the task graph and each task's predicted hit",
     '                           or miss.',
-    '      --graph[=<path>]     Emit Graphviz DOT (stdout if no path).',
     '',
     'Artifacts (for run):',
-    '      --format <fmt>        pretty (default) | json: print the --summarize',
-    '                            document on stdout when the run ends; every other',
-    '                            line goes to stderr.',
-    '      --summarize[=<path>]  Write per-run JSON to <cacheDir>/runs/<run_id>.json.',
     '      --profile[=<path>]    Write Chrome-trace JSON (default profile.json).',
-    '      --report[=markdown]   Print a markdown run report to stdout after the run.',
-    '      --report-file <path>  Append that report to <path> ($GITHUB_STEP_SUMMARY).',
-    '      --tag <k=v>           Label this invocation (repeatable); recorded on its',
-    '                            history row.',
     '',
     'Extensions (plugins):',
     '  vx core runs tasks in-process and nothing else. A dashboard, remote',
@@ -216,12 +208,11 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     'Watch mode:',
     '  vx watch <task>            Initial run, then re-run on filesystem changes.',
     '                             Uses the same flags as `vx run` except --dry /',
-    '                             --graph / --summarize / --profile / --report /',
-    '                             --report-file / --verbosity (they plan or report',
-    '                             one run), plus --poll (watch.poll: poll instead of',
-    '                             the OS watcher). Press Ctrl+C to stop. Cache means most',
-    '                             re-runs are near-zero cost (cache hits restore',
-    '                             outputs + replay logs).',
+    '                             --profile / --verbosity (they plan or report one',
+    '                             run), plus --poll (watch.poll: poll instead of',
+    '                             the OS watcher). Press Ctrl+C to stop.',
+    '                             Cache means most re-runs are near-zero cost',
+    '                             (cache hits restore outputs + replay logs).',
     '',
     'Cache management:',
     '  vx cache clean --older-than 30d     Evict entries last accessed > 30 days ago.',
@@ -395,16 +386,7 @@ export function documentedFlags(verb: string, text = helpText()): string[] {
  * The `vx run` flags `vx watch` refuses: each plans or reports ONE run
  * (`watchRefusal` in watch.ts, held to this list by a test).
  */
-export const WATCH_REFUSED_FLAGS: readonly string[] = [
-  '--dry',
-  '--graph',
-  '--summarize',
-  '--profile',
-  '--report',
-  '--report-file',
-  '--verbosity',
-  '--format',
-]
+export const WATCH_REFUSED_FLAGS: readonly string[] = ['--dry', '--profile', '--verbosity']
 
 /**
  * The flags one verb accepts: those on its own Usage line, and for a verb
@@ -445,7 +427,9 @@ export function refuse(
   code: string,
 ): number {
   const line = `vx ${verb}: ${message}`
-  process.stderr.write(`${line}\n`)
+  ui.print('err', refusalNotice(`vx ${verb}`, message))
   if (wantsJson(args)) process.stdout.write(errorDocument(code, maskedLine(line)))
   return 1
 }
+
+type Paint = typeof paint

package/src/cli/index.ts

@@ -8,11 +8,14 @@ import { FOREIGN_VERBS } from './foreign-flags.js'
 import {
   errorDocument,
   hideEnvFromTasks,
+  sayNotice,
   isFsRefusal,
   isOutOfFds,
   isUserError,
   maskedLine,
   nearest,
+  refusalNotice,
+  ui,
   UserError,
   wantsJson,
 } from '../util/index.js'
@@ -74,7 +77,8 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         await findWorkspaceRoot(process.cwd())
       } catch (err) {
         if (!isUserError(err)) throw err
-        process.stderr.write(`vx: ${err.message}; \`vx help\` lists the verbs\n`)
+        const parts = err.parts ?? { headline: err.message }
+        ui.print('err', refusalNotice('vx', err.message, { ...parts, why: 'see vx help' }))
         return 1
       }
       await printHelp(await (await plugins()).pluginCommandHelp())
@@ -97,19 +101,23 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         const unknown = resolved === null || 'declaredVerbs' in resolved
         const pointer = FOREIGN_VERBS[verb]
         if (unknown && pointer !== undefined) {
-          process.stderr.write(`${pointer}\n`)
+          sayNotice('info', 'vx', pointer)
           return 1
         }
         if (unknown && verb.startsWith('-')) {
-          process.stderr.write(
-            `vx help: unknown flag: ${verb}${flagHint('help', verb)} (see \`vx help\`)\n`,
+          sayNotice(
+            'error',
+            'vx help',
+            `unknown flag: ${verb}${flagHint('help', verb)} (see \`vx help\`)`,
           )
           return 1
         }
         if (unknown) {
           const declared = resolved === null ? [] : resolved.declaredVerbs
-          process.stderr.write(
-            `vx help: unknown command: ${verb}${didYouMeanVerb(verb, declared)} (see \`vx help\`)\n`,
+          sayNotice(
+            'error',
+            'vx help',
+            `unknown command: ${verb}${didYouMeanVerb(verb, declared)} (see \`vx help\`)`,
           )
           return 1
         }
@@ -123,8 +131,10 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
       // takes no more of is refused, as every other verb refuses one.
       const extra = rest[0]
       if (extra !== undefined) {
-        process.stderr.write(
-          `vx version: ${refusedWord(extra)}: ${extra}${flagHint('version', extra)}${seeHelp('version')}\n`,
+        sayNotice(
+          'error',
+          'vx version',
+          `${refusedWord(extra)}: ${extra}${flagHint('version', extra)}${seeHelp('version')}`,
         )
         return 1
       }
@@ -193,8 +203,12 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
       // points at the file that broke it.
       // Every answer below is "no such verb here": under --format json the
       // agent reads it as one code, as a verb's own refusal gives one.
-      const unknown = (text: string, code = 'VX_E_UNKNOWN_COMMAND'): number => {
-        process.stderr.write(text)
+      const unknown = (
+        text: string,
+        code = 'VX_E_UNKNOWN_COMMAND',
+        tone: 'error' | 'info' = 'error',
+      ): number => {
+        sayNotice(tone, 'vx', text.replace(/^vx: /, '').trimEnd())
         if (wantsJson(rest))
           process.stdout.write(errorDocument(code, maskedLine(text.split('\n')[0]!)))
         return 1
@@ -207,7 +221,7 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
       // their chance — a workspace that declares a plugin verb of that name keeps it.
       const moved = FOREIGN_VERBS[command]
       if (moved !== undefined) {
-        return unknown(`${moved}${loadNote}\n`)
+        return unknown(`${moved}${loadNote}\n`, undefined, 'info')
       }
       // A task typed where the verb goes (`turbo build`, `nx build app`),
       // `turbo dev` included: a repo's own `dev` task beats the no-service note.

package/src/cli/info.ts

@@ -4,11 +4,12 @@
 // from the orchestrator's `collectInfo` (doctor.ts); this file parses the flags and renders the rows.
 
 import os from 'node:os'
-import { collectInfo, type FlakyTask, type InfoFacts } from '../orchestrator/index.js'
+import { collectInfo, type InfoFacts } from '../orchestrator/index.js'
+import { type FlakyTask } from '../history/index.js'
 import { flagHint, formatValue, refuse, refusedWord, seeHelp } from './help.js'
 import { namedCacheDir, parseCacheDirFlag, warnToStderr } from './workspace-config.js'
 import { formatBytes } from './format.js'
-import { MIN_BUN } from '../util/index.js'
+import { detectColors, MIN_BUN, ui, type ColorSupport } from '../util/index.js'
 import { envName } from '../settings.js'
 
 interface InfoArgs {
@@ -55,12 +56,14 @@ export async function infoCmd(args: readonly string[]): Promise<number> {
     warn: warnToStderr,
   })
   process.stdout.write(
-    parsed.format === 'json' ? `${JSON.stringify(facts)}\n` : `${renderInfo(facts)}\n`,
+    parsed.format === 'json'
+      ? `${JSON.stringify(facts)}\n`
+      : `${renderInfo(facts, detectColors(process.stdout))}\n`,
   )
   return 0
 }
 
-export function renderInfo(f: InfoFacts): string {
+export function renderInfo(f: InfoFacts, colors: ColorSupport = { enabled: false }): string {
   const rows: [string, string][] = [
     [
       'vx',
@@ -122,8 +125,7 @@ export function renderInfo(f: InfoFacts): string {
     ['sandbox', describeSandbox(f.sandbox)],
     ['projects lock', f.lockfile ? 'yes' : 'no'],
   ]
-  const labelW = Math.max(...rows.map(([label]) => label.length))
-  return rows.map(([label, value]) => `${`${label}:`.padEnd(labelW + 1)} ${value}`).join('\n')
+  return ui.report('vx info', rows).lines(colors).join('\n')
 }
 
 /** `812 (1.2 GB)`, or against `cacheRetention.maxSize`: `812 (1.2 GB of 10 GB, 12%)`. */

package/src/cli/init.ts

@@ -15,7 +15,7 @@ import { lockAfterMigration } from './lock.js'
 import { PLUGIN_TEMPLATES } from './plugin-templates.js'
 import { isCompiledBinary } from './upgrade.js'
 import { VERSION } from '../version.js'
-import { DOT_VX_GITATTRIBUTES, DOT_VX_GITIGNORE, UserError } from '../util/index.js'
+import { DOT_VX_GITATTRIBUTES, DOT_VX_GITIGNORE, ui, UserError, sayNotice } from '../util/index.js'
 import {
   findWorkspaceRoot,
   PROJECT_CONFIG_FILENAMES,
@@ -125,7 +125,7 @@ async function scaffoldPlugin(seam: string, root: string, args: InitArgs): Promi
   if (!args.force) {
     for (const [rel] of files) {
       if (await Bun.file(path.join(root, rel)).exists()) {
-        process.stderr.write(`vx init: ${rel} exists; --force overwrites it\n`)
+        sayNotice('error', 'vx init', `${rel} exists. --force overwrites it`)
         return 1
       }
     }
@@ -193,27 +193,26 @@ async function starter(root: string, noGit: boolean, args: InitArgs): Promise<nu
     )
     return 0
   }
-  const report = [
-    'vx init: no package.json, so no scripts to map: a workspace with one project, the root.',
-  ]
-  const named = files.map((f) => f.path).join(', ')
-  if (files.length > 0)
-    report.push(args.dry ? `would write ${named} (dry run, nothing written).` : `wrote ${named}.`)
-  if (kept.length > 0) report.push(`kept ${kept.join(', ')}.`)
-  if (replaced.length > 0)
-    report.push(`${args.dry ? 'would replace' : 'replaced'} ${replaced.join(', ')}.`)
+  const rows: ui.FieldRow[] = [['from', 'no package.json: one project, the root']]
+  if (args.dry) rows.push(['dry run', 'nothing written'])
+  if (files.length > 0) rows.push(['files', ...files.map((f) => f.path)])
+  if (kept.length > 0) rows.push(['kept', ...kept])
+  if (replaced.length > 0) rows.push(['replaced', ...replaced])
   if (args.dry) {
     for (const f of files) process.stdout.write(`── ${f.path} ──\n${f.contents}\n`)
-    process.stdout.write(`${report.join('\n')}\n\nnext: ${next}\n`)
+    ui.print('out', ui.report(`vx init ${VERSION}`, [...rows, null, ['next', next]]))
     return 0
   }
   for (const f of files) await Bun.write(path.join(root, f.path), f.contents)
   for (const f of replaced) await unlink(path.join(root, f))
   // The lock that follows loads the workspace file just written.
   workspaceFileWritten()
-  process.stdout.write(`${report.join('\n')}\n\n`)
-  const locked = (await lockAfterMigration(root)) === 0
-  process.stdout.write(`\nnext: ${locked ? next : `fix the above and run vx lock, then ${next}`}\n`)
+  const lock = await lockAfterMigration(root)
+  rows.push(['lock', lock.code === 0 ? lock.said.replace(/^locked /, '') : 'not written'], null, [
+    'next',
+    lock.code === 0 ? next : `fix the above, then vx lock and ${next}`,
+  ])
+  ui.print('out', ui.report(`vx init ${VERSION}`, rows))
   return 0
 }
 

package/src/cli/last.ts

@@ -9,22 +9,24 @@ import { Cache } from '../cache/index.js'
 import { formatBytes } from './format.js'
 import { flagHint, formatValue, seeHelp } from './help.js'
 import {
-  currentBranch,
-  exitSignal,
   type FailureMode,
   getInvocation,
   getRun,
   type InvocationDetail,
   listInvocations,
   LocalHistoryProvider,
-  outcomeWord,
   type RunSummaryRow,
+} from '../history/index.js'
+import {
+  currentBranch,
+  exitSignal,
   resolveRunId,
   runFailures,
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
-import { formatElapsed, splitTaskId, UserError } from '../util/index.js'
+import { outcomeWord } from '../report/index.js'
+import { formatElapsed, refusal, splitTaskId, UserError, sayNotice, ui } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import { cliCacheDir, parseCacheDirFlag } from './workspace-config.js'
 
@@ -242,7 +244,7 @@ async function printStats(
     return 0
   }
   if (stats.length === 0) {
-    process.stdout.write('no recorded runs\n')
+    ui.print('out', ui.status('info', 'vx last', 'no runs yet'))
     return 0
   }
   const pct = (r: number): string => `${Math.round(r * 100)}%`
@@ -319,6 +321,7 @@ function reasonParts(t: RunSummaryRow): string {
   } else if (t.status === 'skipped' && t.blockedBy !== null) {
     parts.push(`after ${t.blockedBy} failed`)
   }
+  if (t.remoteError !== null) parts.push(`remote \u2717 ${t.remoteError}`)
   return parts.map((p) => `  ${p}`).join('')
 }
 
@@ -468,8 +471,10 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         return 0
       }
       if (log.source === null) {
-        process.stderr.write(
-          `vx last: ${log.taskId} ended ${log.status}; vx keeps output only for failed and cached tasks\n`,
+        sayNotice(
+          'info',
+          'vx last',
+          `${log.taskId} ended ${log.status}. vx keeps output only for failed and cached tasks`,
         )
       }
       process.stdout.write(log.output)
@@ -486,9 +491,8 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         return 0
       }
       if (invocations.length === 0) {
-        process.stdout.write(
-          parsed.failed === true && !noRuns() ? 'no recorded run failed\n' : 'no recorded runs\n',
-        )
+        const none = parsed.failed === true && !noRuns() ? 'no failed runs' : 'no runs yet'
+        ui.print('out', ui.status('info', 'vx last', none))
         return 0
       }
       const lines = formatRunList(
@@ -504,6 +508,12 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
         : parsed.failed === true
           ? (failedInvocations(db, 1)[0] ?? null)
           : (listInvocations(db, { limit: 1 })[0] ?? null)
+    if ((inv === null || inv === undefined) && noRuns()) {
+      throw refusal(
+        { tone: 'info', headline: 'no runs yet', fix: 'vx run' },
+        { code: 'VX_E_NO_HISTORY', message: 'vx last: no recorded runs yet — run something first' },
+      )
+    }
     if (inv === null || inv === undefined) {
       throw new UserError(
         noRuns()

package/src/cli/lock.ts

@@ -17,11 +17,14 @@ import {
 } from '../orchestrator/index.js'
 import { resolveSetting, runRules } from '../settings.js'
 import {
-  configErrorFrame,
+  refusalNotice,
   DOT_VX_GITATTRIBUTES,
   isUserError,
   relPosix,
+  type RefusalParts,
   secretMask,
+  ui,
+  sayNotice,
 } from '../util/index.js'
 import {
   findProjectConfigs,
@@ -84,7 +87,7 @@ export async function lockCmd(args: readonly string[]): Promise<number> {
 
 /**
  * Projects with tasks and no vx.config: a plugin's tasks, which load live
- * in every run, so both verbs name them — `locked 0 project configs`
+ * in every run, so both verbs name them — `0 project configs`
  * on a turbo() repo read like an audit of something (2026-09-16). One with
  * no task is left out: solidjs/solid's solid-ssr, which has no script Turbo
  * runs, read as a project whose tasks come live from the plugin `project` stage.
@@ -100,13 +103,14 @@ function bareProjects(all: readonly ProjectMeta[], tasked: ReadonlySet<string>):
 export async function lockWorkspace(
   root: string,
   warn: (message: string) => void = warnToStderr,
+  say: (line: string) => void = (line) => ui.print('out', ui.status('ok', 'vx lock', line)),
 ): Promise<number> {
   const check = await audit(root, warn)
   if (check.broken !== null) {
-    process.stderr.write(`vx lock: ${LOCKFILE_NAME} not written: ${framed(check.broken)}\n`)
+    notWritten(check.broken, check.brokenParts)
     return 1
   }
-  return await writeLock(root, check)
+  return await writeLock(root, check, say)
 }
 
 /**
@@ -159,6 +163,7 @@ async function audit(root: string, warn: (message: string) => void): Promise<Gra
       closure: false,
       configs: lock,
       warn,
+      lock: true,
     })
     for (const entry of projects.values()) resolved.set(entry.name, entry.config)
     const names = new Set<string>()
@@ -193,7 +198,8 @@ async function audit(root: string, warn: (message: string) => void): Promise<Gra
         rules,
       })
   } catch (err) {
-    if (isUserError(err)) return { ...out, broken: err.message }
+    if (isUserError(err))
+      return { ...out, broken: err.message, ...(err.parts ? { brokenParts: err.parts } : {}) }
     throw err
   }
   return out
@@ -202,6 +208,7 @@ async function audit(root: string, warn: (message: string) => void): Promise<Gra
 interface GraphCheck {
   /** A graph rule's refusal, or a config that does not load; null when sound. */
   broken: string | null
+  brokenParts?: RefusalParts
   /** The lock the configs evaluate to here. */
   fresh: Lockfile
   /** Every project, as a run discovers them from `fresh`. */
@@ -219,23 +226,25 @@ function configured(all: readonly ProjectMeta[]): ConfiguredMeta[] {
 }
 
 /**
- * `vx init`'s last step: the lock, as `vx lock` writes it. A refusal (a
- * graph rule, a config that does not load) is printed and leaves the
- * written configs in place.
+ * `vx init`'s last step: the lock, as `vx lock` writes it, its line
+ * returned for the report's `lock` row. A refusal (a graph rule, a config
+ * that does not load) is printed and leaves the written configs in place.
  */
-export async function lockAfterMigration(root: string): Promise<number> {
+export async function lockAfterMigration(root: string): Promise<{ code: number; said: string }> {
+  let said = ''
   try {
-    return await lockWorkspace(root)
+    const code = await lockWorkspace(root, warnToStderr, (line) => (said = line))
+    return { code, said }
   } catch (err) {
     if (!isUserError(err)) throw err
-    process.stderr.write(`vx lock: ${LOCKFILE_NAME} not written: ${framed(err.message)}\n`)
-    return 1
+    notWritten(err.message, err.parts)
+    return { code: 1, said }
   }
 }
 
-/** A config refusal as a run used to print it: path:line:col and the source line. */
-function framed(message: string): string {
-  return configErrorFrame(message, process.cwd()) ?? message
+/** The lock refused: the refusal's own parts, or its config line and frame, or its message. */
+function notWritten(message: string, parts: RefusalParts | undefined): void {
+  ui.print('err', refusalNotice('vx lock', message, parts, { headline: 'lock not written' }))
 }
 
 /** Names shown per note: a turbo() repo can have hundreds of bare projects. */
@@ -295,7 +304,11 @@ async function writeIfMissing(file: string, text: string): Promise<void> {
   }
 }
 
-async function writeLock(root: string, check: GraphCheck): Promise<number> {
+async function writeLock(
+  root: string,
+  check: GraphCheck,
+  say: (line: string) => void,
+): Promise<number> {
   const metas = configured(check.all)
   const bare = bareProjects(check.all, check.tasked)
   // By project name, as the refusal names them.
@@ -310,11 +323,12 @@ async function writeLock(root: string, check: GraphCheck): Promise<number> {
   for (const l of secretsIn(Object.fromEntries(reviews.map((r) => [r.name, r.config]))))
     if (!named.has(l.at)) leaks.push(l)
   if (leaks.length > 0) {
-    process.stderr.write(
-      `vx lock: ${LOCKFILE_NAME} is committed, and these configs evaluated to a secret value:\n` +
-        leaks.map((l) => `  ${l.at}\n`).join('') +
-        `let the shell expand it ($${leaks[0]!.name} in the command, the name in exec.env.passThrough) instead of reading process.env in the config\n`,
-    )
+    notWritten('', {
+      headline: 'these configs evaluated to a secret value',
+      what: leaks.map((l) => l.at),
+      why: 'the lock is committed, so the secret would be too',
+      fix: `let the shell expand it ($${leaks[0]!.name} in the command, the name in exec.env.passThrough) instead of reading process.env in the config`,
+    })
     return 1
   }
   await writeLockfile(root, check.fresh)
@@ -323,9 +337,7 @@ async function writeLock(root: string, check: GraphCheck): Promise<number> {
     writeIfMissing(path.join(root, '.vx', '.gitattributes'), DOT_VX_GITATTRIBUTES),
   ])
   const n = metas.length
-  process.stdout.write(
-    `vx lock: locked ${n} project config${n === 1 ? '' : 's'} → ${LOCKFILE_NAME}${bareNote(bare)}\n`,
-  )
+  say(`${n} project config${n === 1 ? '' : 's'} → ${LOCKFILE_NAME}${bareNote(bare)}`)
   return 0
 }
 
@@ -389,7 +401,7 @@ async function checkLock(root: string, json: boolean): Promise<number> {
   const lock = await readLockfile(root)
   if (!lock) {
     const problem = `no ${LOCKFILE_NAME} at ${root} — run \`vx lock\` first`
-    if (!json) process.stderr.write(`vx lock --check: ${problem}\n`)
+    if (!json) sayNotice('error', 'vx lock --check', problem)
     return answer([problem])
   }
   const failures: string[] = []
@@ -451,12 +463,12 @@ async function checkLock(root: string, json: boolean): Promise<number> {
   }
   if (json) return answer(failures)
   if (failures.length > 0) {
-    for (const f of failures) process.stderr.write(`vx lock --check: ${f}\n`)
+    for (const f of failures) sayNotice('error', 'vx lock --check', f)
     return 1
   }
   const n = metas.length
   const audited = `${n} project${n === 1 ? '' : 's'}`
   const skipped = bare.length === 0 ? '' : `; not audited, no vx.config: ${bareNames(bare)}`
-  process.stdout.write(`vx lock --check: up to date (${audited}${skipped})\n`)
+  ui.print('out', ui.status('ok', 'vx lock --check', `up to date (${audited}${skipped})`))
   return 0
 }