@vzn/vx 0.0.637 → 0.0.638

package/src/cache/run-history.ts

@@ -34,6 +34,31 @@ const RUNS_PER_INSERT = 40
 /** Rows per `task_durations` INSERT: 6 variables each, under 999. */
 const DURATIONS_PER_INSERT = 160
 
+/** Rows per `task_outcomes` INSERT: 6 variables each, under 999. */
+const OUTCOMES_PER_INSERT = 160
+
+/**
+ * Whether a run says anything of its key, so the flaky record may keep it:
+ * keyed, cached, and not run behind a failure (its bytes were not the key's).
+ */
+const keyed = (r: RunRecord): boolean =>
+  r.hash !== undefined && r.hash !== '' && r.cached !== false && r.blockedBy == null
+
+/** A hit, as the orchestrator marks one (`isCacheHit`, run-records.ts). */
+const isHit = (r: RunRecord): boolean => r.cacheHit === true
+
+/**
+ * Of a JSON array of hashes, those the record holds a pass of: one index
+ * probe each (0.6 ms for 1,000; a join reading every row of each key was
+ * 5.7 ms at 20 runs of history). A hit's row is kept only when its key has
+ * none: a hit replays a pass, and the first is what a later failure
+ * relapses from (an entry adopted from its artifact, or older than the
+ * record, has no executed row). By hash alone, as the entry it replays is.
+ */
+const PASSED_HASHES = `
+      SELECT j.value AS hash FROM json_each(?) AS j
+      WHERE EXISTS (SELECT 1 FROM task_outcomes AS o WHERE o.hash = j.value AND o.status <> 'failed')`
+
 /** A local run's `task_durations.source`: its branch, `''` when it had none. */
 export const branchSource = (branch: string | null): string => `branch:${branch ?? ''}`
 
@@ -75,6 +100,7 @@ export class RunHistory {
       .transaction(() => {
         this.insertRuns(runs)
         this.insertDurations(runs, branchSource(null), null)
+        this.insertOutcomes(runs)
       })
       .immediate()
   }
@@ -94,6 +120,45 @@ export class RunHistory {
     }
   }
 
+  /**
+   * The flaky record's rows: every executed outcome, and a key's first hit,
+   * in the order given (a batch may hold one key's history).
+   */
+  private insertOutcomes(runs: readonly RunRecord[]): void {
+    const rows = runs.filter(
+      (r) => keyed(r) && (isHit(r) || r.status === 'success' || r.status === 'failed'),
+    )
+    const hits = rows.filter(isHit)
+    let passed: Set<string> | undefined
+    if (hits.length > 0) {
+      const found = this.db.query(PASSED_HASHES).all(JSON.stringify(hits.map((r) => r.hash))) as {
+        hash: string
+      }[]
+      passed = new Set(found.map((f) => f.hash))
+    }
+    const kept: RunRecord[] = []
+    for (const r of rows) {
+      if (isHit(r)) {
+        if (passed!.has(r.hash!)) continue
+        passed!.add(r.hash!)
+      } else if (r.status === 'success') {
+        passed?.add(r.hash!)
+      }
+      kept.push(r)
+    }
+    for (let i = 0; i < kept.length; i += OUTCOMES_PER_INSERT) {
+      const block = kept.slice(i, i + OUTCOMES_PER_INSERT)
+      const params: SQLQueryBindings[] = []
+      for (const r of block)
+        params.push(r.project, r.task, r.hash!, r.status, r.attempts ?? null, r.startedAt)
+      this.db
+        .query(
+          `INSERT INTO task_outcomes(project, task, hash, status, attempts, recorded_at) VALUES ${Array(block.length).fill('(?, ?, ?, ?, ?, ?)').join(', ')}`,
+        )
+        .run(...params)
+    }
+  }
+
   /** `runs` as few INSERTs; each distinct forward-args list digested once. */
   private insertRuns(runs: readonly RunRecord[]): void {
     const digests = new Map<string, string>()
@@ -134,6 +199,7 @@ export class RunHistory {
           branchSource(bundle.invocation.branch),
           bundle.invocation.commitSha,
         )
+        this.insertOutcomes(bundle.runs)
       })
       .immediate()
   }
@@ -149,6 +215,8 @@ export class RunHistory {
     this.db.prepare('DELETE FROM runs WHERE started_at < ?').run(cutoff)
     this.db.prepare('DELETE FROM invocations WHERE started_at < ?').run(cutoff)
     this.db.prepare('DELETE FROM task_durations WHERE recorded_at < ?').run(cutoff)
+    this.db.prepare('DELETE FROM task_outcomes WHERE recorded_at < ?').run(cutoff)
+    this.db.prepare('DELETE FROM plugin_blobs WHERE at < ?').run(cutoff)
   }
 }
 

package/src/cache/run-store.ts

@@ -0,0 +1,77 @@
+// What core keeps of a run that writes a remote (owner 2026-10-15): a failed
+// task's log and the files its outputs left, an uncached task's log. Names
+// come from the run id and task (`run/<id>/<task>/log`); each key is derived
+// in a namespace no task key or plugin entry shares. Remote only: locally
+// `vx last --log` and the working tree already hold them. No size cap (M:
+// the cache is free). Plugins read them by name (`ctx.cache.getRun`).
+
+import { xxh3hex } from '../util/index.js'
+import type { PluginCacheRemote } from './plugin-cache.js'
+import { scopedKey } from './scoped-cache.js'
+import { tarPackInto, tarSize } from './tar-stream.js'
+
+/** The name core stores a task's `part` of run `runId` under. */
+export function runEntryName(runId: string, taskId: string, part: 'log' | 'outputs'): string {
+  return `run/${runId}/${taskId}/${part}`
+}
+
+const runKey = (name: string): string => xxh3hex(`vx-run\0${name}`)
+
+/** The keys `name` is read under: the default, then the scope's, as tasks read. */
+export function runReadKeys(name: string, scope: string | undefined): string[] {
+  const key = runKey(name)
+  return scope === undefined ? [key] : [key, scopedKey(scope, key)]
+}
+
+/** Whether some remote takes this run's writes: only then does core keep run bytes. */
+export function writesRunStore(remotes: readonly PluginCacheRemote[]): boolean {
+  return remotes.some((r) => r.write)
+}
+
+/**
+ * Store `bytes` under `name` in every remote the policy writes. An entry is
+ * written once; a remote's failure leaves the others theirs, silently: what
+ * a run keeps here is a record, never its verdict.
+ */
+export async function putRunEntry(
+  remotes: readonly PluginCacheRemote[],
+  scope: string | undefined,
+  name: string,
+  bytes: Uint8Array,
+): Promise<boolean> {
+  const key = scope === undefined ? runKey(name) : scopedKey(scope, runKey(name))
+  let kept = false
+  for (const { remote, write } of remotes) {
+    if (!write) continue
+    try {
+      if (!(await remote.has(key))) await remote.put(key, new Blob([bytes]), { durationMs: 0 })
+      kept = true
+    } catch {
+      // the other remotes still keep it
+    }
+  }
+  return kept
+}
+
+/**
+ * The files at `paths` (workspace-relative) as a plain ustar archive, names
+ * as given, so any `tar` reads it; null when none is left to read.
+ */
+export async function packRunOutputs(
+  workspaceRoot: string,
+  paths: readonly string[],
+): Promise<Uint8Array | null> {
+  const inputs: { name: string; size: number; body: Uint8Array }[] = []
+  for (const name of paths) {
+    try {
+      const body = await Bun.file(`${workspaceRoot}/${name}`).bytes()
+      inputs.push({ name, size: body.byteLength, body })
+    } catch {
+      // gone since the glob: nothing to keep
+    }
+  }
+  if (inputs.length === 0) return null
+  const out = new Uint8Array(tarSize(inputs))
+  tarPackInto(inputs, out)
+  return out
+}

package/src/cache/schema.ts

@@ -23,7 +23,8 @@ export function lazyStatement(db: Database, sql: string): ReturnType<Database['p
 /**
  * Create every table. `store` names the schema holding the ENTRY tables
  * (`entries`, `entry_stdout`, `output_files`, `entry_inputs`, `store_meta`)
- * and the task timings (`task_durations`):
+ * the task timings (`task_durations`), the flaky record (`task_outcomes`),
+ * the blob sizes (`blob_sizes`) and the plugins' blobs (`plugin_blobs`):
  * `main` when one `cache.db` holds everything (a `cacheDir`), `store` when
  * they live in the shared store attached beside it (v32). The rest is the
  * workspace's own: its history, its memos, and what its disk looked like
@@ -114,17 +115,14 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
     --   runs_ended (2026-09-09) served only the retention DELETE, which
     --     prunes on started_at now (a row ends after it starts, so the
     --     30-day window moves by at most one task's duration).
+    --   runs_failed (v38) served the flakiness probe, which reads the
+    --     store's task_outcomes now.
     DROP INDEX IF EXISTS main.runs_hash;
     DROP INDEX IF EXISTS main.runs_project;
     DROP INDEX IF EXISTS main.runs_ended;
+    DROP INDEX IF EXISTS main.runs_failed;
     CREATE INDEX IF NOT EXISTS main.runs_started_at ON runs(started_at);
     CREATE INDEX IF NOT EXISTS main.runs_run_id     ON runs(run_id);
-    -- The one keyed index, PARTIAL over failed rows: a green run's
-    -- inserts only evaluate its predicate, so the append-only cost above
-    -- holds, and the flakiness probe after a miss (failure-mode.ts,
-    -- "did this key ever fail?") reads a handful of leaves instead of
-    -- scanning the table (2026-09-10: 10–95 ms at 170k rows without it).
-    CREATE INDEX IF NOT EXISTS main.runs_failed ON runs(hash) WHERE status = 'failed';
     -- Per-file (mtime, size, content_hash) cache. Lets Cache.key()
     -- skip the content-hash on inputs whose stat hasn't changed
     -- since the last run. Pure performance optimization; the stored
@@ -142,8 +140,9 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
     -- The size of each index blob the enumeration checked against the
     -- worktree size git recorded (A-60). Fixed for its OID, so a warm
     -- run asks git for none; swept with file_hashes by seen_at, the
-    -- time the row was written.
-    CREATE TABLE IF NOT EXISTS main.blob_sizes (
+    -- time the row was written. v38: in the store, so a worktree reads
+    -- what another learned (owner, 2026-10-14).
+    CREATE TABLE IF NOT EXISTS ${store}.blob_sizes (
       oid     TEXT PRIMARY KEY,
       size    INTEGER NOT NULL,
       seen_at INTEGER NOT NULL
@@ -275,6 +274,36 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
     );
     CREATE INDEX IF NOT EXISTS ${store}.task_durations_task
       ON task_durations(project, task, source, id);
+    -- v37: a 'remote' row is a default-branch commit's timing a plugin
+    -- imported (\`sha\` that commit): one per task, so a repeat import is a
+    -- no-op under INSERT OR IGNORE.
+    CREATE UNIQUE INDEX IF NOT EXISTS ${store}.task_durations_remote
+      ON task_durations(sha, project, task) WHERE source = 'remote';
+    -- v38: the flaky record (orchestrator/failure-mode.ts): each keyed,
+    -- cached, unblocked outcome that observed its key, shared by every
+    -- worktree so a key that passed in one and failed in another is flaky
+    -- in both (owner, 2026-10-14). Every executed success or failure, and
+    -- a key's first hit (run-history.ts): a later hit replays a pass the
+    -- record holds, so a warm run on keys that passed writes no row.
+    -- Append-only, ordered by id, pruned by age with the run history.
+    CREATE TABLE IF NOT EXISTS ${store}.task_outcomes (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      project     TEXT NOT NULL,
+      task        TEXT NOT NULL,
+      hash        TEXT NOT NULL,
+      status      TEXT NOT NULL,
+      attempts    INTEGER,
+      recorded_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS ${store}.task_outcomes_hash ON task_outcomes(hash, status);
+    -- v37: what a plugin keeps through \`ctx.cache\` (plugin-cache.ts), by
+    -- its namespaced key. Written once, never updated; pruned by age with
+    -- the run history.
+    CREATE TABLE IF NOT EXISTS ${store}.plugin_blobs (
+      key   TEXT PRIMARY KEY,
+      bytes BLOB NOT NULL,
+      at    INTEGER NOT NULL
+    );
     ${artifactTables(store)}
   `)
 }

package/src/cache/scoped-cache.ts

@@ -16,7 +16,7 @@ import type {
 } from './layer.js'
 
 /** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
-function scopedKey(scope: string, hash: string): string {
+export function scopedKey(scope: string, hash: string): string {
   return xxh3hex(`vx-cache-scope\0${scope}\0${hash}`)
 }
 
@@ -75,6 +75,13 @@ export class ScopedCache implements CacheLayer {
     return out
   }
 
+  /** A task key the store holds under the default key or the scope's. */
+  async localHasMany(hashes: readonly string[]): Promise<Set<string>> {
+    const held = await this.inner.localHasMany?.([...hashes, ...hashes.map((h) => this.own(h))])
+    if (held === undefined) return new Set()
+    return new Set(hashes.filter((h) => held.has(h) || held.has(this.own(h))))
+  }
+
   private async scopedHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
     const scoped = hashes.map((h) => this.own(h))
     const [plain, own] = await Promise.all([
@@ -105,7 +112,13 @@ export class ScopedCache implements CacheLayer {
   }
 
   async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
-    for (const key of [hash, this.own(hash)]) {
+    // The scope's key first when only it is local: the default key's
+    // remote GET would cost a round-trip for the same inputs.
+    const own = this.own(hash)
+    const keys = (await this.inner.localHasMany?.([hash, own]))?.has(own)
+      ? [own, hash]
+      : [hash, own]
+    for (const key of keys) {
       const entry = await this.inner.get(key, ctx)
       if (entry === null) continue
       this.served.set(hash, key)

package/src/cli/cache.ts

@@ -3,7 +3,15 @@ import { homedir } from 'node:os'
 import path from 'node:path'
 import { Cache, vxCacheEntries } from '../cache/index.js'
 import { flagHint, formatValue, refuse, refusedWord, seeHelp } from './help.js'
-import { errorCode, nearest, parseDuration, parseSize, relPosix, treeBytes } from '../util/index.js'
+import {
+  errorCode,
+  nearest,
+  parseDuration,
+  parseSize,
+  relPosix,
+  treeBytes,
+  ui,
+} from '../util/index.js'
 import { acquireRunLock } from '../orchestrator/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import {
@@ -254,15 +262,28 @@ function printPruned(
     )
     return
   }
-  const orphans =
-    result.orphans > 0
-      ? `, ${dry ? 'would reap' : 'reaped'} ${result.orphans} orphaned artifact${result.orphans === 1 ? '' : 's'} (${formatBytes(result.orphanBytes)})`
-      : ''
-  process.stdout.write(
-    `${dry ? 'Would prune' : 'Pruned'} ${result.evicted} entr${result.evicted === 1 ? 'y' : 'ies'} (${formatBytes(result.bytesFreed)}${dry ? '' : ' freed'})${orphans}\n`,
+  const plural = (n: number, one: string, many: string): string => `${n} ${n === 1 ? one : many}`
+  const facts = [
+    ...(result.evicted > 0 ? [plural(result.evicted, 'entry', 'entries')] : []),
+    ...(result.orphans > 0
+      ? [plural(result.orphans, 'orphaned artifact', 'orphaned artifacts')]
+      : []),
+  ]
+  ui.print(
+    'out',
+    freedStatus(dry, result.bytesFreed + result.orphanBytes, facts.length > 0),
+    ...(facts.length > 0 ? [ui.text(facts.join(' · '))] : []),
   )
 }
 
+/** `✓ vx cache clean  freed 1.3 GB`, `› … would free 1.3 GB (dry run)`, or nothing to free. */
+function freedStatus(dry: boolean, bytes: number, any: boolean): ui.Block {
+  if (!any) return ui.status('info', 'vx cache clean', `nothing to free${dry ? ' (dry run)' : ''}`)
+  return dry
+    ? ui.status('info', 'vx cache clean', `would free ${formatBytes(bytes)} (dry run)`)
+    : ui.status('ok', 'vx cache clean', `freed ${formatBytes(bytes)}`)
+}
+
 /** `vx cache clean --format json` with no bound (schemas/cache.json `clear`). */
 export interface ClearResult {
   dryRun: boolean
@@ -341,16 +362,12 @@ async function clear(
   if (parsed.format === 'json') {
     const result: ClearResult = { dryRun: dry, cleared: shown, bytesFreed: bytes }
     process.stdout.write(`${JSON.stringify(result)}\n`)
-  } else if (shown.length === 0) process.stdout.write('Nothing to clear: no cache here\n')
-  else {
-    const scope =
-      parsed.global === true
-        ? "every repository's store and this workspace's run history"
-        : "this repository's store, shared by its checkouts, and this workspace's run history"
-    process.stdout.write(
-      `${dry ? 'Would clear' : 'Cleared'} ${scope} (${formatBytes(bytes)}${dry ? '' : ' freed'}):\n${shown.map((t) => `  ${t}\n`).join('')}`,
+  } else
+    ui.print(
+      'out',
+      freedStatus(dry, bytes, shown.length > 0),
+      ...(shown.length > 0 ? [ui.text(...shown)] : []),
     )
-  }
   return 0
 }
 

package/src/cli/completions.ts

@@ -6,7 +6,7 @@
 // Tab is the wrong price).
 
 import { acceptedFlags, CORE_VERBS, flagHint, seeHelp } from './help.js'
-import { nearest } from '../util/index.js'
+import { nearest, sayNotice } from '../util/index.js'
 
 /** A flag whose value is one of a fixed set; the tests hold each to its parser. */
 export const FLAG_VALUES: Readonly<Record<string, readonly string[]>> = {
@@ -139,8 +139,10 @@ export async function completionsCmd(
   if (args.length !== 1 || !(SHELLS as readonly string[]).includes(shell ?? '')) {
     const flag = args.find((a) => a.startsWith('-'))
     if (flag !== undefined) {
-      process.stderr.write(
-        `vx completions: unknown flag: ${flag}${flagHint('completions', flag)}${seeHelp('completions')}\n`,
+      sayNotice(
+        'error',
+        'vx completions',
+        `unknown flag: ${flag}${flagHint('completions', flag)}${seeHelp('completions')}`,
       )
       return 1
     }
@@ -148,8 +150,10 @@ export async function completionsCmd(
     // One edit: shell names are three or four letters, so two edits took
     // `tcsh` to `bash`, a different shell.
     const best = one ? nearest(shell, SHELLS, 1) : undefined
-    process.stderr.write(
-      `vx completions: expected one shell — bash, zsh or fish${one ? ` (got ${shell})` : ''}${best === undefined ? '' : `. Did you mean ${best}?`}${seeHelp('completions')}\n`,
+    sayNotice(
+      'error',
+      'vx completions',
+      `expected one shell — bash, zsh or fish${one ? ` (got ${shell})` : ''}${best === undefined ? '' : `. Did you mean ${best}?`}${seeHelp('completions')}`,
     )
     return 1
   }

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
@@ -445,7 +452,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

@@ -8,7 +8,7 @@ import { collectInfo, type FlakyTask, type InfoFacts } from '../orchestrator/ind
 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 +55,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 +124,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
 }