@vzn/vx 0.0.645 → 0.0.646

package/src/report/summary.ts

@@ -15,6 +15,7 @@ import {
   gradientRule,
   paint,
   SUCCESS,
+  ui,
   WARN,
   type ColorSupport,
 } from '../util/index.js'
@@ -27,6 +28,7 @@ const LOCAL = '#38bdf8' // sky-400
 const REMOTE = '#2563eb' // blue-600
 const ABORTED = '#f97316' // orange-500: red's neighbour, not a failure
 const NOT_RUN = '#a855f7' // purple-500: stopped before it began, apart from every other state
+const RUNNING = '#06b6d4' // cyan-500: ui's info
 const ACCENT = '#06b6d4' // cyan-500: the live region's running word
 
 /**
@@ -85,6 +87,11 @@ export interface SummaryStats {
   aborted?: number
   /** Reached by the stop before they ran. Not in `total`. */
   notRun?: number
+  /** Live: running now, and handed to an executor whose machine has not begun them. */
+  running?: number
+  scheduled?: number
+  /** Live: not started because a dependency has not finished. */
+  blocked?: number
   total: number
   upToDate: number
   restoredLocal: number
@@ -120,13 +127,20 @@ export type CacheBucket =
   | 'restoredLocal'
   | 'restoredRemote'
   | 'saved'
+  | 'notSaved'
 
 /** A finished task's own cache bucket; none for a group, a skip or an abort. */
 export function cacheBucketOf(o: TaskOutcome): CacheBucket | undefined {
   if (isGroupTask(o.node)) return undefined
   switch (o.status) {
     case 'success':
-      return ranNoCache(o) ? 'noCache' : o.saved === true ? 'saved' : 'miss'
+      return ranNoCache(o)
+        ? 'noCache'
+        : o.saved === true
+          ? 'saved'
+          : ranUnsaved(o)
+            ? 'notSaved'
+            : 'miss'
     case 'failed':
       return ranNoCache(o) ? 'noCache' : 'miss'
     case 'cache-hit':
@@ -149,8 +163,12 @@ type Buckets = Record<CacheBucket | 'uploaded' | 'uploading' | 'remoteFailed', n
  */
 function cacheBuckets(stats: SummaryStats, layers: RunContext['cache']): Buckets {
   const saved = layers === undefined ? 0 : (stats.saved ?? 0)
+  // Its own yellow segment, as its legend count is: in the misses' red it
+  // was a cell with no count under it (M, 2026-10-21).
+  const notSaved = layers === undefined ? 0 : (stats.notSaved ?? 0)
   const b: Buckets = {
-    miss: stats.miss - saved,
+    miss: stats.miss - saved - notSaved,
+    notSaved,
     noCache: stats.noCache ?? 0,
     upToDate: stats.upToDate,
     restoredLocal: stats.restoredLocal,
@@ -183,6 +201,10 @@ export interface RunContext {
   packageCount: number
   /** The run's whole id, as `vx last` takes it; shown on the `info` row. */
   runId?: string | undefined
+  /** The executors' own footer rows (`TaskExecutor.footer`), above the `info` row. */
+  executorRows?: () => readonly (readonly [string, ui.Inline])[]
+  /** Where a running task runs, `null` while it waits for a machine (`TaskExecutor.running`): its live row. */
+  whereRunning?: (taskId: string) => string | null | undefined
   /** Worker-pool size for this run; shown on the `info` row. */
   concurrency?: number
   remoteCacheEnabled: boolean
@@ -226,7 +248,15 @@ export function formatSummarySection(
   const left = stats.left ?? 0
   const aborted = stats.aborted ?? 0
   const notRun = stats.notRun ?? 0
-  const remainder = { n: left, color: '', glyph: '\u25b1', dim: true }
+  const running = stats.running ?? 0
+  const scheduled = stats.scheduled ?? 0
+  const blocked = stats.blocked ?? 0
+  const remainder = {
+    n: Math.max(0, left - running - scheduled - blocked),
+    color: '',
+    glyph: '\u25b1',
+    dim: true,
+  }
 
   const dim = (txt: string) => paint('', txt, colors, { dim: true })
   const row = (label: string, value: string): string => `  ${dim(label.padEnd(8))}  ${value}`
@@ -243,6 +273,9 @@ export function formatSummarySection(
   if (stats.skipped > 0) taskParts.push(paint(WARN, `${stats.skipped} skipped`, colors))
   if (aborted > 0) taskParts.push(paint(ABORTED, `${aborted} aborted`, colors))
   if (notRun > 0) taskParts.push(paint(NOT_RUN, `${notRun} not run`, colors))
+  if (running > 0) taskParts.push(paint(RUNNING, `${running} running`, colors))
+  if (scheduled > 0) taskParts.push(dim(`${scheduled} scheduled`))
+  if (blocked > 0) taskParts.push(dim(`${blocked} blocked`))
   if (runTotal > 0) taskParts.push(dim(`${runTotal} total`))
   const taskBar = segmentBar(
     [
@@ -251,6 +284,9 @@ export function formatSummarySection(
       { n: stats.skipped, color: WARN },
       { n: aborted, color: ABORTED },
       { n: notRun, color: NOT_RUN },
+      { n: running, color: RUNNING },
+      { n: scheduled, color: '', dim: true },
+      { n: blocked, color: '', dim: true },
       remainder,
     ],
     colors,
@@ -310,6 +346,7 @@ export function formatSummarySection(
     const cacheBar = segmentBar(
       [
         { n: b.miss, color: ERROR },
+        { n: b.notSaved, color: WARN },
         { n: b.noCache, color: '', dim: true },
         { n: b.upToDate, color: SUCCESS },
         { n: b.restoredLocal, color: LOCAL },
@@ -355,8 +392,8 @@ export function formatSummarySection(
       ]
       if (layers.remote && remote.length > 0)
         cacheParts.push(`${dim('remote')} ${remote.join(' ')}`)
-      if ((stats.notSaved ?? 0) > 0)
-        cacheParts.push(paint(WARN, `${stats.notSaved} not saved`, colors))
+      if (b.miss > 0) cacheParts.push(paint(ERROR, `${b.miss} miss`, colors))
+      if (b.notSaved > 0) cacheParts.push(paint(WARN, `${b.notSaved} not saved`, colors))
       const notDownloaded = layers.notDownloaded()
       if (notDownloaded > 0) cacheParts.push(paint(WARN, `${notDownloaded} not downloaded`, colors))
     } else {
@@ -410,10 +447,27 @@ export function formatSummarySection(
   // Run-shape footer (final summary only): worker pool + cache mode,
   // grouped with time under a blank line below the meters.
   if (context !== undefined) {
+    const own = context.executorRows?.() ?? []
+    if (own.length > 0)
+      lines.push('', ...own.map(([label, text]) => row(label, ui.inline(text, colors))))
     const info: string[] = []
-    if (context.concurrency !== undefined)
+    // An executor that says where tasks ran says it better than the pool.
+    if (context.concurrency !== undefined && own.length === 0)
       info.push(`${context.concurrency} worker${context.concurrency === 1 ? '' : 's'}`)
-    info.push(context.remoteCacheEnabled ? 'local + remote cache' : 'local cache')
+    const layers = context.cache
+    info.push(
+      layers === undefined
+        ? context.remoteCacheEnabled
+          ? 'local + remote cache'
+          : 'local cache'
+        : layers.local && layers.remote
+          ? 'local + remote cache'
+          : layers.local
+            ? 'local cache'
+            : layers.remote
+              ? 'remote cache'
+              : 'no cache',
+    )
     if (context.cacheScope !== undefined) info.push(`scope ${context.cacheScope}`)
     // The plugin's hand on the run: a task a policy held with a worker
     // free would otherwise have started; without the line nothing says

package/src/settings.ts

@@ -50,6 +50,13 @@ export const SETTINGS: readonly Setting[] = [
     default: "origin/HEAD's branch, then main, then master",
     doc: 'The default branch: a run on it has no cache scope and a bare `--affected` no base; elsewhere both use the merge base with `origin/<baseBranch>`.',
   },
+  {
+    path: 'affectedBase',
+    kind: { type: 'string' },
+    default: "a plugin's base commit, else the merge base with `baseBranch`",
+    doc: "The commit a bare `--affected` compares with, on the base branch too. `--affected=<base>` beats it; it beats a plugin's base commit. Env only: a committed base would be stale on the next push.",
+    config: false,
+  },
   {
     path: 'run.concurrency',
     kind: { type: 'concurrency' },

package/src/util/colors.ts

@@ -34,6 +34,7 @@ export interface PaintOptions {
  *   NO_COLOR non-empty          → off (overrides FORCE_COLOR)
  *   FORCE_COLOR=0 or =false     → off, even on a TTY
  *   FORCE_COLOR any other value → on (the empty string too)
+ *   a CI whose log renders ANSI (`ciPaints`) → on
  *   else: on iff stdout is a TTY that is not `TERM=dumb`.
  * `0` and `false` are the convention's "off" (supports-color, chalk,
  * Node); reading every non-empty value as on painted a piped CI log that
@@ -45,7 +46,7 @@ export function detectColors(stream: NodeJS.WriteStream = process.stdout): Color
     ? false
     : force !== undefined
       ? force !== '0' && force !== 'false'
-      : stream.isTTY === true && !dumbTerminal()
+      : ciPaints() || (stream.isTTY === true && !dumbTerminal())
   return {
     enabled,
     get columns() {
@@ -54,6 +55,20 @@ export function detectColors(stream: NodeJS.WriteStream = process.stdout): Color
   }
 }
 
+/**
+ * A CI whose log viewer renders ANSI colour though the job's output is a
+ * pipe (supports-color reads the same variables): its log was plain.
+ */
+function ciPaints(): boolean {
+  const env = process.env
+  return (
+    env['GITHUB_ACTIONS'] === 'true' ||
+    env['GITLAB_CI'] === 'true' ||
+    env['BUILDKITE'] === 'true' ||
+    env['CIRCLECI'] === 'true'
+  )
+}
+
 /**
  * `TERM=dumb` (Emacs `M-x shell`, some CI log viewers) can neither paint
  * nor move the cursor: vx prints to it as off a terminal.

package/src/util/index.ts

@@ -72,6 +72,7 @@ export {
   anyTaskGlob,
   isInstalledPath,
   taskGlob,
+  outputDirPrefixes,
   wholeSubtreePrefixes,
   slashBraceExpansions,
   braceAlternatives,

package/src/util/paths.ts

@@ -117,6 +117,36 @@ export function wholeSubtreePrefixes(globs: readonly string[]): string[] | null
   return [...new Set(out)]
 }
 
+/**
+ * The directories whose snapshot covers every path the positive `globs`
+ * can match, or `null` when one reaches outside the project. A
+ * whole-subtree glob or a literal is its own tree
+ * ({@link wholeSubtreePrefixes}); any other glob is the tree under its
+ * static prefix, and a root-anchored one (`**\/dist/**`, Turbo's shape) is
+ * the whole project, `''`. Sound for the same reason: a file added or
+ * removed anywhere under a recorded directory bumps a recorded mtime. The
+ * snapshot's file list is then held to the entry's rows through the globs
+ * themselves, so a source file beside the outputs is no stray.
+ */
+export function outputDirPrefixes(globs: readonly string[]): string[] | null {
+  if (globs.length === 0) return null
+  const dirs: string[] = []
+  for (const g of globs) {
+    const whole = wholeSubtreePrefixes([g])?.[0]
+    if (whole !== undefined) {
+      dirs.push(whole)
+      continue
+    }
+    const prefix = staticPrefix(g)
+    if (prefix === '.') return ['']
+    if (prefix.startsWith('/') || prefix.startsWith('!') || prefix.split('/').includes('..'))
+      return null
+    dirs.push(prefix)
+  }
+  const sorted = [...new Set(dirs)].sort()
+  return sorted.filter((d, i) => !sorted.slice(0, i).some((a) => d.startsWith(`${a}/`)))
+}
+
 /**
  * The spellings a reader, Turbo and `.gitignore` all accept but a matcher
  * fed the raw string turns into NOTHING — and a task keyed on nothing

package/src/util/ui.ts

@@ -40,10 +40,13 @@ export const path = (text: string): Inline => ({ style: 'bold', text })
 export const cmd = (text: string): Inline => ({ style: 'bold', text })
 /** A secondary fact. */
 export const dim = (text: string): Inline => ({ style: 'dim', text })
+/** Where a task runs (`small#1`): its name's hue in every row and block; `local` plain. */
+export const place = (text: string): Inline => (text === 'local' ? text : id(text))
 /** Text in a tone's color. */
 export const tone = (t: Tone, text: string): Inline => ({ style: t, text })
 
-function inline(x: Inline, c: ColorSupport): string {
+/** One inline as text, colored for `c`. */
+export function inline(x: Inline, c: ColorSupport): string {
   if (typeof x === 'string') return x
   if (Array.isArray(x)) return (x as readonly Inline[]).map((p) => inline(p, c)).join('')
   const { style, text } = x as { style: Style; text: string }

package/src/workspace/config-bytecode.ts

@@ -0,0 +1,276 @@
+// Every run evaluates `.vx/workspace.ts`, and with it every plugin package
+// it imports: Bun parses and compiles that TypeScript on each run, and a
+// plugin's functions compile again on their first call, while core itself
+// runs from the binary's bytecode. On a solid-sized workspace that was
+// ~4 ms of a ~60 ms warm run (the `discover` stage alone 9 → 5 ms,
+// 2026-10-22). So the config's module graph is bundled once into CommonJS
+// with Bun's bytecode under `.vx/cache/compiled/`, and a later run whose
+// every input still has the bytes it was built from requires that instead.
+//
+// The bundle is built from the bytes it records, file by file, and is used
+// only while each recorded file still hashes the same and each bare import
+// still resolves to the file it did; anything else loads the source as
+// before and builds again. A graph the bundle could run differently is
+// never built: an `import.meta` field beyond its location, a `require` or
+// `import()` of a computed specifier (relative to the bundle, not the
+// file), top-level await, a CommonJS config, a file this process already
+// evaluated (a bundled copy would be a second state; run from source, core
+// itself). The bundle goes
+// into `.vx/cache` only once a run made it, so a reading verb on a fresh
+// workspace writes nothing (item 900). `.vx/cache` is trusted as the rest
+// of the cache is: what it holds is restored into the tree too.
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+} from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { xxh3hex } from '../util/index.js'
+
+/** Bumped when what a bundle holds, or how it is checked, changes. */
+const COMPILED_VERSION = 1
+
+/** What `import.meta` becomes in a bundled file: an identifier no source spells. */
+const META = '__vxImportMeta'
+const META_FIELDS = new Set(['dir', 'dirname', 'path', 'filename', 'file', 'url', 'main'])
+const META_USE = new RegExp(`\\b${META}\\b(\\.[\\w$]+)?`, 'g')
+const COMPUTED_LOAD = /\b(?:require|import)\(\s*(?![\s'"])|\brequire\.resolve\b/
+
+interface Manifest {
+  version: number
+  /** The config file by real path; its bytes are in the bundle's name, so it is not read again (principle 9). */
+  entry: string
+  /** Every file the bundle was built from, by real path, and its bytes' hash. */
+  inputs: Record<string, string>
+  /** Each bare import: the importing file's directory, the specifier, the real path it resolved to. */
+  bare: [string, string, string][]
+  /** The graph cannot be bundled faithfully: load the source while the inputs stay as they are. */
+  skip?: true
+}
+
+function compiledDir(root: string): string {
+  return path.join(root, '.vx', 'cache', 'compiled')
+}
+
+function nameOf(configPath: string, bytes: Uint8Array): string {
+  return `workspace-${xxh3hex(`${COMPILED_VERSION}\0${Bun.revision}\0${configPath}\0${xxh3hex(bytes)}`)}`
+}
+
+function fresh(manifest: Manifest): boolean {
+  for (const [file, hash] of Object.entries(manifest.inputs)) {
+    if (file === manifest.entry) continue
+    let bytes: Uint8Array
+    try {
+      bytes = readFileSync(file)
+    } catch {
+      return false
+    }
+    if (xxh3hex(bytes) !== hash) return false
+  }
+  for (const [from, spec, to] of manifest.bare) {
+    try {
+      if (realpathSync(Bun.resolveSync(spec, from)) !== to) return false
+    } catch {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * The workspace config's module namespace from its bundle: `undefined` when
+ * there is none for these bytes or an input moved (`build` then makes one),
+ * `null` when the graph is one no bundle runs faithfully.
+ */
+export function loadCompiled(
+  root: string,
+  configPath: string,
+  bytes: Uint8Array,
+): { default?: unknown } | null | undefined {
+  // A repeat load in this process (the run after the CLI's selection pass,
+  // a `vx watch` cycle) of the same bytes: the loader already refused an
+  // import edited since the first, so the answer stands (principle 9).
+  const seen = answered.get(configPath)
+  if (seen !== undefined && Buffer.from(seen.bytes).equals(bytes)) return seen.ns
+  const name = nameOf(configPath, bytes)
+  const dir = compiledDir(root)
+  let manifest: Manifest
+  try {
+    manifest = JSON.parse(readFileSync(path.join(dir, `${name}.json`), 'utf8')) as Manifest
+  } catch {
+    return undefined
+  }
+  if (manifest.version !== COMPILED_VERSION || !fresh(manifest)) return undefined
+  const ns =
+    manifest.skip === true
+      ? null
+      : (createRequire(path.join(dir, 'index.js'))(path.join(dir, `${name}.js`)) as {
+          default?: unknown
+        })
+  answered.set(configPath, { bytes, ns })
+  return ns
+}
+
+/** What `loadCompiled` answered for each config, by the bytes it was asked with. */
+const answered = new Map<string, { bytes: Uint8Array; ns: { default?: unknown } | null }>()
+
+/**
+ * The files this process has evaluated as modules. One the config imports
+ * by path (run from source, core's own `src/index.ts`) is shared with the
+ * process, and a bundle would run a second copy of its state.
+ */
+export function loadedModules(root: string): Set<string> {
+  // Not `import.meta`: core's planner also runs as a browser script (the playground).
+  return new Set(Object.keys(createRequire(path.join(root, 'index.js')).cache))
+}
+
+/** The loader Bun reads `file` with, or null for a file the bundle must not hold. */
+function loaderOf(file: string): 'ts' | 'tsx' | 'js' | 'jsx' | null {
+  const ext = path.extname(file)
+  if (ext === '.ts' || ext === '.mts') return 'ts'
+  if (ext === '.tsx') return 'tsx'
+  if (ext === '.js' || ext === '.mjs') return 'js'
+  if (ext === '.jsx') return 'jsx'
+  return null
+}
+
+/**
+ * Bundle the workspace config's graph for the next run. A speed-up only:
+ * every failure leaves the next run loading the source.
+ */
+export async function buildCompiled(
+  root: string,
+  configPath: string,
+  bytes: Uint8Array,
+  /** `loadedModules()` before the config's source load. */
+  loaded: ReadonlySet<string>,
+  /** What that load evaluated: a repeat load in this process gets it, not a bundle or a second build. */
+  ns: { default?: unknown },
+): Promise<void> {
+  answered.set(configPath, { bytes, ns })
+  const dir = compiledDir(root)
+  if (!existsSync(path.dirname(dir))) return
+  const name = nameOf(configPath, bytes)
+  const entryFile = realpathSync(configPath)
+  const inputs: Record<string, string> = {}
+  let faithful = true
+  const transpilers = new Map<string, Bun.Transpiler>()
+  const tmp = path.join(dir, `.tmp-${process.pid}-${Date.now()}`)
+  try {
+    mkdirSync(tmp, { recursive: true })
+    const built = await Bun.build({
+      entrypoints: [configPath],
+      target: 'bun',
+      format: 'cjs',
+      bytecode: true,
+      external: ['@vzn/vx'],
+      outdir: tmp,
+      naming: `${name}.js`,
+      metafile: true,
+      throw: false,
+      plugins: [
+        {
+          name: 'vx-config-bytecode',
+          setup(build) {
+            build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
+              const file = realpathSync(args.path)
+              if (loaded.has(file)) {
+                faithful = false
+                inputs[file] = xxh3hex(await Bun.file(file).bytes())
+                return { contents: '', loader: 'js' }
+              }
+              const loader = loaderOf(file)
+              const source = file === entryFile ? bytes : await Bun.file(file).bytes()
+              inputs[file] = xxh3hex(source)
+              if (loader === null || /\.c[jt]s$/.test(file)) {
+                faithful = false
+                return { contents: source, loader: loader ?? 'js' }
+              }
+              const fileDir = path.dirname(file)
+              let t = transpilers.get(file)
+              if (t === undefined) {
+                t = new Bun.Transpiler({
+                  loader,
+                  define: {
+                    'import.meta': META,
+                    __dirname: JSON.stringify(fileDir),
+                    __filename: JSON.stringify(file),
+                  },
+                })
+                transpilers.set(file, t)
+              }
+              const js = t.transformSync(new TextDecoder().decode(source))
+              for (const m of js.matchAll(META_USE)) {
+                if (m[1] !== undefined && !META_FIELDS.has(m[1].slice(1))) faithful = false
+              }
+              if (COMPUTED_LOAD.test(js)) faithful = false
+              const meta = {
+                dir: fileDir,
+                dirname: fileDir,
+                path: file,
+                filename: file,
+                file: path.basename(file),
+                url: Bun.pathToFileURL(file).href,
+                main: false,
+              }
+              return { contents: `const ${META} = ${JSON.stringify(meta)};\n${js}`, loader: 'js' }
+            })
+          },
+        },
+      ],
+    })
+    const out = path.join(tmp, `${name}.js`)
+    const bytecode = built.success && Bun.file(`${out}.jsc`).size > 0
+    const manifest: Manifest = {
+      version: COMPILED_VERSION,
+      entry: entryFile,
+      inputs,
+      bare: bareImports(built.metafile),
+      ...(faithful && bytecode ? {} : { skip: true as const }),
+    }
+    // The metafile names every input; one no onLoad saw (a JSON import) is
+    // bytes the manifest does not check.
+    for (const [input, entry] of Object.entries(built.metafile?.inputs ?? {})) {
+      const file = realpathSync(path.resolve(input))
+      if (inputs[file] === undefined) manifest.skip = true
+      // A CommonJS config's export is `module.exports`, not a namespace's `default`.
+      if (file === entryFile && entry.format === 'cjs') manifest.skip = true
+    }
+    for (const old of readdirSync(dir)) {
+      if (old.startsWith('workspace-')) rmSync(path.join(dir, old), { force: true })
+    }
+    if (manifest.skip !== true) {
+      renameSync(`${out}.jsc`, path.join(dir, `${name}.js.jsc`))
+      renameSync(out, path.join(dir, `${name}.js`))
+    }
+    // Last: a manifest names a bundle already in place.
+    await writeFile(path.join(tmp, 'manifest.json'), JSON.stringify(manifest))
+    renameSync(path.join(tmp, 'manifest.json'), path.join(dir, `${name}.json`))
+  } catch {
+    // A read-only cache directory, a full disk, a graph Bun cannot bundle:
+    // the next run loads the source, as this one did.
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}
+
+function bareImports(metafile: Bun.BuildMetafile | undefined): [string, string, string][] {
+  const out: [string, string, string][] = []
+  for (const [input, entry] of Object.entries(metafile?.inputs ?? {})) {
+    const from = path.dirname(realpathSync(path.resolve(input)))
+    for (const imp of entry.imports) {
+      const spec = imp.original
+      if (imp.external === true || spec === undefined) continue
+      if (spec.startsWith('.') || path.isAbsolute(spec)) continue
+      out.push([from, spec, realpathSync(path.resolve(imp.path))])
+    }
+  }
+  return out
+}

package/src/workspace/index.ts

@@ -77,5 +77,4 @@ export {
   type GeneratedTask,
   type MigrationPlan,
   type RawExpr,
-  vxInvocation,
 } from './migration.js'

package/src/workspace/migration.ts

@@ -383,18 +383,18 @@ export async function applyMigration(args: ApplyMigrationArgs): Promise<number>
     }
   }
   const firstTask = nextTask(plan.projects.flatMap((p) => p.tasks))
-  const installed = existsSync(path.join(root, 'node_modules', '@vzn', 'vx', 'package.json'))
   // The line is the next thing to type, so it names what that run would
   // refuse without: a git work tree (vx keys inputs on git's view) and,
   // with no scripts mapped, a task to run.
-  const vx = vxInvocation(process.env['npm_config_user_agent'], installed)
-  const run = `${vx} run ${firstTask} --all`
+  // `vx init` installs vx globally first: the line names vx alone, never
+  // a package manager's runner (owner, 2026-10-22: vx owns the command).
+  const run = `vx run ${firstTask} --all`
   // A run reads configs only from the lock; with no lock step here
   // (`--no-install`), that run stopped with "no lock: run `vx lock`".
   const steps = [
     ...(inGitWorkTree(root) ? [] : ['git init']),
     ...(empty ? [`declare a task as the example shows`] : []),
-    ...(!dry && args.lock === undefined ? [`${vx} lock`] : []),
+    ...(!dry && args.lock === undefined ? ['vx lock'] : []),
   ]
   const next = steps.length === 0 ? run : `${steps.join(', ')}, then ${run}`
   const emptyReason = empty ? args.emptyReason : undefined
@@ -595,34 +595,6 @@ function nextTask(tasks: readonly GeneratedTask[]): string {
   return names.includes('build') ? 'build' : (fit?.name ?? names[0] ?? 'build')
 }
 
-/**
- * How the user runs vx, for the report's `next:` line. After `npx @vzn/vx init`
- * or `bunx @vzn/vx init` a bare `vx` is on no PATH (the first-five-minutes
- * walk, 2026-09-28), so the line names the runner that started this
- * process — npx, pnpm, yarn and Bun each set `npm_config_user_agent` — and
- * the spec it resolves. npx and bunx always name the package, which runs
- * the installed bin when there is one: their bare `vx` fetches an unrelated
- * package named `vx` wherever vx is not installed. No
- * runner (a global install, the compiled binary): `vx`.
- */
-export function vxInvocation(userAgent: string | undefined, installed: boolean): string {
-  const runner = /^(npm|pnpm|yarn|bun)\//.exec(userAgent ?? '')?.[1]
-  switch (runner) {
-    case 'npm':
-      return 'npx @vzn/vx'
-    case 'bun':
-      return 'bunx @vzn/vx'
-    case 'pnpm':
-      return installed ? 'pnpm vx' : 'pnpm dlx @vzn/vx'
-    case 'yarn':
-      // `dlx` is Yarn 2+; Yarn 1 answers `Command "dlx" not found`.
-      if (installed) return 'yarn vx'
-      return userAgent!.startsWith('yarn/1.') ? 'npx @vzn/vx' : 'yarn dlx @vzn/vx'
-    default:
-      return 'vx'
-  }
-}
-
 /** Files named one per line; past this, the root's and a count (TanStack form: 97). */
 const FILES_SHOWN = 10