@vzn/vx 0.0.631 → 0.0.633

package/src/cli/init.ts

@@ -1,16 +1,19 @@
-// `vx init [--dry] [--force] [--mjs]` — a workspace from nowhere: one vx.config.ts
-// per package from its package.json scripts, and the workspace file every
-// run needs. In a Turbo or Nx repo it writes only the workspace file,
-// declaring `turbo()` or `nx()` from `@vzn/vx-migrate`, which read the
-// runner's own config live (`adopt`).
+// `vx init [--dry [--format json]] [--force] [--mjs] [--native|--keep]` — a workspace from nowhere:
+// one vx.config.ts per package from its package.json scripts, and the
+// workspace file every run needs. In a Turbo or Nx repo it hands over to
+// `@vzn/vx-migrate` (`migrate`), which asks a terminal whether to write
+// native config; `--keep` writes only the workspace file, declaring
+// `turbo()` or `nx()`, which read the runner's own config live (`adopt`).
 // `vx init --plugin <seam>` writes a runnable plugin for one seam and its
 // test instead (plugin-templates.ts, the examples the gate runs).
 
 import { existsSync, readFileSync } from 'node:fs'
 import { mkdir, unlink } from 'node:fs/promises'
 import path from 'node:path'
-import { flagHint, seeHelp } from './help.js'
+import { flagHint, formatValue, refuse, seeHelp } from './help.js'
 import { PLUGIN_TEMPLATES } from './plugin-templates.js'
+import { isCompiledBinary } from './upgrade.js'
+import { VERSION } from '../version.js'
 import { isUserError, relPosix, UserError } from '../util/index.js'
 import {
   applyMigration,
@@ -29,6 +32,10 @@ interface InitArgs {
   mjs: boolean
   /** `--plugin <seam>`: scaffold that seam's plugin instead of the workspace. */
   plugin?: string
+  /** `--native` / `--keep` in a Turbo or Nx repo; unset, vx-migrate asks a terminal. */
+  mode?: 'native' | 'keep'
+  /** `--format json` (with `--dry`): the plan as one JSON document. */
+  json?: boolean
   error?: string
 }
 
@@ -46,13 +53,29 @@ export function parseInitArgs(args: readonly string[]): InitArgs {
         }
       }
       out.plugin = seam
+    } else if (a === '--format' || a.startsWith('--format=')) {
+      const fv = formatValue(a === '--format' ? args[++i] : a.slice('--format='.length), 'init')
+      if (typeof fv === 'object') return { ...out, error: fv.error }
+      out.json = fv === 'json'
     } else if (a === '--dry') out.dry = true
     else if (a === '--force') out.force = true
     else if (a === '--mjs') out.mjs = true
-    else if (a.startsWith('-'))
+    else if (a === '--native' || a === '--keep') {
+      const mode = a === '--native' ? 'native' : 'keep'
+      if (out.mode !== undefined && out.mode !== mode) {
+        return {
+          ...out,
+          error: `--native and --keep are two answers to one question; pass one${seeHelp('init')}`,
+        }
+      }
+      out.mode = mode
+    } else if (a.startsWith('-'))
       return { ...out, error: `unknown flag: ${a}${flagHint('init', a)}${seeHelp('init')}` }
     else return { ...out, error: `unexpected argument: ${a}${seeHelp('init')}` }
   }
+  if (out.plugin !== undefined && out.mode !== undefined) {
+    return { ...out, error: `--${out.mode} does not combine with --plugin${seeHelp('init')}` }
+  }
   if (out.plugin !== undefined && out.mjs) {
     return {
       ...out,
@@ -64,16 +87,22 @@ export function parseInitArgs(args: readonly string[]): InitArgs {
 
 export async function initCmd(args: readonly string[]): Promise<number> {
   const parsed = parseInitArgs(args)
-  if (parsed.error) {
-    process.stderr.write(`vx init: ${parsed.error}\n`)
-    return 1
+  if (parsed.error) return refuse('init', args, parsed.error, 'VX_E_USAGE')
+  // In the verb, not the parser: completion asks the parser one flag at a time.
+  if (parsed.json === true && (!parsed.dry || parsed.plugin !== undefined)) {
+    return refuse(
+      'init',
+      args,
+      `--format json prints the workspace plan, so it needs --dry and no --plugin${seeHelp('init')}`,
+      'VX_E_USAGE',
+    )
   }
   if (parsed.plugin !== undefined) return scaffoldPlugin(parsed.plugin, parsed)
   const reads: LoadReads = new Map()
   // "a workspace from nowhere" still needs a package.json to start from,
   // and the lookup's own refusal named no next step.
   const root = await findWorkspaceRoot(process.cwd(), reads).catch((err: unknown) => {
-    if (isUserError(err) && err.message.startsWith('Could not find a workspace root')) {
+    if (isUserError(err) && err.code === 'VX_E_NO_WORKSPACE') {
       throw new UserError(
         'vx init: no package.json here or in any parent directory; create one (`bun init` or `npm init -y`) and run vx init again',
       )
@@ -95,14 +124,42 @@ export async function initCmd(args: readonly string[]): Promise<number> {
       break
     }
   }
-  // A Turbo or Nx repo already says its tasks: the runner's own config is
-  // the source, and `turbo()` / `nx()` read it live. Writing a config per
-  // package from the scripts dropped every edge turbo.json declares (the
-  // first-five-minutes walk, 2026-09-28); the workspace file alone is the
-  // whole adoption, and `bunx @vzn/vx-migrate` stays for freezing it.
-  if (turbo !== undefined) return adopt(root, 'turbo', turbo, parsed)
-  if (await Bun.file(path.join(root, 'nx.json')).exists()) {
-    return adopt(root, 'nx', 'nx.json', parsed)
+  // A Turbo or Nx repo already says its tasks: writing a config per package
+  // from the scripts dropped every edge turbo.json declares (the
+  // first-five-minutes walk, 2026-09-28). vx-migrate maps the runner's own
+  // config, so `vx init` is the one command (M, 2026-10-08); its `--keep`
+  // comes back here for the workspace file alone.
+  const runner: ['turbo' | 'nx', string] | undefined =
+    turbo !== undefined
+      ? ['turbo', turbo]
+      : (await Bun.file(path.join(root, 'nx.json')).exists())
+        ? ['nx', 'nx.json']
+        : undefined
+  if (runner !== undefined) {
+    if (parsed.mode === 'keep') return adopt(root, ...runner, parsed)
+    // A second `vx init` after the native migration refused to overwrite
+    // the configs it wrote, exit 1, after a package fetch: the first-run
+    // walk (2026-10-09). Set up is an answer, with the next step.
+    const existing = WORKSPACE_CONFIG_FILENAMES.find((f) => existsSync(path.join(root, f)))
+    if (
+      existing !== undefined &&
+      !parsed.force &&
+      !parsed.dry &&
+      parsed.mode === undefined &&
+      metas.some((m) => m.configPath !== null) &&
+      !readFileSync(path.join(root, existing), 'utf8').includes(`${runner[0]}(`)
+    ) {
+      process.stdout.write(
+        `vx is already set up here (${existing} and the projects' vx.config files); --force regenerates them from ${runner[1]}.\n\nnext: ${adoptionNext(root, ...runner, ['@vzn/vx'])}\n`,
+      )
+      return 0
+    }
+    return migrate(root, parsed)
+  }
+  if (parsed.mode !== undefined) {
+    throw new UserError(
+      `vx init: --${parsed.mode} answers a Turbo or Nx repo's question, and no turbo.json or nx.json is at ${relPosix(process.cwd(), root) || '.'}`,
+    )
   }
   const unmapped = namelessNotes(root, nameless)
   return applyMigration({
@@ -118,6 +175,7 @@ export async function initCmd(args: readonly string[]): Promise<number> {
     notes: [...(await unreadWorkspaces(root, workspace.packageGlobs)), ...unmapped],
     unmapped: unmapped.length > 0,
     dry: parsed.dry,
+    json: parsed.json === true,
     force: parsed.force,
     init: true,
     format: parsed.mjs ? 'mjs' : 'ts',
@@ -156,7 +214,36 @@ async function scaffoldPlugin(seam: string, args: InitArgs): Promise<number> {
 }
 
 /**
- * `vx init` in a Turbo or Nx repo: `vx.workspace.ts` declaring the plugin
+ * `vx init` in a Turbo or Nx repo runs `@vzn/vx-migrate`: the installed one,
+ * else this version's through `bun x`. It asks a terminal native or keep,
+ * installs what it writes, and runs `vx init --keep` for keep.
+ */
+async function migrate(root: string, args: InitArgs): Promise<number> {
+  const flags = [
+    args.dry && '--dry',
+    args.force && '--force',
+    args.mjs && '--mjs',
+    args.mode === 'native' && '--native',
+    args.json === true && '--format=json',
+  ].filter((f): f is string => typeof f === 'string')
+  return Bun.spawn(migrateCommand(root, flags), {
+    cwd: root,
+    stdio: ['inherit', 'inherit', 'inherit'],
+    // A compiled vx is a Bun runtime only when told so.
+    env: isCompiledBinary() ? { ...process.env, BUN_BE_BUN: '1' } : process.env,
+  }).exited
+}
+
+export function migrateCommand(root: string, flags: readonly string[]): string[] {
+  const installed = path.join(root, 'node_modules', '@vzn', 'vx-migrate', 'src', 'bin.ts')
+  if (existsSync(installed)) return [process.execPath, '--no-install', installed, ...flags]
+  // A source checkout is 0.0.0, which npm never had.
+  const version = VERSION === '0.0.0' ? 'latest' : VERSION
+  return [process.execPath, 'x', `@vzn/vx-migrate@${version}`, ...flags]
+}
+
+/**
+ * `vx init --keep` in a Turbo or Nx repo: `vx.workspace.ts` declaring the plugin
  * that runs the repo as it is, nothing else, and the one command that gets
  * from here to a run.
  */
@@ -184,7 +271,7 @@ async function adopt(
       )
     }
   } else if (args.dry) {
-    process.stdout.write(`── ${name} ──\n${text}\n`)
+    if (args.json !== true) process.stdout.write(`── ${name} ──\n${text}\n`)
   } else {
     if (existing !== undefined && existing !== name) await unlink(path.join(root, existing))
     await Bun.write(path.join(root, name), text)
@@ -205,8 +292,23 @@ async function adopt(
         : kept
           ? ''
           : `${cache}(): ${remote}, so vx shares that remote cache (inert where the variable is unset).\n`
+  if (args.json === true) {
+    process.stdout.write(
+      `${JSON.stringify({
+        dry: true,
+        source,
+        files: kept ? [] : [{ path: name, contents: text }],
+        kept: kept ? [existing] : [],
+        replaced: !kept && existing !== undefined && existing !== name ? [existing] : [],
+        todos: [],
+        notes: cacheLine === '' ? [] : [cacheLine.trimEnd()],
+        next: adoptionNext(root, runner, source),
+      })}\n`,
+    )
+    return 0
+  }
   process.stdout.write(
-    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate, a temporary start until bunx @vzn/vx-migrate writes native config; nothing else written.\n` +
+    `vx init: ${source} found — ${runner}() from @vzn/vx-migrate, a temporary start until vx init --native writes native config; nothing else written.\n` +
       `${wrote}\n${cacheLine}\nnext: ${adoptionNext(root, runner, source)}\n`,
   )
   return 0
@@ -320,9 +422,14 @@ const INSTALL: Record<PackageManager, string> = {
 const EXEC: Record<PackageManager, string> = { pnpm: 'pnpm', yarn: 'yarn', bun: 'bunx', npm: 'npx' }
 
 /** Install what the workspace file imports, if missing, then run the repo's build. */
-export function adoptionNext(root: string, runner: 'turbo' | 'nx', source: string): string {
+export function adoptionNext(
+  root: string,
+  runner: 'turbo' | 'nx',
+  source: string,
+  needs: readonly string[] = ['@vzn/vx', '@vzn/vx-migrate'],
+): string {
   const pm = LOCKFILES.find(([f]) => existsSync(path.join(root, f)))?.[1] ?? 'npm'
-  const missing = ['@vzn/vx', '@vzn/vx-migrate'].filter(
+  const missing = needs.filter(
     (p) => !existsSync(path.join(root, 'node_modules', p, 'package.json')),
   )
   // A global vx (no runner started this one) runs the workspace's plugins as they are.

package/src/cli/last.ts

@@ -17,7 +17,9 @@ import {
   outcomeWord,
   type RunSummaryRow,
   resolveRunId,
+  runFailures,
   shortRunId,
+  taskLog,
 } from '../orchestrator/index.js'
 import { formatElapsed, UserError } from '../util/index.js'
 import { findWorkspaceRoot } from '../workspace/index.js'
@@ -29,6 +31,8 @@ interface LastArgs {
   /** Only runs that failed: the latest one replayed, or the list narrowed. */
   failed?: boolean
   format: 'pretty' | 'json'
+  /** `--log <task>`: that task's output in the run, not the run's summary. */
+  log?: string
   /** `--cache-dir`: read the history a run with the same flag wrote. */
   cacheDir?: string
   error?: string
@@ -72,6 +76,14 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       out.failed = true
       continue
     }
+    if (a === '--log' || a.startsWith('--log=')) {
+      const v = a === '--log' ? args[++i] : a.slice('--log='.length)
+      if (v === undefined || v === '' || v.startsWith('-')) {
+        return { ...out, error: `--log requires a task id, like app#build${seeHelp('last')}` }
+      }
+      out.log = v
+      continue
+    }
     if (a === '--format' || a.startsWith('--format=')) {
       const fv = formatValue(a === '--format' ? args[++i] : a.slice(9), 'last')
       if (typeof fv === 'object') return { ...out, ...fv }
@@ -102,6 +114,12 @@ export function parseLastArgs(args: readonly string[]): LastArgs {
       error: `a run id and --list do not combine: replay ${out.runId}, or list runs${seeHelp('last')}`,
     }
   }
+  if (out.log !== undefined && (out.list !== undefined || out.failed === true)) {
+    return {
+      ...out,
+      error: `--log reads one task's output and combines only with a run id${seeHelp('last')}`,
+    }
+  }
   if (out.runId !== undefined && out.failed === true) {
     return {
       ...out,
@@ -282,10 +300,11 @@ export function formatRunList(
 
 export async function lastCmd(args: readonly string[]): Promise<number> {
   const parsed = parseLastArgs(args)
-  if (parsed.error !== undefined) throw new UserError(`vx last: ${parsed.error}`)
+  if (parsed.error !== undefined) throw new UserError(`vx last: ${parsed.error}`, 'VX_E_USAGE')
 
   const root = await findWorkspaceRoot(process.cwd())
-  const cache = Cache.inspect(await cliCacheDir(root, parsed.cacheDir))
+  const cacheDir = await cliCacheDir(root, parsed.cacheDir)
+  const cache = Cache.inspect(cacheDir)
   try {
     const db = cache.dbHandle()
     // Nothing recorded at all is its own answer: `--failed` said "no
@@ -293,6 +312,30 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
     // nothing, while `--list --failed` past green runs said there were none.
     const noRuns = (): boolean => listInvocations(db, { limit: 1 }).length === 0
 
+    if (parsed.log !== undefined) {
+      const runId =
+        parsed.runId === undefined
+          ? undefined
+          : (resolveRunId(db, parsed.runId, 'vx last') ?? parsed.runId)
+      const log = taskLog(cacheDir, db, parsed.log, runId)
+      if (log === null) {
+        throw new UserError(
+          `vx last: no recorded run of ${parsed.log}${parsed.runId === undefined ? '' : ` in run ${parsed.runId}`} (a task id is project#task)`,
+        )
+      }
+      if (parsed.format === 'json') {
+        process.stdout.write(`${JSON.stringify(log)}\n`)
+        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`,
+        )
+      }
+      process.stdout.write(log.output)
+      return 0
+    }
+
     if (parsed.list !== undefined) {
       const invocations =
         parsed.failed === true
@@ -330,12 +373,20 @@ export async function lastCmd(args: readonly string[]): Promise<number> {
             : parsed.failed === true
               ? 'vx last: no recorded run failed'
               : 'vx last: no recorded runs yet — run something first',
+        'VX_E_NO_HISTORY',
       )
     }
     const detail = getRun(db, inv.runId)
 
     if (parsed.format === 'json') {
-      process.stdout.write(`${JSON.stringify({ invocation: inv, tasks: detail?.tasks ?? [] })}\n`)
+      const failures = new Map(
+        (runFailures(cacheDir, db, inv.runId)?.tasks ?? []).map((f) => [f.taskId, f]),
+      )
+      const tasks = (detail?.tasks ?? []).map((t) => {
+        const f = failures.get(`${t.project}#${t.task}`)
+        return f === undefined ? t : { ...t, output: f.output, locations: f.locations }
+      })
+      process.stdout.write(`${JSON.stringify({ invocation: inv, tasks })}\n`)
       return 0
     }
 

package/src/cli/lock.ts

@@ -3,7 +3,7 @@
 // current environment. Design: docs/design/config-lock-2026-06.md.
 
 import type { ProjectConfig } from '../config.js'
-import { flagHint, refusedWord, seeHelp } from './help.js'
+import { flagHint, formatValue, refuse, refusedWord, seeHelp } from './help.js'
 import { relPosix, secretMask, xxh3hex } from '../util/index.js'
 import {
   findWorkspaceRoot,
@@ -22,16 +22,22 @@ import { discoverCliProjects } from './workspace-config.js'
 
 interface LockArgs {
   check: boolean
+  format: 'pretty' | 'json'
   error?: string
 }
 
 export function parseLockArgs(args: readonly string[]): LockArgs {
-  const out: LockArgs = { check: false }
-  for (const a of args) {
+  const out: LockArgs = { check: false, format: 'pretty' }
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!
     if (a === '--check') out.check = true
-    else
+    else if (a === '--format' || a.startsWith('--format=')) {
+      const fv = formatValue(a === '--format' ? args[++i] : a.slice(9), 'lock')
+      if (typeof fv === 'object') return { ...out, ...fv }
+      out.format = fv
+    } else
       return {
-        check: false,
+        ...out,
         error: `${refusedWord(a)}: ${a}${flagHint('lock', a)}${seeHelp('lock')}`,
       }
   }
@@ -42,10 +48,15 @@ type ConfiguredMeta = ProjectMeta & { configPath: string }
 
 export async function lockCmd(args: readonly string[]): Promise<number> {
   const parsed = parseLockArgs(args)
-  if (parsed.error) {
-    process.stderr.write(`vx lock: ${parsed.error}\n`)
-    return 1
-  }
+  if (parsed.error) return refuse('lock', args, parsed.error, 'VX_E_USAGE')
+  // Writing the lock prints one line; only the audit has an answer to shape.
+  if (parsed.format === 'json' && !parsed.check)
+    return refuse(
+      'lock',
+      args,
+      `--format json answers --check only${seeHelp('lock')}`,
+      'VX_E_USAGE',
+    )
   const reads: LoadReads = new Map()
   const root = await findWorkspaceRoot(process.cwd(), reads)
   const workspace = await loadWorkspace(root, reads)
@@ -62,7 +73,7 @@ export async function lockCmd(args: readonly string[]): Promise<number> {
   // count above leaves out — `locked 0 project configs` on a turbo() repo
   // read like an audit of something (2026-09-16).
   const bare = all.length - metas.length
-  if (parsed.check) return await checkLock(root, metas, bare)
+  if (parsed.check) return await checkLock(root, metas, bare, parsed.format === 'json')
   return await writeLock(root, metas, bare)
 }
 
@@ -154,13 +165,29 @@ function secretsIn(projects: Record<string, LockfileEntry>): Array<{ at: string;
  *      catches eval-time env-var drift that file hashes cannot see —
  *      file bytes unchanged, resolved value changed.
  */
-async function checkLock(root: string, metas: ConfiguredMeta[], bare: number): Promise<number> {
+async function checkLock(
+  root: string,
+  metas: ConfiguredMeta[],
+  bare: number,
+  json: boolean,
+): Promise<number> {
+  const answer = (problems: string[]): number => {
+    if (json) {
+      const out = {
+        upToDate: problems.length === 0,
+        audited: metas.length,
+        notAudited: bare,
+        problems,
+      }
+      process.stdout.write(`${JSON.stringify(out)}\n`)
+    }
+    return problems.length === 0 ? 0 : 1
+  }
   const lock = await readLockfile(root)
   if (!lock) {
-    process.stderr.write(
-      `vx lock --check: no ${LOCKFILE_NAME} at ${root} — run \`vx lock\` first\n`,
-    )
-    return 1
+    const problem = `no ${LOCKFILE_NAME} at ${root} — run \`vx lock\` first`
+    if (!json) process.stderr.write(`vx lock --check: ${problem}\n`)
+    return answer([problem])
   }
   const results = await Promise.all(
     metas.map(async (m): Promise<string | null> => {
@@ -200,6 +227,7 @@ async function checkLock(root: string, metas: ConfiguredMeta[], bare: number): P
       )
     }
   }
+  if (json) return answer(failures)
   if (failures.length > 0) {
     for (const f of failures) process.stderr.write(`vx lock --check: ${f}\n`)
     return 1

package/src/cli/plan-format.ts

@@ -1,6 +1,6 @@
 // Formatters for `--dry-run` (human / JSON) and `--graph` (DOT).
 
-import type { CacheStatus, RunPlan } from '../orchestrator/index.js'
+import type { AffectedReason, CacheStatus, RunPlan } from '../orchestrator/index.js'
 import { formatElapsed, maskedCommand } from '../util/index.js'
 
 /**
@@ -52,6 +52,9 @@ export function formatPlanText(plan: RunPlan): string {
     if (taskDesc) {
       lines.push(`     ${' '.repeat(idWidth)}  ${taskDesc}`)
     }
+    if (t.affected !== undefined) {
+      lines.push(`     ${' '.repeat(idWidth)}  affected: ${describeReason(t.affected)}`)
+    }
     if (skipped) noop++
     else if (t.cacheStatus === 'hit-local') local++
     else if (t.cacheStatus === 'hit-remote') remote++
@@ -104,6 +107,23 @@ export function formatPlanText(plan: RunPlan): string {
   return lines.join('\n') + '\n'
 }
 
+/** One `--affected --dry` reason line: the cause, then the edge chain that carried it. */
+function describeReason(r: AffectedReason): string {
+  const cause =
+    r.kind === 'named'
+      ? 'named on the command line'
+      : r.kind === 'selected'
+        ? 'its project is selected outright'
+        : r.kind === 'package'
+          ? `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'
+  return r.via === undefined ? cause : `${cause}, via ${r.via.join(' ← ')}`
+}
+
 /** A TS config may build the description from `process.env` (L-11). */
 function shownDescription(t: RunPlan['tasks'][number]): string | undefined {
   const { description, exec } = t.node.config
@@ -122,6 +142,7 @@ export interface PlanTaskJson {
   executor?: string
   download?: 'deferred'
   description?: string
+  affected?: AffectedReason
 }
 
 export function formatPlanJson(plan: RunPlan): string {
@@ -141,6 +162,7 @@ export function formatPlanJson(plan: RunPlan): string {
             ...(t.executor !== undefined ? { executor: t.executor } : {}),
             ...(t.download !== undefined ? { download: t.download } : {}),
             ...(description !== undefined ? { description } : {}),
+            ...(t.affected !== undefined ? { affected: t.affected } : {}),
           }
         }),
         ...(plan.predicted !== undefined ? { predicted: plan.predicted } : {}),

package/src/cli/plugin-commands.ts

@@ -99,6 +99,9 @@ export async function resolvePluginCommand(
         workspaceRoot: ws.workspaceRoot,
         cacheDir: ws.cacheDir,
         concurrency: ws.concurrency,
+        vx: (await import('./upgrade.js')).isCompiledBinary()
+          ? [process.execPath]
+          : [process.execPath, Bun.main],
         warn: (m) => process.stderr.write(`${maskedLine(m)}\n`),
       },
     }

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 = { workspaceRoot: '/ws', cacheDir: '/ws/.vx/cache', warn() {}, concurrency: 1 }\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}\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: