@vzn/vx 0.0.644 → 0.0.646

package/src/cache/output-index.ts

@@ -18,11 +18,11 @@ const FILE_PREFIX_MTIME = -2
 import type { Database } from 'bun:sqlite'
 import { inHashes, lazyStatement } from './schema.js'
 import { modeMatches } from './umask.js'
-import { lstatSync, readlinkSync, statSync } from 'node:fs'
-import { lstat, readdir } from 'node:fs/promises'
+import { lstatSync, readdirSync, readlinkSync, statSync } from 'node:fs'
 import path from 'node:path'
 import {
   OUTPUT_DIRS_CAP,
+  OUTPUT_DIRS_OVER_CAP,
   OUTPUT_DIRS_RACY_MS,
   type OutputDirRow,
   isIndexFull,
@@ -262,8 +262,8 @@ export class OutputIndex {
    * process may have written into them: `holds` is asked with the files
    * the walk saw, and a tree it refuses records nothing (item 1087).
    * Symlinked directories are not descended (the output walk refuses them
-   * too). Over `OUTPUT_DIRS_CAP` directories, or on any error, the rows
-   * are cleared and the next hit keeps the walk.
+   * too). Over `OUTPUT_DIRS_CAP` directories the one row left says so; on
+   * any error the rows are cleared. Either way the next hit keeps the walk.
    */
   async recordOutputDirs(
     hash: string,
@@ -273,11 +273,16 @@ export class OutputIndex {
   ): Promise<void> {
     const rows: Array<[string, number]> = []
     const files: string[] = []
-    const walk = async (rel: string, isPrefix = false): Promise<boolean> => {
+    let overCap = false
+    // Synchronous, like the stats of `isOutputsCurrent`: an async lstat and
+    // readdir per directory are two thread-pool round trips, and a
+    // root-anchored glob's snapshot of solid's 47 directories took 4 ms of
+    // the run's end that way (2026-10-22).
+    const walk = (rel: string, isPrefix = false): boolean => {
       const abs = path.join(projectDir, rel)
       let st
       try {
-        st = await lstat(abs)
+        st = lstatSync(abs)
       } catch {
         // A declared prefix the task never produced (`build/**` beside
         // `dist/**`, medusa's `.medusa/**`) is recorded ABSENT: the check
@@ -299,29 +304,38 @@ export class OutputIndex {
         return true
       }
       rows.push([rel, st.mtimeMs])
-      if (rows.length > OUTPUT_DIRS_CAP) return false
+      if (rows.length > OUTPUT_DIRS_CAP) {
+        overCap = true
+        return false
+      }
       let entries
       try {
-        entries = await readdir(abs, { withFileTypes: true })
+        entries = readdirSync(abs, { withFileTypes: true })
       } catch {
         return false
       }
       for (const e of entries) {
+        // The project itself is the prefix `''` of a root-anchored glob.
+        const child = rel === '' ? e.name : `${rel}/${e.name}`
         if (e.isDirectory() && !e.isSymbolicLink()) {
-          if (!(await walk(`${rel}/${e.name}`))) return false
+          if (!walk(child)) return false
         } else {
-          files.push(`${rel}/${e.name}`)
+          files.push(child)
         }
       }
       return true
     }
     let ok = true
     for (const prefix of prefixes) {
-      if (!(await walk(prefix, true))) {
+      if (!walk(prefix, true)) {
         ok = false
         break
       }
     }
+    if (overCap) {
+      this.pendingDirs.set(hash, [[prefixes[0]!, OUTPUT_DIRS_OVER_CAP]])
+      return
+    }
     // All or nothing: a racy directory dropped alone would leave its
     // parent trusted while an addition inside it bumps only the dropped one.
     const now = Date.now()

package/src/cache/plugin-cache.ts

@@ -8,7 +8,6 @@
 
 import type { Database } from 'bun:sqlite'
 import { xxh3hex } from '../util/index.js'
-import type { RemoteKey } from './layered-cache.js'
 import type { CachePolicy } from './policy.js'
 import type { ResolvedRemote } from './remote-lane.js'
 import { scopedKey } from './scoped-cache.js'
@@ -100,8 +99,6 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
   const { db, policy, scope } = host
   const readers = host.remotes.filter((r) => r.read)
   const writers = host.remotes.filter((r) => r.write)
-  const at: RemoteKey = scope === undefined ? {} : { scope }
-  const atOf = (key: string, name: string): RemoteKey => (key === entryKey(plugin, name) ? {} : at)
   const readKey = (name: string, scoped: boolean): string => {
     const key = entryKey(plugin, name)
     return scope === undefined || !scoped ? key : scopedKey(scope, key)
@@ -155,7 +152,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       const key = readKey(name, scoped)
       for (const { remote } of readers) {
         try {
-          const got = await remote.get(key, atOf(key, name))
+          const got = await remote.get(key)
           if (got === null) continue
           const bytes = await capped(got.body)
           if (bytes === null) continue
@@ -174,7 +171,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       if (policy.localWrite) localPut(entryKey(plugin, name), bytes)
       for (const { remote } of writers) {
         try {
-          await remote.put(key, new Blob([bytes]), { durationMs: 0, ...at })
+          await remote.put(key, new Blob([bytes]), { durationMs: 0 })
         } catch {
           // the other layers still keep it
         }
@@ -187,7 +184,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       let answered = policy.localRead
       for (const { remote } of readers) {
         try {
-          if (await remote.has(key, atOf(key, name))) return true
+          if (await remote.has(key)) return true
           answered = true
         } catch {
           // no answer from this remote
@@ -207,12 +204,10 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         if (ask.length === 0) break
         if (remote.hasMany === undefined) return null
         try {
-          const got: unknown = await remote.hasMany(
-            ask,
-            ask.map((k) => atOf(k, byKey.get(k)!)),
-          )
-          if (!(got instanceof Set)) return null
-          for (const key of got) if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
+          const got: unknown = await remote.hasMany(ask)
+          if (!(got instanceof Map)) return null
+          for (const key of got.keys())
+            if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
         } catch {
           return null
         }
@@ -222,9 +217,9 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
 
     async getRun(name) {
       for (const { remote } of readers) {
-        for (const [i, key] of runReadKeys(name, scope).entries()) {
+        for (const key of runReadKeys(name, scope)) {
           try {
-            const got = await remote.get(key, i === 0 ? {} : at)
+            const got = await remote.get(key)
             if (got === null) continue
             const bytes = await capped(got.body, Infinity)
             if (bytes !== null) return bytes

package/src/cache/remote-lane.ts

@@ -6,7 +6,7 @@
 
 import { machineParallelism } from '../util/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
-import type { RemoteCacheLayer } from './layered-cache.js'
+import type { ArtifactInfo, RemoteCacheLayer } from './layered-cache.js'
 
 /** One remote, resolved: its wire and what the run's policy and its `access` let it do. */
 export interface ResolvedRemote {
@@ -48,6 +48,14 @@ function invalidRemoteResult(what: string): Error {
   )
 }
 
+/** A plugin's `ArtifactInfo`, keeping only the fields that are finite, non-negative numbers; null when it is no object. */
+function artifactInfo(value: unknown): ArtifactInfo | null {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return null
+  const { size, durationMs } = value as Record<string, unknown>
+  const ok = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n) && n >= 0
+  return { ...(ok(size) ? { size } : {}), ...(ok(durationMs) ? { durationMs } : {}) }
+}
+
 function isBody(value: unknown): value is Blob | Response {
   return value instanceof Blob || value instanceof Response
 }
@@ -106,14 +114,16 @@ export class RemoteLane {
    */
   private readonly absent = new Set<string>()
   /** What a `hasMany` said this remote holds, as `absent` records the rest. */
-  private readonly held = new Set<string>()
+  private readonly held = new Map<string, ArtifactInfo>()
 
   /**
    * A remote the run writes but does not read (`--force`): which of the
    * run's up-front keys it already holds, from one `hasMany`. `found` is
    * null when the probe failed.
    */
-  private presence: Promise<{ asked: Set<string>; found: Set<string> | null } | null> | undefined
+  private presence:
+    | Promise<{ asked: Set<string>; found: Map<string, ArtifactInfo> | null } | null>
+    | undefined
 
   private readonly uploadQueue: Array<() => Promise<void>> = []
   private activeUploads = 0
@@ -136,13 +146,11 @@ export class RemoteLane {
   constructor(
     resolved: ResolvedRemote,
     private readonly traffic: RemoteTraffic,
-    /** The wire as this run asks it: a branch scope's view of `resolved.remote`. */
-    remote: RemoteCacheLayer = resolved.remote,
     /** Background PUTs at once; excess uploads queue and drain FIFO. */
     private readonly uploadConcurrency: number = networkConcurrency(),
   ) {
     this.resolved = resolved
-    this.remote = remote
+    this.remote = resolved.remote
     this.onError = resolved.onError
     this.endpoint = printableEndpoint(resolved.remote.endpoint)
   }
@@ -159,15 +167,28 @@ export class RemoteLane {
    * Existence probe; a failure is a miss. A key a `hasMany` this run
    * answered for is not asked again: `--dry` batches its keys first.
    */
-  async has(hash: string): Promise<boolean> {
-    if (this.held.has(hash)) return true
-    if (this.absent.has(hash)) return false
+  async has(hash: string): Promise<ArtifactInfo | null> {
+    const held = this.held.get(hash)
+    if (held !== undefined) return held
+    if (this.absent.has(hash)) return null
+    let found: unknown
     try {
-      return Boolean(await this.remote.has(hash))
+      found = await this.remote.has(hash)
     } catch (err) {
       this.report('probe', hash, err)
-      return false
+      return null
     }
+    if (found === null || found === undefined) return null
+    const info = artifactInfo(found)
+    if (info === null)
+      this.report(
+        'probe',
+        hash,
+        invalidRemoteResult(
+          `has() resolved ${describeValue(found)} (expected { size, durationMs } or null)`,
+        ),
+      )
+    return info
   }
 
   /**
@@ -175,7 +196,7 @@ export class RemoteLane {
    * rest as absent; `null` when this remote cannot batch or the probe
    * failed, which the caller reads as "no batch info".
    */
-  async hasMany(hashes: readonly string[]): Promise<Set<string> | null> {
+  async hasMany(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null> {
     if (this.remote.hasMany === undefined) return null
     let found: unknown
     try {
@@ -185,24 +206,37 @@ export class RemoteLane {
       return null
     }
     if (found === null || found === undefined) return null
-    if (!(found instanceof Set)) {
+    if (!(found instanceof Map)) {
       this.report(
         'probe',
         batchOf(hashes),
         invalidRemoteResult(
-          `hasMany() resolved ${describeValue(found)} (expected a Set of the hashes present, or null)`,
+          `hasMany() resolved ${describeValue(found)} (expected a Map of the hashes present, or null)`,
         ),
       )
       return null
     }
-    const set = found as Set<string>
-    for (const h of hashes) (set.has(h) ? this.held : this.absent).add(h)
-    return set
+    const out = new Map<string, ArtifactInfo>()
+    for (const h of hashes) {
+      const info = found.has(h) ? (artifactInfo(found.get(h)) ?? {}) : undefined
+      if (info === undefined) this.absent.add(h)
+      else {
+        this.held.set(h, info)
+        out.set(h, info)
+      }
+    }
+    return out
   }
 
-  /** The artifact's body, or null on a miss, a known absence, a failure or a malformed answer. */
-  async get(hash: string): Promise<{ body: Blob | Response; durationMs?: number } | null> {
-    if (this.absent.has(hash)) return null
+  /**
+   * The artifact's body, or null on a miss, a known absence (unless
+   * `fresh`: saved since the probe), a failure or a malformed answer.
+   */
+  async get(
+    hash: string,
+    fresh = false,
+  ): Promise<{ body: Blob | Response; durationMs?: number } | null> {
+    if (!fresh && this.absent.has(hash)) return null
     let result: unknown
     try {
       result = await this.remote.get(hash)
@@ -225,7 +259,10 @@ export class RemoteLane {
       )
       return null
     }
-    return result as { body: Blob | Response; durationMs?: number }
+    // It holds the key: a save of it after this restore uploads nothing.
+    const got = result as { body: Blob | Response; durationMs?: number }
+    this.held.set(hash, got.durationMs === undefined ? {} : { durationMs: got.durationMs })
+    return got
   }
 
   /**
@@ -253,7 +290,7 @@ export class RemoteLane {
     const probed = await this.presence
     if (probed !== undefined && probed !== null && probed.found !== null && probed.asked.has(hash))
       return probed.found.has(hash)
-    return this.has(hash)
+    return (await this.has(hash)) !== null
   }
 
   /** Queue a PUT in this remote's bounded pool; `body` is asked for when the job starts. */
@@ -270,6 +307,7 @@ export class RemoteLane {
       let release: (() => Promise<void>) | undefined
       try {
         if (this.stopped) return
+        if (this.held.has(hash)) return
         if (!this.read && (await this.holds(hash))) return
         if (this.stopped) return
         const start = performance.now()

package/src/cache/run-history.ts

@@ -13,11 +13,12 @@ const INSERT_RUNS = `
         started_at, ended_at,
         run_id, cpu_ms, peak_rss_bytes, wallclock_start_ns, wallclock_end_ns,
         cache_hit, attempts, cached,
-        blocked_by, timed_out, sandbox_violations, not_ready, restored, remote_error
+        blocked_by, timed_out, sandbox_violations, not_ready, restored, remote_error,
+        peak_cores, avg_rss_bytes, placement, placement_cores, placement_memory, keyless_by
       )
       VALUES `
-/** One `runs` row's placeholders: the 23 columns `bindRun` fills. */
-const RUN_TUPLE = `(${Array(23).fill('?').join(', ')})`
+/** One `runs` row's placeholders: the 29 columns `bindRun` fills. */
+const RUN_TUPLE = `(${Array(29).fill('?').join(', ')})`
 
 /** An INSERT of `n` `runs` rows. */
 function insertRunsSql(n: number): string {
@@ -25,11 +26,11 @@ function insertRunsSql(n: number): string {
 }
 
 /**
- * Rows per INSERT: 40 × 23 variables stays under 999, the oldest default
+ * Rows per INSERT: 34 × 29 variables stays under 999, the oldest default
  * ceiling. A statement per row was 8.7 ms of 1,000 rows, 40 at a time 6.4
  * (2026-10-03).
  */
-const RUNS_PER_INSERT = 40
+const RUNS_PER_INSERT = 34
 
 /** Rows per `task_durations` INSERT: 6 variables each, under 999. */
 const DURATIONS_PER_INSERT = 160
@@ -236,7 +237,7 @@ export class RunHistory {
   }
 }
 
-/** Bind a RunRecord to one `RUN_TUPLE`'s 23 positional parameters. */
+/** Bind a RunRecord to one `RUN_TUPLE`'s 29 positional parameters. */
 function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBindings[] {
   return [
     // The ONE place the no-key sentinel is applied, so the column's
@@ -267,6 +268,12 @@ function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBi
     run.notReady ?? null,
     run.restored === undefined ? null : run.restored ? 1 : 0,
     run.remoteError ?? null,
+    run.peakCores ?? null,
+    run.avgRssBytes ?? null,
+    run.placement ?? null,
+    run.placementCores ?? null,
+    run.placementMemoryBytes ?? null,
+    run.keylessBy ?? null,
   ]
 }
 

package/src/cache/schema.ts

@@ -101,7 +101,18 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       restored            INTEGER,
       -- v40: each remote read or write of the key that failed, as
       -- 'upload: <message>', '; '-joined; NULL when none did.
-      remote_error        TEXT
+      remote_error        TEXT,
+      -- v43: the most cores one sampling interval burned and the mean
+      -- resident memory over the looks; NULL when nothing sampled.
+      peak_cores          REAL,
+      avg_rss_bytes       INTEGER,
+      -- v44: where an executor ran it (ExecuteResult.where) and that
+      -- machine's cores and memory; NULL = here.
+      placement           TEXT,
+      placement_cores     INTEGER,
+      placement_memory    INTEGER,
+      -- v46: the task with no inputs its key folded (TaskOutcome.keylessBy).
+      keyless_by          TEXT
     );
     -- 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
@@ -280,7 +291,13 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       source      TEXT NOT NULL,
       sha         TEXT,
       duration_ms INTEGER NOT NULL,
-      recorded_at INTEGER NOT NULL
+      recorded_at INTEGER NOT NULL,
+      -- v45: a 'remote' row's measured need (TaskResources); NULL on the
+      -- rest, whose need the run history holds.
+      cpu_parallelism        REAL,
+      peak_rss_bytes         INTEGER,
+      saturated_cores        INTEGER,
+      saturated_memory_bytes INTEGER
     );
     CREATE INDEX IF NOT EXISTS ${store}.task_durations_task
       ON task_durations(project, task, source, id);

package/src/cache/scoped-cache.ts

@@ -1,87 +1,10 @@
-// A branch's cache scope (owner, 2026-10-17): the local store never knows
-// one, so every branch shares one local pool under the task keys. Scopes
-// decide only which remote entry a task asks for: a task the branch changed
-// reads the scope's key, every other task the default key, and a scoped run
-// writes every remote under the scope's key. An artifact is packed under its
-// task key wherever it is stored, so a remote entry ingests under that key.
+// A scope keys only what plugins store themselves (ctx.cache, run records):
+// task keys reach every remote plain, and a remote decides which branch a
+// read may see (VZN, 2026-10-20).
 
 import { xxh3hex } from '../util/index.js'
-import type { RemoteCacheLayer, RemoteKey } from './layered-cache.js'
 
 /** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
 export function scopedKey(scope: string, hash: string): string {
   return xxh3hex(`vx-cache-scope\0${scope}\0${hash}`)
 }
-
-/**
- * Which remote key each task asks for, in a run with a scope. The routes
- * come from the branch's diff, which only a remote call awaits: a run the
- * local cache answers never waits on git.
- */
-export class BranchScope {
-  /** Finds the tasks that read the scope, at the first remote call; null: every task does. */
-  private route: (() => Promise<ReadonlySet<string>>) | null = null
-  private routes: Promise<ReadonlySet<string>> | null = null
-  /** Task key → its task. */
-  private readonly taskOf = new Map<string, string>()
-
-  constructor(readonly scope: string) {}
-
-  /** Only the tasks `ids` finds read the scope; set before any remote call. */
-  routeTasks(ids: () => Promise<ReadonlySet<string>>): void {
-    this.route = ids
-  }
-
-  noteKey(taskId: string, hash: string): void {
-    this.taskOf.set(hash, taskId)
-  }
-
-  /** The remote key `hash` is read under, and the scope it is read in (none: the default key). */
-  private async readKey(hash: string): Promise<{ key: string; at: RemoteKey }> {
-    const id = this.taskOf.get(hash)
-    if (this.route !== null) this.routes ??= this.route()
-    const tasks = this.routes === null ? null : await this.routes
-    return tasks !== null && id !== undefined && !tasks.has(id)
-      ? { key: hash, at: {} }
-      : { key: scopedKey(this.scope, hash), at: { scope: this.scope } }
-  }
-
-  /**
-   * `inner` as this run asks it: each task key under its route's key; every
-   * write under the scope's. Each call also names its scope, for a backend
-   * that keeps one store per scope; no wire vx ships sends it.
-   */
-  remote(inner: RemoteCacheLayer): RemoteCacheLayer {
-    const read = (h: string) => this.readKey(h)
-    const at: RemoteKey = { scope: this.scope }
-    const hasMany = inner.hasMany
-    return {
-      ...(inner.endpoint !== undefined ? { endpoint: inner.endpoint } : {}),
-      ...(inner.open !== undefined ? { open: (ctx) => inner.open!(ctx) } : {}),
-      has: async (h) => {
-        const r = await read(h)
-        return inner.has(r.key, r.at)
-      },
-      ...(hasMany !== undefined
-        ? {
-            hasMany: async (hashes) => {
-              const reads = await Promise.all(hashes.map(read))
-              const keys = reads.map((r) => r.key)
-              const found = await hasMany.call(
-                inner,
-                keys,
-                reads.map((r) => r.at),
-              )
-              if (!(found instanceof Set)) return found
-              return new Set(hashes.filter((_, i) => found.has(keys[i]!)))
-            },
-          }
-        : {}),
-      get: async (h) => {
-        const r = await read(h)
-        return inner.get(r.key, r.at)
-      },
-      put: (h, body, meta) => inner.put(scopedKey(this.scope, h), body, { ...meta, ...at }),
-    }
-  }
-}

package/src/cli/core-alias.ts

@@ -14,12 +14,15 @@
  * so a verb that never loads a plugin never loads the façade. The
  * source form (`bun src/bin.ts`) resolves the specifier to the same file
  * anyway; the alias makes that a guarantee rather than a layout fact.
+ * The loader is synchronous: the workspace config's bytecode bundle
+ * (workspace/config-bytecode.ts) is CommonJS, and `require` refuses a
+ * module whose loader is async.
  */
-export function registerCoreAlias(load: () => Promise<Record<string, unknown>>): void {
+export function registerCoreAlias(load: () => Record<string, unknown>): void {
   Bun.plugin({
     name: 'vx-core-alias',
     setup(build) {
-      build.module('@vzn/vx', async () => ({ exports: await load(), loader: 'object' }))
+      build.module('@vzn/vx', () => ({ exports: load(), loader: 'object' }))
     },
   })
 }

package/src/cli/help.ts

@@ -199,12 +199,6 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '  depends on none of them; a plain `vx run` never requires a plugin.',
     '  See the plugin guide: https://vznjs.github.io/vx/guides/plugins/',
     '',
-    'Turbo and Nx spellings (for run):',
-    '  What turbo run / nx run-many / nx affected take works here, or is refused',
-    '  naming the vx spelling: -t build,test, -p app, --exclude docs, --parallel 4,',
-    '  and --base main, --dry-run, --skip-nx-cache. `vx build` names `vx run build`.',
-    '  Every flag: https://vznjs.github.io/vx/cli/#turbo-and-nx-flags',
-    '',
     'Argument forwarding (for run):',
     "  Anything after `--` is forwarded (shell-quoted) to the task's exec",
     '  command. The forwarded args are folded into the cache key.',
@@ -264,10 +258,10 @@ export function helpText(pluginCommands: readonly string[] = []): string {
     '      --cache-dir <path>  Read the cache a run with the same flag uses.',
     '',
     'Migration:',
-    '  vx init              With no package.json: write .vx/workspace.ts and an empty',
-    '                       root vx.config.ts. With one: runs @vzn/vx-migrate, which maps',
-    '                       turbo.json, an Nx graph or package.json scripts to one',
-    '                       vx.config.ts per package (asking native or keep in Turbo/Nx).',
+    '  vx init              Install vx globally and as the root devDependency, then',
+    '                       write .vx/workspace.ts and an empty root vx.config.ts. In a',
+    '                       Turbo or Nx repo: runs @vzn/vx-migrate, which maps turbo.json',
+    '                       or the Nx graph to vx (asking native or keep).',
     '      --dry            Print the generated files instead of writing them.',
     '      --format json    With --dry: the plan as one JSON document (schemas/init.json).',
     '      --force          Overwrite existing vx.config.* files.',
@@ -356,6 +350,10 @@ export function flagHint(verb: string, arg: string): string {
   // `--json` is gh's and Nx's spelling; a verb with `--format` reads it
   // there, and no edit budget reaches `--format json` from `--json`.
   if (name === '--json' && flags.includes('--format')) return ' (did you mean --format json?)'
+  // `vx run` prints no JSON of its own, and edit distance reached `--force`
+  // from `--format`: a run with its cache reads turned off.
+  if ((name === '--format' || name === '--json') && flags.includes('--dry'))
+    return ' (the run as JSON is `vx last --format json` after it; the plan is --dry=json)'
   // A flag cut short at a word (`--dry` for prune's `--dry-run`, which
   // `vx run` spells `--dry`) is too many edits away for either budget.
   const cut = flags.filter((f) => f.startsWith(`${name}-`))

package/src/cli/index.ts

@@ -4,7 +4,6 @@
 import { VERSION } from '../version.js'
 import { checkSettingsEnv } from '../settings.js'
 import { CORE_VERBS, flagHint, printHelp, refusedWord, seeHelp } from './help.js'
-import { FOREIGN_VERBS } from './foreign-flags.js'
 import {
   errorDocument,
   hideEnvFromTasks,
@@ -99,11 +98,6 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         // for the whole reference: it printed 145 lines and no hint.
         const resolved = await (await plugins()).resolvePluginCommand(verb)
         const unknown = resolved === null || 'declaredVerbs' in resolved
-        const pointer = FOREIGN_VERBS[verb]
-        if (unknown && pointer !== undefined) {
-          sayNotice('info', 'vx', pointer)
-          return 1
-        }
         if (unknown && verb.startsWith('-')) {
           sayNotice(
             'error',
@@ -217,12 +211,6 @@ async function dispatch(command: string | undefined, rest: string[]): Promise<nu
         resolved !== null && 'loadError' in resolved
           ? `\n  (plugin verbs could not be looked up: .vx/workspace failed to load: ${resolved.loadError})`
           : ''
-      // Another tool's verb: the pointer, but only after the plugins had
-      // 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`, 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.
       const declaredVerbs =