@vzn/vx 0.0.637 → 0.0.638

package/src/cli/last.ts

@@ -24,7 +24,7 @@ import {
   shortRunId,
   taskLog,
 } from '../orchestrator/index.js'
-import { formatElapsed, splitTaskId, UserError } from '../util/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 +242,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)}%`
@@ -468,8 +468,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 +488,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 +505,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
 }

package/src/cli/plan-format.ts

@@ -118,9 +118,11 @@ function describeReason(r: AffectedReason): string {
           ? `a ^ edge passes changed package ${r.project}`
           : r.kind === 'input'
             ? `${r.file} changed (an input)`
-            : r.file !== undefined
-              ? `${r.file} changed (in its project)`
-              : 'its project changed as a whole'
+            : r.kind === 'workspace'
+              ? `${r.file} changed (workspace-wide)`
+              : r.file !== undefined
+                ? `${r.file} changed (in its project)`
+                : 'its project changed as a whole'
   return r.via === undefined ? cause : `${cause}, via ${r.via.join(' ← ')}`
 }
 

package/src/cli/plugin-commands.ts

@@ -7,8 +7,10 @@
 // reports an unknown command as it always did. Core's verbs are matched
 // before this is asked, so a plugin cannot shadow `run`.
 
+import type { CachePolicy, PluginCache, PluginCacheRemote } from '../cache/index.js'
+import type { WorkspaceConfig } from '../config.js'
 import type { VxPlugin, PluginCommand, CommandContext } from '../orchestrator/index.js'
-import { findWorkspaceRoot } from '../workspace/index.js'
+import { cacheScopeEnvError, findWorkspaceRoot, isCacheScope } from '../workspace/index.js'
 import { machineParallelism, maskedLine } from '../util/index.js'
 import { resolveSetting } from '../settings.js'
 
@@ -39,10 +41,15 @@ export interface UnresolvedPluginCommand {
   loadError: string
 }
 
-async function workspacePlugins(
-  cwd: string,
-): Promise<
-  | { workspaceRoot: string; cacheDir: string; concurrency: number; plugins: readonly VxPlugin[] }
+async function workspacePlugins(cwd: string): Promise<
+  | {
+      workspaceRoot: string
+      cacheDir: string
+      storeRoot: Promise<string | null>
+      workspaceConfig: WorkspaceConfig | null
+      concurrency: number
+      plugins: readonly VxPlugin[]
+    }
   | UnresolvedPluginCommand
   | null
 > {
@@ -62,6 +69,8 @@ async function workspacePlugins(
   return {
     workspaceRoot,
     cacheDir: ws.cacheDir,
+    storeRoot: ws.storeRoot,
+    workspaceConfig: ws.workspaceConfig,
     // What run.ts takes when no --concurrency is given.
     concurrency:
       (resolveSetting('run.concurrency', ws.workspaceConfig).value as number | undefined) ??
@@ -98,13 +107,75 @@ export async function resolvePluginCommand(
         vx: (await import('./upgrade.js')).isCompiledBinary()
           ? [process.execPath]
           : [process.execPath, Bun.main],
-        warn: (m) => process.stderr.write(`${maskedLine(m)}\n`),
+        warn,
+        cache: lazyCache(() => verbCache(ws, plugin.name)),
       },
     }
   }
   return { declaredVerbs: [...declaredVerbs] }
 }
 
+const warn = (m: string): void => {
+  process.stderr.write(`${maskedLine(m)}\n`)
+}
+
+/** Read-only: a verb reads what runs stored, and only a run's policy may write. */
+const VERB_POLICY: CachePolicy = {
+  localRead: true,
+  localWrite: false,
+  remoteRead: true,
+  remoteWrite: false,
+}
+
+/**
+ * The verb's `ctx.cache`: the plugin's entries in the local store, then each
+ * remote the workspace's cache plugins supply, under the run's scope. Opened
+ * on first use, so a verb that never reads it opens nothing.
+ */
+async function verbCache(
+  ws: Exclude<Awaited<ReturnType<typeof workspacePlugins>>, UnresolvedPluginCommand | null>,
+  plugin: string,
+): Promise<PluginCache> {
+  const [{ Cache, pluginCache }, { resolveCache }] = await Promise.all([
+    import('../cache/index.js'),
+    import('../orchestrator/index.js'),
+  ])
+  const envScope = process.env['VX_CACHE_SCOPE'] || undefined
+  if (envScope !== undefined && !isCacheScope(envScope)) throw cacheScopeEnvError()
+  const scope = envScope ?? ws.workspaceConfig?.cache?.scope
+  const localCache = new Cache(
+    ws.cacheDir,
+    { read: true, write: false },
+    ws.workspaceRoot,
+    undefined,
+    'open',
+    await ws.storeRoot,
+  )
+  const remotes: PluginCacheRemote[] = []
+  await resolveCache(ws.plugins, {
+    workspaceRoot: ws.workspaceRoot,
+    cacheDir: ws.cacheDir,
+    warn,
+    scope,
+    localCache,
+    policy: VERB_POLICY,
+    remotes,
+  })
+  return pluginCache(plugin, { db: localCache.dbHandle(), policy: VERB_POLICY, remotes, scope })
+}
+
+function lazyCache(open: () => Promise<PluginCache>): PluginCache {
+  let opened: Promise<PluginCache> | undefined
+  const cache = (): Promise<PluginCache> => (opened ??= open())
+  return {
+    get: async (key) => (await cache()).get(key),
+    put: async (key, bytes) => (await cache()).put(key, bytes),
+    has: async (key) => (await cache()).has(key),
+    hasMany: async (keys) => (await cache()).hasMany(keys),
+    getRun: async (name) => (await cache()).getRun(name),
+  }
+}
+
 /** The plugin verbs the workspace around `cwd` declares, in declaration order; none when it does not load. */
 export async function pluginVerbs(cwd = process.cwd()): Promise<string[]> {
   const ws = await workspacePlugins(cwd).catch(() => null)

package/src/cli/plugin-templates.ts

@@ -16,7 +16,7 @@ export const PLUGIN_TEMPLATES: Readonly<Record<string, { plugin: string; test: s
   commands: {
     plugin:
       "// `commands`: a CLI verb. `vx cache-dir` prints where this workspace's cache\n// lives. The verb's return value is the exit code.\nimport { definePlugin, type VxPlugin } from '@vzn/vx'\n\nexport function cacheDirVerb(): VxPlugin {\n  return definePlugin(import.meta, {\n    commands: {\n      'cache-dir': {\n        description: \"print this workspace's cache directory\",\n        run(argv, ctx) {\n          if (argv.length > 0) {\n            console.error(`vx cache-dir: takes no arguments, got ${argv.join(' ')}`)\n            return 2\n          }\n          console.log(ctx.cacheDir)\n          return 0\n        },\n      },\n    },\n  })\n}\n",
-    test: "// A test for the example `commands` plugin beside it: the verb is called\n// the way vx calls it, with the context vx hands it. `bun test` runs it.\nimport { expect, it, spyOn } from 'bun:test'\nimport { cacheDirVerb } from './commands.ts'\n\nconst verb = cacheDirVerb().commands!['cache-dir']!\nconst ctx = {\n  workspaceRoot: '/ws',\n  cacheDir: '/ws/.vx/cache',\n  warn() {},\n  concurrency: 1,\n  vx: ['vx'],\n}\n\nit('prints the cache directory; an argument is exit 2', async () => {\n  const out = spyOn(console, 'log').mockImplementation(() => {})\n  const err = spyOn(console, 'error').mockImplementation(() => {})\n  try {\n    expect(await verb.run([], ctx)).toBe(0)\n    expect(out.mock.calls).toEqual([['/ws/.vx/cache']])\n    expect(await verb.run(['x'], ctx)).toBe(2)\n    expect(err.mock.calls).toEqual([['vx cache-dir: takes no arguments, got x']])\n  } finally {\n    out.mockRestore()\n    err.mockRestore()\n  }\n})\n",
+    test: "// A test for the example `commands` plugin beside it: the verb is called\n// the way vx calls it, with the context vx hands it. `bun test` runs it.\nimport { expect, it, spyOn } from 'bun:test'\nimport { cacheDirVerb } from './commands.ts'\n\nconst verb = cacheDirVerb().commands!['cache-dir']!\nconst ctx = {\n  workspaceRoot: '/ws',\n  cacheDir: '/ws/.vx/cache',\n  warn() {},\n  concurrency: 1,\n  vx: ['vx'],\n  cache: {\n    get: async () => null,\n    put: async () => {},\n    has: async () => null,\n    hasMany: async () => null,\n    getRun: async () => null,\n  },\n}\n\nit('prints the cache directory; an argument is exit 2', async () => {\n  const out = spyOn(console, 'log').mockImplementation(() => {})\n  const err = spyOn(console, 'error').mockImplementation(() => {})\n  try {\n    expect(await verb.run([], ctx)).toBe(0)\n    expect(out.mock.calls).toEqual([['/ws/.vx/cache']])\n    expect(await verb.run(['x'], ctx)).toBe(2)\n    expect(err.mock.calls).toEqual([['vx cache-dir: takes no arguments, got x']])\n  } finally {\n    out.mockRestore()\n    err.mockRestore()\n  }\n})\n",
   },
   executor: {
     plugin:

package/src/cli/run.ts

@@ -23,7 +23,7 @@ import {
 } from '../cache/index.js'
 import { affectedFilterFor, findCwdSelection, pickTask, resolveFilters } from './select.js'
 import { nxTargetHint, taskNamesHere } from './task-verb.js'
-import { parseDecimalInt } from '../util/index.js'
+import { parseDecimalInt, sayNotice, sayLine } from '../util/index.js'
 import { kindHint, parseSettingValue, type Setting, SETTINGS, settingRefusal } from '../settings.js'
 import { formatGraphDot, formatPlanJson, formatPlanText } from './plan-format.js'
 
@@ -556,7 +556,7 @@ export async function resolveRunOptions(
       // scope. An empty project list keeps the bare tasks unselected
       // while the anchored ones still run.
       if (anchoredTasks.length === 0) return { nothingSelected: resolved.empty }
-      process.stderr.write(`vx: ${resolved.empty} — running ${anchoredTasks.join(', ')} only\n`)
+      sayNotice('info', 'vx run', `${resolved.empty} — running ${anchoredTasks.join(', ')} only`)
       projects = []
     } else {
       projects = resolved.names
@@ -665,7 +665,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
     // Every run needs git: refused here, not after the user has chosen.
     const refusal = gitRefusal(await findWorkspaceRoot(cwd))
     if (refusal !== undefined) {
-      process.stderr.write(`${refusal.message}\n`)
+      sayLine('error', refusal.message, 'vx run')
       return 1
     }
     const load = parsed.cacheDir !== undefined ? { cacheDir: parsed.cacheDir } : {}
@@ -679,7 +679,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       if ('error' in selected)
         return refuse('run', args, selected.error, selected.code ?? 'VX_E_USAGE')
       if ('empty' in selected) {
-        process.stderr.write(`vx run: ${selected.empty}\n`)
+        sayNotice('info', 'vx run', selected.empty)
         return 0
       }
       only = new Set(selected.names)
@@ -695,7 +695,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   const resolved = await resolveRunOptions(parsed, cwd, tasks, 'run', scopeOut)
   if ('error' in resolved) return refuse('run', args, resolved.error, resolved.code ?? 'VX_E_USAGE')
   if ('nothingSelected' in resolved) {
-    process.stderr.write(`vx run: ${resolved.nothingSelected}\n`)
+    sayNotice('info', 'vx run', resolved.nothingSelected)
     return 0
   }
   const opts = resolved
@@ -715,8 +715,10 @@ export async function runCmd(args: readonly string[]): Promise<number> {
   if (parsed.dry !== undefined || parsed.graph !== undefined) {
     const plan = await planRun(opts)
     if (plan.unresolvedTasks !== undefined && plan.unresolvedTasks.length > 0) {
-      process.stderr.write(
-        `vx run: no projects declare task(s): ${plan.unresolvedTasks.join(', ')}.${plan.unresolvedHint ?? ''}\n`,
+      sayNotice(
+        'error',
+        'vx run',
+        `no projects declare task(s): ${plan.unresolvedTasks.join(', ')}.${plan.unresolvedHint ?? ''}`,
       )
       return 1
     }
@@ -724,14 +726,14 @@ export async function runCmd(args: readonly string[]): Promise<number> {
       // The run's own line: a dry run that guessed from the scope alone
       // said no affected project declared a task one did (X-141).
       if (plan.noneAffected !== undefined) {
-        process.stderr.write(`${plan.noneAffected}\n`)
+        sayLine('info', plan.noneAffected, 'vx run')
         return 0
       }
       if (opts.selectedByDiff === true) {
-        process.stderr.write(`vx run: no affected project declares task(s): ${tasks.join(', ')}.\n`)
+        sayNotice('info', 'vx run', `no affected project declares task(s): ${tasks.join(', ')}`)
         return 0
       }
-      process.stderr.write(`vx run: no projects declare task(s): ${tasks.join(', ')}.\n`)
+      sayNotice('error', 'vx run', `no projects declare task(s): ${tasks.join(', ')}`)
       return 1
     }
     if (parsed.graph !== undefined) {
@@ -747,7 +749,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
           await Bun.write(target, out)
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err)
-          process.stderr.write(`vx run: failed to write graph to ${target}: ${message}\n`)
+          sayNotice('error', 'vx run', `failed to write graph to ${target}: ${message}`)
           return 1
         }
       }
@@ -813,7 +815,7 @@ export async function runCmd(args: readonly string[]): Promise<number> {
         // Same contract as --summarize / --profile: the run already
         // happened, so a write failure is reported, not fatal.
         const message = err instanceof Error ? err.message : String(err)
-        process.stderr.write(`vx: failed to write report to ${target}: ${message}\n`)
+        sayNotice('warn', 'vx run', `failed to write report to ${target}: ${message}`)
       }
     }
   }

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
     }