@vzn/vx 0.0.649 → 0.0.651

package/src/cache/remote-hits.ts

@@ -12,7 +12,15 @@ export interface RemoteHit {
   readonly durationMs?: number
 }
 
-export class RemoteHits {
+/** What a layered cache asks of the remote-hit rows; the rows stay core's (`IndexRemoteHits`). */
+export interface RemoteHits {
+  /** The keys of `hashes` a remote last said it holds. */
+  get(hashes: readonly string[]): Map<string, RemoteHit>
+  record(asked: readonly string[], found: ReadonlyMap<string, RemoteHit>, now?: number): void
+  forget(hash: string): void
+}
+
+export class IndexRemoteHits implements RemoteHits {
   constructor(
     private readonly db: Database,
     /** Off for a reading verb or an index this user cannot write. */

package/src/cache/remote-lane.ts

@@ -4,7 +4,8 @@
 // class with the endpoint named. The order across remotes, the local store
 // and provenance are `LayeredCache`'s; nothing here knows another remote.
 
-import { machineParallelism, thrownMessage, ui } from '../util/index.js'
+import { machineParallelism, thrownMessage } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
 import type { ArtifactInfo, RemoteCacheLayer } from './layered-cache.js'
 

package/src/cache/run-history.ts

@@ -41,6 +41,11 @@ const RUN_COLUMNS = [
   'keyless_by',
   'def',
   'cpu_share',
+  'queued_ms',
+  'output_bytes',
+  'blocks',
+  'flaky_passes',
+  'flaky_failures',
 ]
 
 const INSERT_RUNS = `INSERT INTO runs(${RUN_COLUMNS.join(', ')}) VALUES `
@@ -282,7 +287,7 @@ export class RunHistory {
   }
 }
 
-/** Bind a RunRecord to one `RUN_TUPLE`'s 29 positional parameters. */
+/** Bind a RunRecord to one `RUN_TUPLE`'s positional parameters, in `RUN_COLUMNS` order. */
 function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBindings[] {
   return [
     // The ONE place the no-key sentinel is applied, so the column's
@@ -321,6 +326,11 @@ function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBi
     run.keylessBy ?? null,
     run.def ?? null,
     run.cpuShare ?? null,
+    run.queuedMs ?? null,
+    run.outputBytes ?? null,
+    run.blocks ?? null,
+    run.flakyPasses ?? null,
+    run.flakyFailures ?? null,
   ]
 }
 

package/src/cache/run-notes.ts

@@ -0,0 +1,123 @@
+// What a run said that its `runs` rows do not hold, for `vx last`: the steps
+// it did not wait on (`vx:prefetch`, 2026-10-16), which never show in a
+// run's output; its warnings, which scroll past on a terminal (an agent
+// reading the run afterwards saw only the footer's count, 2026-10-28); and
+// each failed task's output and the files it names. Rows of cache.db's
+// `steps`, `warnings` and `failures` (v50; files under the cache dir
+// before), so `vx last --sql` reads them too. The newest `KEPT` runs that
+// had any are kept, per table. A run with none writes nothing.
+
+import type { Database } from 'bun:sqlite'
+
+/** Runs whose steps, warnings or failures are kept; run ids are UUIDv7, so they sort by age. */
+const KEPT = 50
+
+/** One of vx's own steps that ran beside the tasks. */
+export interface RunStep {
+  id: string
+  durationMs: number
+  ok: boolean
+}
+
+/** A failed task's kept output: plain, bounded, secrets masked. */
+export interface KeptFailure {
+  taskId: string
+  inputMoved?: string
+  output: string
+  locations: readonly unknown[]
+  sandboxFix?: unknown
+}
+
+export interface RunNotes {
+  readonly steps?: readonly RunStep[]
+  readonly warnings?: readonly string[]
+  readonly failures?: readonly KeptFailure[]
+}
+
+/** Drop every row of `table` older than its newest `KEPT` runs. */
+function trim(db: Database, table: 'steps' | 'warnings' | 'failures'): void {
+  db.query(
+    `DELETE FROM ${table} WHERE run_id < (SELECT run_id FROM (SELECT DISTINCT run_id FROM ${table} ORDER BY run_id DESC LIMIT 1 OFFSET ${KEPT - 1}))`,
+  ).run()
+}
+
+/** Write `notes` for `runId` in one transaction, then keep the newest `KEPT` runs of each table written. */
+export function keepRunNotes(db: Database, runId: string, notes: RunNotes): void {
+  const steps = notes.steps ?? []
+  const warnings = notes.warnings ?? []
+  const failures = notes.failures ?? []
+  if (steps.length + warnings.length + failures.length === 0) return
+  db.transaction(() => {
+    if (steps.length > 0) {
+      const insert = db.query(
+        'INSERT OR REPLACE INTO steps(run_id, seq, step, duration_ms, ok) VALUES (?, ?, ?, ?, ?)',
+      )
+      steps.forEach((s, i) => insert.run(runId, i, s.id, Math.round(s.durationMs), s.ok ? 1 : 0))
+      trim(db, 'steps')
+    }
+    if (warnings.length > 0) {
+      const insert = db.query('INSERT OR REPLACE INTO warnings(run_id, seq, text) VALUES (?, ?, ?)')
+      warnings.forEach((w, i) => insert.run(runId, i, w))
+      trim(db, 'warnings')
+    }
+    if (failures.length > 0) {
+      const insert = db.query(
+        `INSERT OR REPLACE INTO failures(run_id, task_id, input_moved, output, locations, sandbox_fix)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+      )
+      for (const f of failures) {
+        insert.run(
+          runId,
+          f.taskId,
+          f.inputMoved ?? null,
+          f.output,
+          JSON.stringify(f.locations),
+          f.sandboxFix === undefined ? null : JSON.stringify(f.sandboxFix),
+        )
+      }
+      trim(db, 'failures')
+    }
+  }).immediate()
+}
+
+/** The background steps `runId` kept, in the order they ended; none when it had none. */
+export function keptSteps(db: Database, runId: string): RunStep[] {
+  const rows = db
+    .query('SELECT step, duration_ms, ok FROM steps WHERE run_id = ? ORDER BY seq')
+    .all(runId) as { step: string; duration_ms: number; ok: number }[]
+  return rows.map((r) => ({ id: r.step, durationMs: r.duration_ms, ok: r.ok === 1 }))
+}
+
+/** The warnings `runId` said, colour stripped; none when it said none. */
+export function keptWarnings(db: Database, runId: string): string[] {
+  const rows = db.query('SELECT text FROM warnings WHERE run_id = ? ORDER BY seq').all(runId) as {
+    text: string
+  }[]
+  return rows.map((r) => r.text)
+}
+
+/** What `runId` kept of its failed tasks, by task id; empty when it kept none. */
+export function keptFailures(db: Database, runId: string): Map<string, KeptFailure> {
+  const rows = db
+    .query(
+      'SELECT task_id, input_moved, output, locations, sandbox_fix FROM failures WHERE run_id = ?',
+    )
+    .all(runId) as {
+    task_id: string
+    input_moved: string | null
+    output: string
+    locations: string
+    sandbox_fix: string | null
+  }[]
+  const kept = new Map<string, KeptFailure>()
+  for (const r of rows) {
+    kept.set(r.task_id, {
+      taskId: r.task_id,
+      ...(r.input_moved !== null ? { inputMoved: r.input_moved } : {}),
+      output: r.output,
+      locations: JSON.parse(r.locations) as unknown[],
+      ...(r.sandbox_fix !== null ? { sandboxFix: JSON.parse(r.sandbox_fix) as unknown } : {}),
+    })
+  }
+  return kept
+}

package/src/cache/schema.ts

@@ -119,7 +119,17 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       def                 TEXT,
       -- v49: the share of a core each runnable thread got where it ran
       -- (ExecuteResult.machine.cpuShare); NULL = all it wanted.
-      cpu_share           REAL
+      cpu_share           REAL,
+      -- v51: the rest of the results row. How long the task waited ready
+      -- for a slot (NULL: it started at once); its output files' bytes,
+      -- uncompressed (a hit's restored, a miss's saved; NULL: no entry);
+      -- the tasks downstream of it in the run; the flaky record its note
+      -- quoted (NULL: not proven flaky).
+      queued_ms           INTEGER,
+      output_bytes        INTEGER,
+      blocks              INTEGER,
+      flaky_passes        INTEGER,
+      flaky_failures      INTEGER
     );
     -- Two whole-table indexes only, and both APPEND: every row of a run carries the
     -- same run_id and a started_at newer than everything before it, so
@@ -261,6 +271,49 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       arch              TEXT,
       vx_version        TEXT NOT NULL
     );
+    -- v50: what a run said that its runs rows do not hold (run-notes.ts),
+    -- for \`vx last\`: the steps it did not wait on (\`vx:prefetch\`), its
+    -- warnings, colour stripped, and each failed task's output, plain,
+    -- bounded and masked, with the files it names (JSON). Rows of the
+    -- newest 50 runs that had any; run ids are UUIDv7, so they sort by age.
+    CREATE TABLE IF NOT EXISTS main.steps (
+      run_id      TEXT NOT NULL,
+      seq         INTEGER NOT NULL,
+      step        TEXT NOT NULL,
+      duration_ms INTEGER NOT NULL,
+      ok          INTEGER NOT NULL,
+      PRIMARY KEY (run_id, seq)
+    );
+    CREATE TABLE IF NOT EXISTS main.warnings (
+      run_id TEXT NOT NULL,
+      seq    INTEGER NOT NULL,
+      text   TEXT NOT NULL,
+      PRIMARY KEY (run_id, seq)
+    );
+    CREATE TABLE IF NOT EXISTS main.failures (
+      run_id      TEXT NOT NULL,
+      task_id     TEXT NOT NULL,
+      input_moved TEXT,
+      output      TEXT NOT NULL,
+      locations   TEXT NOT NULL,
+      sandbox_fix TEXT,
+      PRIMARY KEY (run_id, task_id)
+    );
+    -- v50: a lockfile claimant's parse (orchestrator/lockfile-claim.ts): one
+    -- row per lockfile and claimant, read while \`version\` and \`lock\` (the
+    -- file's xxh3) match, replaced when they do not. JSON: the extra files'
+    -- hashes, the importers' digests and edges, the names each records.
+    CREATE TABLE IF NOT EXISTS main.lockfile_memos (
+      file      TEXT NOT NULL,
+      claimant  TEXT NOT NULL,
+      version   INTEGER NOT NULL,
+      lock      TEXT NOT NULL,
+      extras    TEXT NOT NULL,
+      importers TEXT NOT NULL,
+      edges     TEXT NOT NULL,
+      recorded  TEXT,
+      PRIMARY KEY (file, claimant)
+    );
     CREATE INDEX IF NOT EXISTS main.invocations_started ON invocations(started_at);
     CREATE INDEX IF NOT EXISTS main.invocations_branch  ON invocations(branch);
     CREATE INDEX IF NOT EXISTS main.invocations_ci      ON invocations(ci);

package/src/cli/cache.ts

@@ -11,8 +11,8 @@ import {
   parseSize,
   relPosix,
   treeBytes,
-  ui,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import { acquireRunLock } from '../orchestrator/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
 import {
@@ -270,9 +270,7 @@ function printPruned(
 ): void {
   if (json) {
     const { evicted, bytesFreed, orphans, orphanBytes } = result
-    process.stdout.write(
-      `${JSON.stringify({ dry: dry, evicted, bytesFreed, orphans, orphanBytes })}\n`,
-    )
+    ui.data('out', `${JSON.stringify({ dry: dry, evicted, bytesFreed, orphans, orphanBytes })}\n`)
     return
   }
   const plural = (n: number, one: string, many: string): string => `${n} ${n === 1 ? one : many}`
@@ -321,6 +319,25 @@ async function clear(
   storeRoot: string | null,
   parsed: PruneArgs,
 ): Promise<number> {
+  // A clear beside a run deletes what the run is restoring or saving; it
+  // waits for the run's lock, as a trim does, and only then reads what to
+  // delete: read first, what the run saved meanwhile went uncounted.
+  const release =
+    parsed.dry === true ? async () => {} : await acquireRunLock(root, { log: warnToStderr })
+  try {
+    return clearHeld(args, root, dir, storeRoot, parsed)
+  } finally {
+    await release()
+  }
+}
+
+function clearHeld(
+  args: readonly string[],
+  root: string,
+  dir: string,
+  storeRoot: string | null,
+  parsed: PruneArgs,
+): number {
   // The store the index recorded and today's (a changed HOME, an origin
   // added) both go; a directory with no index is not a vx cache to delete.
   const targets: string[] = []
@@ -376,23 +393,16 @@ async function clear(
         ? readdirSync(t).map((e) => path.join(t, e))
         : [t]
   const bytes = doomed.reduce((n, t) => n + entries(t).reduce((m, e) => m + treeBytes(e), 0), 0)
-  if (!dry && doomed.length > 0) {
-    // A clear beside a run deletes what the run is restoring or saving; it
-    // waits for the run's lock, as a trim does.
-    const release = await acquireRunLock(root, { log: warnToStderr })
-    try {
-      for (const t of doomed) {
-        for (const e of entries(t)) rmSync(e, { recursive: true, force: true })
-        if (t === named && readdirSync(t).length === 0) rmSync(t, { recursive: true })
-      }
-    } finally {
-      await release()
+  if (!dry) {
+    for (const t of doomed) {
+      for (const e of entries(t)) rmSync(e, { recursive: true, force: true })
+      if (t === named && readdirSync(t).length === 0) rmSync(t, { recursive: true })
     }
   }
   const shown = doomed.map((t) => (path.relative(root, t).startsWith('..') ? t : relPosix(root, t)))
   if (parsed.format === 'json') {
     const result: ClearResult = { dry: dry, cleared: shown, bytesFreed: bytes }
-    process.stdout.write(`${JSON.stringify(result)}\n`)
+    ui.data('out', `${JSON.stringify(result)}\n`)
   } else
     ui.print(
       'out',

package/src/cli/completions.ts

@@ -6,7 +6,9 @@
 // Tab is the wrong price).
 
 import { acceptedFlags, CORE_VERBS, flagHint, refuse, seeHelp } from './help.js'
-import { nearest, sayNotice } from '../util/index.js'
+import { nearest } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import { setting } from '../settings.js'
 
 function enumValues(path: string): readonly string[] {
@@ -167,6 +169,6 @@ export async function completionsCmd(
   const verbs = [...CORE_VERBS.filter((v) => v !== 'help' && v !== 'version'), 'help', 'version']
   // No overlap to skip: the workspace load refuses a plugin verb named like a core one.
   verbs.push(...pluginVerbs)
-  process.stdout.write(completionScript(shell as CompletionShell, verbs))
+  ui.data('out', completionScript(shell as CompletionShell, verbs))
   return 0
 }

package/src/cli/docs.ts

@@ -5,7 +5,8 @@
 // whole, best first.
 
 import { VERSION } from '../version.js'
-import { detectColors, paint, parseDecimalInt, ui } from '../util/index.js'
+import { parseDecimalInt } from '../util/index.js'
+import * as ui from '../ui/index.js'
 import { flagHint, formatValue, refuse, refusedWord, seeHelp } from './help.js'
 
 const SITE = 'https://vznjs.github.io/vx/'
@@ -238,7 +239,7 @@ export async function docsCmd(
   const hits = searchDocs(pages, parsed.terms, parsed.limit)
   const query = parsed.terms.join(' ')
   if (parsed.json) {
-    process.stdout.write(`${JSON.stringify({ query, hits })}\n`)
+    ui.data('out', `${JSON.stringify({ query, hits })}\n`)
     return 0
   }
   if (hits.length === 0) {
@@ -249,15 +250,13 @@ export async function docsCmd(
     )
     return 0
   }
-  const c = detectColors(process.stdout)
-  process.stdout.write(
-    hits
-      .map((h) =>
-        c.enabled
-          ? `${ui.render([ui.excerpt(`${h.page}.md${h.heading === '' ? '' : ` § ${h.heading}`}`, h.text)], c)}${paint('', h.url, c, { dim: true })}\n`
-          : `── ${h.page}.md${h.heading === '' ? '' : ` § ${h.heading}`} · ${h.url}\n\n${h.text}\n`,
-      )
-      .join('\n'),
+  // Each hit an excerpt of the page, its link under it: off colour the
+  // bare markdown, as a pipe copies it.
+  ui.print(
+    'out',
+    ...hits.map((h) =>
+      ui.excerpt(`${h.page}.md${h.heading === '' ? '' : ` § ${h.heading}`} · ${h.url}`, h.text),
+    ),
   )
   return 0
 }

package/src/cli/help.ts

@@ -1,22 +1,15 @@
-import {
-  CORE_VERBS,
-  detectColors,
-  errorDocument,
-  maskedLine,
-  nearest,
-  paint,
-  refusalNotice,
-  ui,
-  wantsJson,
-  type ColorSupport,
-} from '../util/index.js'
+import { CORE_VERBS, errorDocument, maskedLine, nearest, wantsJson } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { detectColors, paint, refusalNotice, type ColorSupport } from '../ui/index.js'
 
 export async function printHelp(
   pluginCommands: readonly string[] = [],
   verb?: string,
 ): Promise<void> {
   const text = verb === undefined ? helpText(pluginCommands) : verbHelpText(verb)
-  process.stdout.write(paintHelp(text, helpColors(process.stdout, detectColors), paint))
+  // The reference a script greps: painted on a terminal only, and strips
+  // back to `text` exactly, so it goes out as written.
+  ui.data('out', paintHelp(text, helpColors(process.stdout, detectColors), paint))
 }
 
 /**
@@ -31,9 +24,6 @@ export function helpColors(
   return { enabled: stream.isTTY === true && detect(stream as NodeJS.WriteStream).enabled }
 }
 
-const VERB = '#06b6d4' // cyan-500 — the orchestrator's accent
-const TERM = '#22d3ee' // cyan-400 — a flag, a selector, an example
-
 /**
  * The reference with ANSI accents, line by line and never reflowed, so the
  * painted text strips back to `text` exactly: section headings bold (their
@@ -48,13 +38,12 @@ export function paintHelp(text: string, colors: ColorSupport, paint: Paint): str
       if (line === '') return line
       if (i === 0) {
         const [name, ...rest] = line.split(' ')
-        return [paint(VERB, name!, colors, { bold: true }), ...rest].join(' ')
+        return [paint('info', name!, colors, true), ...rest].join(' ')
       }
       const heading = /^([A-Z][^:]*?)( \(for [^)]*\))?:$/.exec(line)
       if (heading !== null) {
-        const qualifier =
-          heading[2] === undefined ? '' : paint('', heading[2], colors, { dim: true })
-        return `${paint('', heading[1]!, colors, { bold: true })}${qualifier}${paint('', ':', colors, { bold: true })}`
+        const qualifier = heading[2] === undefined ? '' : paint('muted', heading[2], colors)
+        return `${paint('strong', heading[1]!, colors)}${qualifier}${paint('strong', ':', colors)}`
       }
       // `  term   description`: a term is a flag, a `vx` form, a selector.
       const row = /^(\s+)(\S(?:.*?\S)?)(\s{2,}\S.*)?$/.exec(line)
@@ -66,11 +55,11 @@ export function paintHelp(text: string, colors: ColorSupport, paint: Paint): str
         if (description === '' && !(CORE_VERBS as readonly string[]).includes(verb)) return line
         const head = `vx ${verb}`
         const tail = term!.slice(head.length)
-        return `${indent}${paint(VERB, head, colors, { bold: true })}${tail === '' ? '' : paint(TERM, tail, colors)}${description}`
+        return `${indent}${paint('info', head, colors, true)}${tail === '' ? '' : paint('term', tail, colors)}${description}`
       }
       if (description === '') return line
       if (/^(-|\(|[\w-]+#)/.test(term!))
-        return `${indent}${paint(TERM, term!, colors)}${description}`
+        return `${indent}${paint('term', term!, colors)}${description}`
       return line
     })
     .join('\n')
@@ -475,7 +464,7 @@ export function refuse(
 ): number {
   const line = `vx ${verb}: ${message}`
   ui.print('err', refusalNotice(`vx ${verb}`, message))
-  if (wantsJson(args)) process.stdout.write(errorDocument(code, maskedLine(line)))
+  if (wantsJson(args)) ui.data('out', errorDocument(code, maskedLine(line)))
   return 1
 }
 

package/src/cli/index.ts

@@ -5,21 +5,19 @@ import { VERSION } from '../version.js'
 import { checkSettingsEnv } from '../settings.js'
 import { CORE_VERBS, flagHint, printHelp, refuse, refusedWord, seeHelp } from './help.js'
 import {
-  detectColors,
   errorDocument,
   hideEnvFromTasks,
-  sayNotice,
   isFsRefusal,
   isOutOfFds,
   isUserError,
   maskedLine,
   nearest,
-  refusalNotice,
   thrownMessage,
-  ui,
   UserError,
   wantsJson,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice, refusalNotice } from '../ui/index.js'
 
 // Every verb is imported when invoked, `run` included, and so is the
 // plugin-verb lookup: each pulls in the orchestrator and the workspace
@@ -163,9 +161,7 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         )
       }
       // Painted, and the same words piped: a script reads `vx <version>`.
-      process.stdout.write(
-        `${ui.inline([ui.cmd('vx'), ' ', ui.tone('info', VERSION)], detectColors(process.stdout))}\n`,
-      )
+      ui.print('out', ui.line(ui.cmd('vx'), ' ', ui.tone('info', VERSION)))
       return 0
     }
     case 'run':
@@ -238,8 +234,7 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
       ): number => {
         sayNotice(tone, 'vx', text.replace(/^vx: /, '').trimEnd())
         // `vx --format json` puts the flag where the verb goes.
-        if (wantsJson([command, ...rest]))
-          process.stdout.write(errorDocument(code, maskedLine(json)))
+        if (wantsJson([command, ...rest])) ui.data('out', errorDocument(code, maskedLine(json)))
         return 1
       }
       const loadNote =

package/src/cli/info.ts

@@ -9,7 +9,9 @@ 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 { detectColors, MIN_BUN, ui, type ColorSupport } from '../util/index.js'
+import { MIN_BUN } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { type ColorSupport } from '../ui/index.js'
 import { envName } from '../settings.js'
 
 interface InfoArgs {
@@ -55,15 +57,18 @@ export async function infoCmd(args: readonly string[]): Promise<number> {
     ...(parsed.cacheDir !== undefined ? { cacheDir: parsed.cacheDir } : {}),
     warn: warnToStderr,
   })
-  process.stdout.write(
-    parsed.format === 'json'
-      ? `${JSON.stringify(facts)}\n`
-      : `${renderInfo(facts, detectColors(process.stdout))}\n`,
-  )
+  if (parsed.format === 'json') ui.data('out', `${JSON.stringify(facts)}\n`)
+  else ui.print('out', infoReport(facts))
   return 0
 }
 
+/** `vx info` as text: the report's lines for `colors`. */
 export function renderInfo(f: InfoFacts, colors: ColorSupport = { enabled: false }): string {
+  return infoReport(f).lines(colors).join('\n')
+}
+
+/** The `vx info` report: one field a fact. */
+function infoReport(f: InfoFacts): ui.Block {
   const rows: [string, string][] = [
     [
       'vx',
@@ -125,7 +130,7 @@ export function renderInfo(f: InfoFacts, colors: ColorSupport = { enabled: false
       typeof f.lockError === 'string' ? `refused: ${f.lockError}` : f.lockfile ? 'yes' : 'no',
     ],
   ]
-  return ui.report('vx info', rows).lines(colors).join('\n')
+  return ui.report('vx info', rows)
 }
 
 /** `812 (1.2 GB)`, or why the index cannot be read and its fix. */
@@ -195,6 +200,9 @@ function trimCores(n: number): string {
 
 /** `2 — app#test (3 of 7 runs failed on unchanged inputs); api#e2e (1 of 4)`, or `none`. */
 function describeProjects(f: InfoFacts): string {
+  // The count is the lock's: with none read, 0 would say the workspace has no project.
+  if (f.lockError != null) return '— (the lock is refused)'
+  if (!f.lockfile) return '— (no lock: `vx lock`)'
   return `${f.projects} (${f.tasks} task${f.tasks === 1 ? '' : 's'})`
 }
 

package/src/cli/init.ts

@@ -23,17 +23,14 @@ import {
 } from './upgrade.js'
 import { VERSION } from '../version.js'
 import {
-  detectColors,
   DOT_VX_GITATTRIBUTES,
   DOT_VX_GITIGNORE,
-  paint,
   refuseSymlink,
-  sayNotice,
-  SUCCESS,
-  ui,
   UserError,
   writeNoFollow,
 } from '../util/index.js'
+import * as ui from '../ui/index.js'
+import { sayNotice } from '../ui/index.js'
 import {
   findWorkspaceRoot,
   PROJECT_CONFIG_FILENAMES,
@@ -279,8 +276,9 @@ async function install(
     let said = ''
     const decoder = new TextDecoder()
     for await (const chunk of proc.stderr) {
-      process.stderr.write(chunk)
-      said += decoder.decode(chunk, { stream: true })
+      const text = decoder.decode(chunk, { stream: true })
+      ui.data('err', text)
+      said += text
     }
     const code = await proc.exited
     if (code !== 0) {
@@ -351,13 +349,22 @@ async function scaffoldPlugin(seam: string, root: string, args: InitArgs): Promi
   const factory = /^export function (\w+)/m.exec(template.plugin)![1]!
   const workspaceFile =
     WORKSPACE_CONFIG_FILENAMES.find((n) => existsSync(path.join(root, n))) ?? '.vx/workspace.ts'
-  const c = detectColors(process.stdout)
-  const dim = (t: string): string => paint('', t, c, { dim: true })
-  const bold = (t: string): string => paint('', t, c, { bold: true })
-  process.stdout.write(
-    `${paint(SUCCESS, args.dry ? 'would write' : 'wrote', c, { bold: true })} ${files.map(([rel]) => bold(rel)).join(' and ')}\n` +
-      `${dim('Declare it in')} ${workspaceFile}${dim(':')} ${bold(`import { ${factory} } from '../plugins/${seam}.ts'`)}${dim(', then')} ${bold(`plugins: [${factory}(…)]`)}\n` +
-      `${dim('Test it:')} ${bold(`bun test plugins/${seam}.test.ts`)} ${dim('(needs @vzn/vx installed)')}\n`,
+  const names = files.flatMap(([rel], i) => [...(i > 0 ? [' and '] : []), ui.strong(rel)])
+  ui.print('out', ui.line(ui.tone('ok', args.dry ? 'would write' : 'wrote', true), ' ', ...names))
+  ui.print(
+    'out',
+    ui.line(
+      'Declare it in ',
+      ui.path(workspaceFile),
+      ': ',
+      ui.cmd(`import { ${factory} } from '../plugins/${seam}.ts'`),
+      ', then ',
+      ui.cmd(`plugins: [${factory}(…)]`),
+    ),
+  )
+  ui.print(
+    'out',
+    ui.line('Test it: ', ui.cmd(`bun test plugins/${seam}.test.ts`), ' (needs @vzn/vx installed)'),
   )
   return 0
 }
@@ -460,7 +467,8 @@ async function starter(
   const declare = `declare a task in ${kept.find((f) => f.startsWith('vx.config.')) ?? config}, then vx lock && vx run <task>`
   const next = `${noGit ? 'git init, ' : ''}${hasScripts(pkgRoot) ? `bunx @vzn/vx-migrate${args.mjs ? ' --mjs' : ''} to make package.json scripts tasks, or ${declare}` : declare}`
   if (args.json === true) {
-    process.stdout.write(
+    ui.data(
+      'out',
       `${JSON.stringify({ dry: true, source: 'no turbo.json or nx.json', files, kept, replaced, todos: [], notes: [], next, installs })}\n`,
     )
     return 0