@vzn/vx 0.0.595 → 0.0.597

package/src/cache/chained-cache.ts

@@ -4,7 +4,8 @@
 // once. Restore goes to the layer that produced the hit — remembered per
 // hash — because an entry's artifact lives wherever it was found.
 //
-// A layer that throws in a lookup is a miss there and the walk goes on; one
+// A layer that throws in a lookup (a batch row load or a has-many included)
+// is a miss there and the walk goes on; a throwing drain is passed; one
 // that throws in a save is skipped and the rest still save. Unisolated, a
 // plugin layer's throw ended the walk before the local floor under it: its
 // `get` failed the task, its `save` kept the entry from every later layer
@@ -122,14 +123,22 @@ export class ChainedCache implements CacheLayer {
       const found = await this.ask(
         layer,
         'remoteHasMany',
-        async () => (await layer.remoteHasMany?.(hashes)) ?? null,
+        // The shape check and the mark sit inside the ask: a layer that
+        // answers a non-Set or throws marking gave no answer.
+        async () => {
+          const got: unknown = (await layer.remoteHasMany?.(hashes)) ?? null
+          if (got === null) return null
+          if (!(got instanceof Set)) throw new TypeError('remoteHasMany answered a non-Set')
+          const set = got as Set<string>
+          layer.markRemoteAbsent?.(hashes.filter((h) => !set.has(h)))
+          return set
+        },
         null,
       )
       if (found === null) {
         complete = false
         continue
       }
-      layer.markRemoteAbsent?.(hashes.filter((h) => !found.has(h)))
       out ??= new Set()
       for (const h of found) out.add(h)
     }
@@ -142,15 +151,24 @@ export class ChainedCache implements CacheLayer {
   }
 
   async drainUploads(): Promise<void> {
-    await Promise.all(this.layers.map((l) => l.drainUploads?.()))
+    await Promise.all(
+      this.layers.map((l) =>
+        this.ask(l, 'drainUploads', async () => l.drainUploads?.(), undefined),
+      ),
+    )
   }
 
   loadOutputFilesBatch(hashes: readonly string[]): Map<string, OutputFileRow[]> {
     const out = new Map<string, OutputFileRow[]>()
-    for (const layer of this.layers) {
-      for (const [h, rows] of layer.loadOutputFilesBatch(hashes)) {
-        if (!out.has(h)) out.set(h, rows)
+    for (const [i, layer] of this.layers.entries()) {
+      let rows: Map<string, OutputFileRow[]>
+      try {
+        rows = layer.loadOutputFilesBatch(hashes)
+      } catch (err) {
+        this.onLayerError(i, 'loadOutputFilesBatch', err)
+        continue
       }
+      for (const [h, r] of rows) if (!out.has(h)) out.set(h, r)
     }
     return out
   }

package/src/cache/git-inputs.ts

@@ -87,6 +87,29 @@ export function repoFacts(dir: string): RepoFacts | null {
   return facts
 }
 
+/**
+ * The refusal a run would meet at its enumeration, asked up front by a
+ * verb that waits on the user first (the picker); undefined when git
+ * tracks `dir`. Free when it does: `repoFacts` is the answer the run
+ * reuses.
+ */
+export function gitRefusal(dir: string): UserError | undefined {
+  if (repoFacts(dir) !== null) return undefined
+  let proc
+  try {
+    proc = Bun.spawnSync({
+      cmd: [executablePath('git'), 'rev-parse', '--is-inside-work-tree'],
+      cwd: dir,
+      stdout: 'ignore',
+      stderr: 'pipe',
+    })
+  } catch {
+    return gitSpawnRefusal(dir)
+  }
+  if (proc.exitCode === 0) return undefined
+  return notAWorkTree(dir, new TextDecoder().decode(proc.stderr).trim())
+}
+
 /** Variables that move where git finds the repository or its index: with any set, git is asked. */
 const GIT_LOCATION_ENV = [
   'GIT_INDEX_FILE',

package/src/cache/index.ts

@@ -11,6 +11,7 @@ export {
   type CacheKeyInput,
   type CacheLayer,
   type CachePolicy,
+  cachesNothing,
   EXECUTED_RUNS_SQL,
   FULL_CACHE_POLICY,
   type InvocationRecord,
@@ -35,6 +36,7 @@ export {
   cleanOutputs,
   cleanWorkspaceOutputs,
   declaresInput,
+  workspaceFilesReachInto,
   resolveInputs,
   resolveOutputs,
   resolveWorkspaceOutputs,
@@ -51,6 +53,7 @@ export {
 } from './inputs.js'
 export {
   GitFilesCache,
+  gitRefusal,
   applyGitEnumeration,
   gitPathspecs,
   MAX_SCOPED_PATHSPECS,

package/src/cache/inputs.ts

@@ -17,7 +17,7 @@
 // be a git work tree; non-git environments are not supported.
 
 import path from 'node:path'
-import { lstatSync, readdirSync, realpathSync, rmdirSync, rmSync } from 'node:fs'
+import { lstatSync, readdirSync, realpathSync, rmdirSync, rmSync, statSync } from 'node:fs'
 import { rm, rmdir } from 'node:fs/promises'
 import type { CacheConfig, CacheInputs } from '../config.js'
 import {
@@ -33,6 +33,7 @@ import {
   slashBraceExpansions,
   splitNegations,
   staticPrefix,
+  stripTrailingSlash,
   taskGlob,
   UserError,
 } from '../util/index.js'
@@ -109,10 +110,10 @@ export interface ResolveInputsArgs {
   envSource: NodeJS.ProcessEnv
   inputs: CacheInputs | undefined
   /** Project-relative output globs to exclude from inputs. */
-  ownOutputs: string[]
+  ownOutputs: readonly string[]
   /** Root-relative `outputs.workspaceFiles` globs to exclude from
    *  `inputs.workspaceFiles` (a task cannot invalidate itself). */
-  ownWorkspaceOutputs?: string[]
+  ownWorkspaceOutputs?: readonly string[]
   /** Absolute dirs of nested projects (cross-boundary isolation). */
   nestedProjectDirs: string[]
   /**
@@ -643,18 +644,24 @@ function outputExcludes(outputs: readonly string[]): Bun.Glob[] {
   return (namesNodeModules ? OUTPUT_NEVER : [...OUTPUT_NEVER, '**/node_modules/**']).map(globFor)
 }
 
-/** Resolve declared output globs (project-relative) to actual produced files. */
+/**
+ * Resolve declared output globs (project-relative) to actual produced files.
+ * An output directory linked out of the project is refused by name (X-88):
+ * dropping its files silently saved an empty entry under a green run.
+ */
 export async function resolveOutputs(args: {
   projectDir: string
-  outputs: string[]
+  outputs: readonly string[]
   nestedProjectDirs: string[]
 }): Promise<string[]> {
   const { positive, negative } = splitNegations(args.outputs)
   if (positive.length === 0) return []
   const excludeGlobs = [...outputExcludes(positive), ...asTrees(negative).map(globFor)]
+  const trees = asTrees(positive)
+  refuseDirLinkedOut(args.projectDir, trees)
   const scanned = [
     ...(await scanUnion(
-      asTrees(positive),
+      trees,
       excludeGlobs,
       args.projectDir,
       inNestedProject(args.projectDir, args.nestedProjectDirs),
@@ -670,6 +677,53 @@ export async function resolveOutputs(args: {
   return containedIn(args.projectDir, scanned).sort()
 }
 
+/**
+ * The literal head of each output glob, walked: the scan follows a link
+ * there (`dist -> ../elsewhere` for `dist/**`) and only there. A link to a
+ * FILE is the archive's to judge (L-23); a dangling one the restore's.
+ */
+function refuseDirLinkedOut(projectDir: string, trees: readonly string[]): void {
+  let realRoot: string | undefined
+  for (const tree of trees) {
+    let at = projectDir
+    for (const part of staticPrefix(tree).split('/')) {
+      if (part === '' || part === '.') continue
+      at = path.join(at, part)
+      if (!isInside(projectDir, at)) break
+      let st
+      try {
+        st = lstatSync(at)
+      } catch {
+        break
+      }
+      if (!st.isSymbolicLink()) continue
+      let real: string
+      try {
+        real = realpathSync(at)
+        if (!statSync(real).isDirectory()) break
+      } catch {
+        break
+      }
+      realRoot ??= realOr(projectDir)
+      if (!isInside(realRoot, real)) {
+        throw new UserError(
+          `${at} is a symbolic link to ${real}, outside ${projectDir} — vx never cleans, saves ` +
+            'or restores declared outputs through a link that leaves the project. Remove the ' +
+            'link and re-run, or stop declaring outputs under it.',
+        )
+      }
+    }
+  }
+}
+
+function realOr(p: string): string {
+  try {
+    return realpathSync(p)
+  } catch {
+    return p
+  }
+}
+
 /**
  * Keep only the paths that are REALLY inside `root` — lexically, and after
  * resolving symlinks.
@@ -708,16 +762,9 @@ function containedIn(root: string, paths: readonly string[]): string[] {
   // Sync, as `hashFile`'s lstat: a realpath is microseconds, and the
   // promise round trip per call was most of this function's cost on every
   // miss (B, 2026-09-30).
-  const real = (p: string): string | null => {
-    try {
-      return realpathSync(p)
-    } catch {
-      return null
-    }
-  }
-  const realRoot = real(root) ?? root
+  const realRoot = realOrNull(root) ?? root
   const uniqueDirs = [...new Set(lexDirs)]
-  const resolved = uniqueDirs.map(real)
+  const resolved = uniqueDirs.map(realOrNull)
   const contained = new Set<string>()
   for (const [i, dir] of uniqueDirs.entries()) {
     const real = resolved[i]
@@ -747,7 +794,7 @@ function isInside(dir: string, abs: string): boolean {
  */
 export async function cleanOutputs(args: {
   projectDir: string
-  outputs: string[]
+  outputs: readonly string[]
   nestedProjectDirs: string[]
 }): Promise<string[]> {
   const files = await resolveOutputs(args)
@@ -801,7 +848,7 @@ export interface OutputStamp {
  */
 export async function stampOutputs(args: {
   projectDir: string
-  outputs: string[]
+  outputs: readonly string[]
   nestedProjectDirs: string[]
 }): Promise<Map<string, OutputStamp>> {
   return stampFiles(await resolveOutputs(args))
@@ -810,7 +857,7 @@ export async function stampOutputs(args: {
 /** `stampOutputs` for root-anchored `cache.outputs.workspaceFiles` (A-43). */
 export async function stampWorkspaceOutputs(args: {
   workspaceRoot: string
-  outputs: string[]
+  outputs: readonly string[]
 }): Promise<Map<string, OutputStamp>> {
   return stampFiles(await resolveWorkspaceOutputs(args))
 }
@@ -841,7 +888,7 @@ function stampFiles(files: readonly string[]): Map<string, OutputStamp> {
  * file back, so no entry reproduces that run and none is saved.
  */
 export async function ownOutputsSince(
-  args: { projectDir: string; outputs: string[]; nestedProjectDirs: string[] },
+  args: { projectDir: string; outputs: readonly string[]; nestedProjectDirs: string[] },
   before: ReadonlyMap<string, OutputStamp>,
 ): Promise<string[] | undefined> {
   return changedSince(await resolveOutputs(args), before)
@@ -849,7 +896,7 @@ export async function ownOutputsSince(
 
 /** `ownOutputsSince` for root-anchored `cache.outputs.workspaceFiles` (A-43). */
 export async function ownWorkspaceOutputsSince(
-  args: { workspaceRoot: string; outputs: string[] },
+  args: { workspaceRoot: string; outputs: readonly string[] },
   before: ReadonlyMap<string, OutputStamp>,
 ): Promise<string[] | undefined> {
   return changedSince(await resolveWorkspaceOutputs(args), before)
@@ -899,7 +946,7 @@ const SYNC_CLEAN_MAX = 128
  * sends the reader to file a bug against a permission bit.
  */
 async function removeAll(all: readonly string[], root: string): Promise<string[]> {
-  const files = notThroughLink(all, root)
+  const files = insideRoot(all, root)
   const refused = (f: string, err: NodeJS.ErrnoException): UserError => {
     const rel = relPosix(root, f)
     return new UserError(
@@ -929,21 +976,14 @@ async function removeAll(all: readonly string[], root: string): Promise<string[]
 }
 
 /**
- * The paths whose directory is really where it sits, not reached through a
- * symlinked directory. A save follows `dist -> real-out` on purpose
- * (turborepo#13042), but a clean through a link deletes the target's
- * files: `public -> static` in the same project took the tracked
- * `static/logo.svg` before every run (X-5). The link is a declared
- * output's own entry; what it leads to is not.
+ * The paths whose directory resolves inside `root`. A link inside the
+ * project is followed, as the save follows it (turborepo#13042): a clean
+ * that skipped `dist -> real-out` left the last run's files for the next
+ * entry to save (X-88). One that leaves the project is never deleted
+ * through (X-5); `cleanOutputPaths` takes recorded rows, not the resolver's
+ * contained set, so the check is here too.
  */
-function notThroughLink(files: readonly string[], root: string): string[] {
-  const real = (p: string): string | null => {
-    try {
-      return realpathSync(p)
-    } catch {
-      return null
-    }
-  }
+function insideRoot(files: readonly string[], root: string): string[] {
   // Resolved only once a directory exists to compare: after a clean pruned
   // the outputs (the common restore) nothing does, and the call was most
   // of an empty clean.
@@ -955,9 +995,8 @@ function notThroughLink(files: readonly string[], root: string): string[] {
     if (ok === undefined) {
       // A directory already gone has nothing to delete through; its path
       // stays so the prune still reaches the parents it emptied.
-      const r = real(dir)
-      ok =
-        r === null || r === path.join((realRoot ??= real(root) ?? root), path.relative(root, dir))
+      const r = realOrNull(dir)
+      ok = r === null || isInside((realRoot ??= realOrNull(root) ?? root), r)
       own.set(dir, ok)
     }
     return ok
@@ -1067,7 +1106,7 @@ function inScope(dir: string, scope: PruneScope): boolean {
  */
 export async function resolveWorkspaceOutputs(args: {
   workspaceRoot: string
-  outputs: string[]
+  outputs: readonly string[]
 }): Promise<string[]> {
   const { positive, negative } = splitNegations(args.outputs)
   if (positive.length === 0) return []
@@ -1090,7 +1129,7 @@ export async function resolveWorkspaceOutputs(args: {
  */
 export async function cleanWorkspaceOutputs(args: {
   workspaceRoot: string
-  outputs: string[]
+  outputs: readonly string[]
 }): Promise<string[]> {
   const files = await resolveWorkspaceOutputs(args)
   await pruneEmptiedDirs(
@@ -1101,8 +1140,12 @@ export async function cleanWorkspaceOutputs(args: {
   return files.map((f) => relPosix(args.workspaceRoot, f))
 }
 
-function stripTrailingSlash(p: string): string {
-  return p.replace(/\/+$/, '')
+function realOrNull(p: string): string | null {
+  try {
+    return realpathSync(p)
+  } catch {
+    return null
+  }
 }
 
 // The literal-is-a-tree rule moved to `util/paths.ts` (item 442): it
@@ -1195,8 +1238,8 @@ async function assertNoInvisibleLiteralInputs(
 interface ResolveFilesArgs {
   projectDir: string
   workspaceRoot: string
-  files: string[] | undefined
-  ownOutputs: string[]
+  files: readonly string[] | undefined
+  ownOutputs: readonly string[]
   /** Root-relative `outputs.workspaceFiles`, and the project's root-relative directory. */
   ownWorkspaceOutputs: readonly string[]
   projectRel: string
@@ -1356,6 +1399,18 @@ export function declaresInput(
   return matcher(workspaceRel)
 }
 
+/**
+ * Whether a cached task's `workspaceFiles` may name a file under `dir`
+ * (workspace-relative): a nested repository git reports as that one path,
+ * whose files the key folds and a match against the path alone misses.
+ * By the entries' static prefixes, so a glob that may descend counts.
+ */
+export function workspaceFilesReachInto(cache: CacheConfig, dir: string): boolean {
+  const ws = cache.inputs.workspaceFiles
+  if (ws === undefined || ws.length === 0) return false
+  return reaches(reachOf(splitNegations(ws).positive).prefixes, dir)
+}
+
 function inPlan(plan: FilesPlan, rel: string): boolean {
   let input = plan.verdicts.get(rel)
   if (input === undefined) {

package/src/cache/key-fold.ts

@@ -103,7 +103,7 @@ import type { CacheKeyInput } from './layer.js'
 // bytes on disk, the filter since removed, holds the CRLF build (A-60).
 // v39: an entry saved while a gitlink without `.git` held files the key
 // never listed sits under the key of that directory empty (A-61).
-export const CACHE_VERSION = 'vx-cache-v40'
+export const CACHE_VERSION = 'vx-cache-v41'
 
 /**
  * The digest a key folds for an input gone between its enumeration and its

package/src/cache/layer.ts

@@ -296,7 +296,8 @@ export interface PruneOptions {
   olderThanMs?: number
   /**
    * After applying olderThanMs, if the cache still exceeds this size in
-   * bytes, evict LRU (smallest `accessed_at` first) until under it.
+   * bytes, evict LRU (smallest `accessed_at` first, a row-less artifact
+   * by its file time) until under it.
    */
   maxBytes?: number
   /**
@@ -312,10 +313,11 @@ export interface PruneResult {
   /** Bytes the evicted entries occupied, per the index. */
   bytesFreed: number
   /**
-   * Artifacts and temp files with no index row, unlinked by the orphan
-   * sweep that runs after eviction (a `SCHEMA_VERSION` drop, a deleted
-   * `cache.db`, a save that crashed before its rename). Files younger
-   * than one hour are never counted: they may be a save in flight.
+   * Artifacts and temp files with no index row, unlinked by the same
+   * policy (another vx version's open dropped the row, a deleted
+   * `cache.db`, a save that crashed before its rename). An artifact's file
+   * time plus an hour stands for its last use; a temp goes once an hour
+   * old. Files younger than one hour are never counted.
    */
   orphans: number
   /** Bytes the reaped orphans occupied on disk. */
@@ -330,7 +332,8 @@ export interface PruneResult {
  * discriminator — least-invasive row format, no schema change. A
  * project output dir literally named `workspace-outputs/` would
  * collide with the namespace; the name is reserved, and a project
- * output glob under it is refused at load (config-schema.ts).
+ * output glob under it is refused at load (config-schema.ts), a file
+ * another glob reaches there at save (`planArtifact`).
  */
 export const WORKSPACE_OUTPUT_PREFIX = 'workspace-outputs/'
 

package/src/cache/policy.ts

@@ -36,6 +36,11 @@ export const FULL_CACHE_POLICY: CachePolicy = {
   remoteWrite: true,
 }
 
+/** No axis on (`--no-cache`, `--cache=local:`): no cache answers for any task. */
+export function cachesNothing(p: CachePolicy): boolean {
+  return !(p.localRead || p.localWrite || p.remoteRead || p.remoteWrite)
+}
+
 /**
  * Parse a `--cache=<spec>` value into a `CachePolicy`, starting from a
  * base (defaults to {@link FULL_CACHE_POLICY}). The spec is a

package/src/cache/zstd.ts

@@ -194,15 +194,21 @@ export async function decodedTar(
     }
     return oneChunk(await zstdDecompressBounded(source, hash, cap))
   }
+  // A BunFile reads no further than the size its first stat cached, and a
+  // save or ingest of the same key may rename a longer copy over the path
+  // after that stat: the read came back cut short, the restore called the
+  // new artifact corrupt and dropped it. The size only picks the decode;
+  // each read goes through a handle that has not stat the path yet.
+  const fresh = (): Bun.BunFile => Bun.file(source.name!)
   if (source.size <= STREAM_DECODE_FROM) {
-    const bytes = await source.bytes()
+    const bytes = await fresh().bytes()
     if (assertDeclaredSize(bytes, hash, cap) === null || !isOneFrame(bytes)) {
-      return zstdDecodeStream(source, hash, cap)
+      return zstdDecodeStream(new Blob([bytes]), hash, cap)
     }
     return oneChunk(await zstdDecompressBounded(bytes, hash, cap))
   }
-  assertDeclaredSize(await source.slice(0, 32).bytes(), hash, cap)
-  return zstdDecodeStream(source, hash, cap)
+  assertDeclaredSize(await fresh().slice(0, 32).bytes(), hash, cap)
+  return zstdDecodeStream(fresh(), hash, cap)
 }
 
 /**

package/src/cli/cache.ts

@@ -85,10 +85,15 @@ export function parsePruneArgs(args: readonly string[]): PruneArgs {
     if (a === '--older-than' || a?.startsWith('--older-than=')) {
       const v = a === '--older-than' ? args[++i] : a.slice('--older-than='.length)
       if (v === undefined || v === '') {
-        return { error: `--older-than requires a value (e.g. 30d, 24h, 60m)` }
+        return {
+          error: `--older-than requires a value: a duration like 30d, 24h or 60m${seeHelp('cache')}`,
+        }
       }
       const ms = parseDuration(v)
-      if (ms === null) return { error: `invalid duration: ${v} (e.g. 30d, 24h, 60m)` }
+      if (ms === null)
+        return {
+          error: `--older-than must be a duration like 30d, 24h or 60m (got ${v})${seeHelp('cache')}`,
+        }
       // `0d` evicts everything ever cached. That is far more often a
       // computed-to-zero retention than an intent, and no other flag
       // combination expresses "wipe the cache" — so refuse it and name
@@ -102,10 +107,11 @@ export function parsePruneArgs(args: readonly string[]): PruneArgs {
     } else if (a === '--max-size' || a?.startsWith('--max-size=')) {
       const v = a === '--max-size' ? args[++i] : a.slice('--max-size='.length)
       if (v === undefined || v === '') {
-        return { error: `--max-size requires a value (e.g. 500M, 1G)` }
+        return { error: `--max-size requires a value: a size like 500M or 1G${seeHelp('cache')}` }
       }
       const bytes = parseSize(v)
-      if (bytes === null) return { error: `invalid size: ${v} (e.g. 500M, 1G)` }
+      if (bytes === null)
+        return { error: `--max-size must be a size like 500M or 1G (got ${v})${seeHelp('cache')}` }
       if (bytes === 0) {
         return {
           error: `--max-size 0 would evict every entry — to clear the cache, delete the cache store \`vx info\` names`,
@@ -134,13 +140,13 @@ export function parsePruneArgs(args: readonly string[]): PruneArgs {
         return {
           error: `${refusedWord(a ?? '')}: ${a}${flagHint('cache prune', a ?? '')}${seeHelp('cache')}`,
         }
-      if ('error' in cd) return { error: cd.error }
+      if ('error' in cd) return { error: `${cd.error}${seeHelp('cache')}` }
       out.cacheDir = cd.cacheDir
       i = cd.next
     }
   }
   if (out.olderThanMs === undefined && out.maxBytes === undefined) {
-    return { error: 'must pass --older-than <duration> or --max-size <bytes>' }
+    return { error: `needs --older-than <duration> or --max-size <size>${seeHelp('cache')}` }
   }
   return out
 }

package/src/cli/foreign-flags.ts

@@ -1,4 +1,4 @@
-// What a Turbo or Nx user's hands type, and what `vx run` does with it.
+// What a Turbo, Nx or Vite Task (`vp run`) user's hands type, and what `vx run` does with it.
 // Every flag here has one outcome: vx takes it as it is (`same`), takes it
 // as another spelling (`alias`, rewritten before the parse), or refuses it
 // with the vx way to say it (`refuse`). Nothing is dropped in silence: a
@@ -7,7 +7,7 @@
 // cli.md's parity section (`renderForeignFlags`), pinned by a test.
 
 interface ForeignFlag {
-  runner: 'turbo' | 'nx'
+  runner: 'turbo' | 'nx' | 'vp'
   /** Every spelling, first the one shown. */
   names: readonly string[]
   /** It takes a value: `--flag <v>` or `--flag=<v>`. */
@@ -375,7 +375,7 @@ export const FOREIGN_FLAGS: readonly ForeignFlag[] = [
     names: ['--preflight'],
     value: false,
     outcome: 'refuse',
-    vx: '`turboCache()` sends no CORS preflight: drop it',
+    vx: 'set `turboCache({ preflight: true })` or `TURBO_PREFLIGHT=1`',
   },
   {
     runner: 'turbo',
@@ -598,6 +598,60 @@ export const FOREIGN_FLAGS: readonly ForeignFlag[] = [
     outcome: 'refuse',
     vx: 'vx has no cloud: drop it',
   },
+  {
+    runner: 'vp',
+    names: ['-r', '--recursive'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--all`',
+    to: () => ['--all'],
+  },
+  {
+    runner: 'vp',
+    names: ['-w', '--workspace-root'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--filter //` (the root project)',
+    to: () => ['--filter', '//'],
+  },
+  {
+    runner: 'vp',
+    names: ['--concurrency-limit'],
+    value: true,
+    outcome: 'alias',
+    vx: '`--concurrency <n>`',
+    to: (v) => (v === undefined ? ['--concurrency'] : ['--concurrency', v]),
+  },
+  {
+    runner: 'vp',
+    names: ['--ignore-depends-on'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--exclude-dependencies`',
+    to: () => ['--exclude-dependencies'],
+  },
+  {
+    runner: 'vp',
+    names: ['--fail-if-no-match'],
+    value: false,
+    outcome: 'alias',
+    vx: 'nothing: a filter that matches nothing already fails the run',
+    to: () => [],
+  },
+  {
+    runner: 'vp',
+    names: ['--log'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'vx frames each task’s output: `--output-logs <mode>` sets how much',
+  },
+  {
+    runner: 'vp',
+    names: ['--last-details'],
+    value: false,
+    outcome: 'refuse',
+    vx: '`vx last` prints the last run',
+  },
 ]
 
 /** Nx's verbs, as its users type them: `vx run` takes their flags. */

package/src/cli/info.ts

@@ -29,7 +29,7 @@ export function parseInfoArgs(args: readonly string[]): InfoArgs {
     }
     const cd = parseCacheDirFlag(args, i)
     if (cd !== null) {
-      if ('error' in cd) return { ...out, error: cd.error }
+      if ('error' in cd) return { ...out, error: `${cd.error}${seeHelp('info')}` }
       out.cacheDir = cd.cacheDir
       i = cd.next
       continue

package/src/cli/init.ts

@@ -42,7 +42,7 @@ export function parseInitArgs(args: readonly string[]): InitArgs {
       if (seam === undefined || !Object.hasOwn(PLUGIN_TEMPLATES, seam)) {
         return {
           ...out,
-          error: `--plugin takes a seam: one of ${seams}${seam === undefined ? '' : ` (got '${seam}')`}`,
+          error: `--plugin takes a seam: one of ${seams}${seam === undefined ? '' : ` (got '${seam}')`}${seeHelp('init')}`,
         }
       }
       out.plugin = seam
@@ -56,7 +56,7 @@ export function parseInitArgs(args: readonly string[]): InitArgs {
   if (out.plugin !== undefined && out.mjs) {
     return {
       ...out,
-      error: '--mjs does not combine with --plugin: the plugin templates are TypeScript',
+      error: `--mjs does not combine with --plugin: the plugin templates are TypeScript${seeHelp('init')}`,
     }
   }
   return out