@vzn/vx 0.0.143 → 0.0.145

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.143",
+  "version": "0.0.145",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.143",
-    "@vzn/vx-linux-arm64": "0.0.143",
-    "@vzn/vx-darwin-x64": "0.0.143",
-    "@vzn/vx-darwin-arm64": "0.0.143"
+    "@vzn/vx-linux-x64": "0.0.145",
+    "@vzn/vx-linux-arm64": "0.0.145",
+    "@vzn/vx-darwin-x64": "0.0.145",
+    "@vzn/vx-darwin-arm64": "0.0.145"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/git-inputs.ts

@@ -201,6 +201,30 @@ export class GitFilesCache extends Map<string, readonly string[]> {
     }
   }
 
+  /** Tracked files a task's clean removed this run, and whose clean (A-48). */
+  private trackedCleans: Array<{ path: string; by: string }> = []
+
+  /**
+   * Note which of the files a task's clean just removed git tracks. Called
+   * before `markOutputsChanged`, which drops their OIDs. A committed output
+   * another task reads with no edge to its producer is gone for as long as
+   * the producer runs (vueuse's `metadata/index.json`, N's dogfood), and the
+   * reader failed naming only the missing file (A-48).
+   */
+  noteClean(by: string, dir: string, rels: readonly string[]): void {
+    const oids = this.oids.get(dir)
+    if (oids === undefined) return
+    for (const rel of rels) {
+      const abs = path.resolve(dir, rel)
+      if (oids.has(abs)) this.trackedCleans.push({ path: abs, by })
+    }
+  }
+
+  /** The tracked files other tasks' cleans removed that are still missing. */
+  trackedCleansMissing(except: string): Array<{ path: string; by: string }> {
+    return this.trackedCleans.filter((c) => c.by !== except && !existsSync(c.path))
+  }
+
   /** Trusted index OIDs for a project (abs path → oid), if any survive. */
   oidsFor(projectDir: string): ReadonlyMap<string, string> | undefined {
     return this.oids.get(projectDir)

package/src/cli/foreign-flags.ts

@@ -0,0 +1,369 @@
+// What a Turbo or Nx 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
+// flag vx does not know was already a refusal, but one that named no way
+// on left a `turbo run --dry-run` user at a dead end. The table renders
+// cli.md's parity section (`renderForeignFlags`), pinned by a test.
+
+export interface ForeignFlag {
+  runner: 'turbo' | 'nx'
+  /** Every spelling, first the one shown. */
+  names: readonly string[]
+  /** It takes a value: `--flag <v>` or `--flag=<v>`. */
+  value: boolean
+  /** When only some values are foreign (`--continue=dependencies-successful`). */
+  when?: (value: string | undefined) => boolean
+  /** How the table shows a `when` row. */
+  shown?: string
+  outcome: 'same' | 'alias' | 'refuse'
+  /** The vx spelling, or what to use instead. */
+  vx: string
+  /** For an alias: the vx argv. For a refusal: none. */
+  to?: (value: string | undefined) => string[]
+}
+
+const list = (v: string | undefined): string[] =>
+  (v ?? '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s !== '')
+
+const GRAPH_IMAGE = /\.(svg|png|jpe?g|pdf|json|html|mermaid)$/i
+
+export const FOREIGN_FLAGS: readonly ForeignFlag[] = [
+  {
+    runner: 'turbo',
+    names: ['--filter'],
+    value: true,
+    outcome: 'same',
+    vx: '`--filter`, the same grammar (`...[ref]`, `{dir}`, `^`, `!`)',
+  },
+  {
+    runner: 'turbo',
+    names: ['--concurrency'],
+    value: true,
+    outcome: 'same',
+    vx: '`--concurrency <n|n%>`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--continue'],
+    value: true,
+    when: (v) => v === 'dependencies-successful',
+    shown: '`--continue=dependencies-successful`',
+    outcome: 'alias',
+    vx: '`--continue=deps-ok`',
+    to: () => ['--continue=deps-ok'],
+  },
+  {
+    runner: 'turbo',
+    names: ['--continue'],
+    value: false,
+    outcome: 'same',
+    vx: '`--continue[=never|deps-ok|always]`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--dry-run'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--dry[=text|json]`',
+    to: (v) => [v === undefined ? '--dry' : `--dry=${v}`],
+  },
+  {
+    runner: 'turbo',
+    names: ['--graph'],
+    value: true,
+    when: (v) => v !== undefined && GRAPH_IMAGE.test(v),
+    shown: '`--graph=<file>.svg|png|json|html|…`',
+    outcome: 'refuse',
+    vx: 'vx writes Graphviz DOT only: `--graph=<file>.dot`, then `dot -Tsvg`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--graph'],
+    value: false,
+    outcome: 'same',
+    vx: '`--graph[=<file>.dot]`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--force'],
+    value: false,
+    outcome: 'same',
+    vx: '`--force`: skip cache reads, keep writes',
+  },
+  {
+    runner: 'turbo',
+    names: ['--affected'],
+    value: false,
+    outcome: 'same',
+    vx: '`--affected[=<base>]`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--summarize'],
+    value: false,
+    outcome: 'same',
+    vx: '`--summarize[=<path>]`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--output-logs'],
+    value: true,
+    when: (v) => v === 'new-only',
+    shown: '`--output-logs=new-only`',
+    outcome: 'refuse',
+    vx: 'use `--output-logs=full` (a hit replays its log) or `errors-only`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--output-logs'],
+    value: true,
+    outcome: 'same',
+    vx: '`--output-logs full|errors-only|hash-only|none`',
+  },
+  { runner: 'turbo', names: ['--no-cache'], value: false, outcome: 'same', vx: '`--no-cache`' },
+  {
+    runner: 'turbo',
+    names: ['--cache'],
+    value: true,
+    outcome: 'same',
+    vx: '`--cache local:rw,remote:r`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--cache-dir'],
+    value: true,
+    outcome: 'same',
+    vx: '`--cache-dir <path>`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--profile'],
+    value: false,
+    outcome: 'same',
+    vx: '`--profile[=<path>]` (Chrome trace)',
+  },
+  {
+    runner: 'turbo',
+    names: ['--only'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--exclude-dependencies`',
+    to: () => ['--exclude-dependencies'],
+  },
+  {
+    runner: 'nx',
+    names: ['--parallel'],
+    value: true,
+    when: (v) => v !== undefined && v !== 'true',
+    shown: '`--parallel <n>`',
+    outcome: 'alias',
+    vx: '`--concurrency <n>` (`--parallel=false` is 1)',
+    to: (v) => ['--concurrency', v === 'false' ? '1' : (v ?? '')],
+  },
+  {
+    runner: 'turbo',
+    names: ['--parallel'],
+    value: false,
+    when: (v) => v === undefined || v === 'true',
+    shown: '`--parallel`',
+    outcome: 'refuse',
+    vx: 'vx always honours `dependsOn`; `--concurrency <n>` sets how many run at once',
+  },
+  {
+    runner: 'turbo',
+    names: ['--scope'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'use `--filter <pkg>`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--since'],
+    value: true,
+    outcome: 'refuse',
+    vx: "use `--filter '[<ref>]'` or `--affected=<ref>`",
+  },
+  {
+    runner: 'turbo',
+    names: ['--remote-only'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'use `--cache local:,remote:rw`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--remote-cache-read-only'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'use `--cache local:rw,remote:r`',
+  },
+  {
+    runner: 'turbo',
+    names: ['--token', '--team', '--api'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'a remote cache is a plugin: `turboCache()` from @vzn/vx-migrate in vx.workspace.ts reads TURBO_TOKEN / TURBO_TEAM / TURBO_API',
+  },
+  {
+    runner: 'turbo',
+    names: ['--no-daemon', '--daemon'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'vx has no daemon: drop it',
+  },
+  {
+    runner: 'turbo',
+    names: ['--ui', '--log-order', '--log-prefix'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'vx frames each task’s output: `--output-logs <mode>` sets how much',
+  },
+  {
+    runner: 'nx',
+    names: ['-t', '--targets', '--target'],
+    value: true,
+    outcome: 'alias',
+    vx: 'the task names, positional: `vx run build test`',
+    to: (v) => list(v),
+  },
+  {
+    runner: 'nx',
+    names: ['-p', '--projects'],
+    value: true,
+    outcome: 'alias',
+    vx: '`--filter <pattern>`, one per project',
+    to: (v) => list(v).flatMap((p) => ['--filter', p]),
+  },
+  {
+    runner: 'nx',
+    names: ['--exclude'],
+    value: true,
+    outcome: 'alias',
+    vx: "`--filter '!<pattern>'`, one per project",
+    to: (v) => list(v).flatMap((p) => ['--filter', `!${p}`]),
+  },
+  {
+    runner: 'nx',
+    names: ['--base'],
+    value: true,
+    outcome: 'alias',
+    vx: '`--affected=<ref>`',
+    to: (v) => [`--affected=${v ?? ''}`],
+  },
+  {
+    runner: 'nx',
+    names: ['--head'],
+    value: true,
+    when: (v) => v === 'HEAD',
+    shown: '`--head HEAD`',
+    outcome: 'alias',
+    vx: 'nothing: vx compares `--affected=<base>` with the working tree',
+    to: () => [],
+  },
+  {
+    runner: 'nx',
+    names: ['--head'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'vx compares `--affected=<base>` with the working tree: check out the head first',
+  },
+  {
+    runner: 'nx',
+    names: ['--skip-nx-cache'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--force`',
+    to: () => ['--force'],
+  },
+  { runner: 'nx', names: ['--all'], value: false, outcome: 'same', vx: '`--all`' },
+  {
+    runner: 'nx',
+    names: ['--nx-bail'],
+    value: false,
+    outcome: 'alias',
+    vx: '`--continue=never`',
+    to: () => ['--continue=never'],
+  },
+  {
+    runner: 'nx',
+    names: ['-c', '--configuration'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'a configuration is its own task: `vx run <target>:<configuration>`',
+  },
+  {
+    runner: 'nx',
+    names: ['--output-style'],
+    value: true,
+    outcome: 'refuse',
+    vx: 'use `--output-logs <mode>`',
+  },
+  {
+    runner: 'nx',
+    names: ['--uncommitted', '--untracked'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'use `--affected=HEAD` (the working tree against the last commit)',
+  },
+  {
+    runner: 'nx',
+    names: ['--no-cloud'],
+    value: false,
+    outcome: 'refuse',
+    vx: 'vx has no cloud: drop it',
+  },
+]
+
+/** Nx's verbs, as its users type them: `vx run` takes their flags. */
+export const FOREIGN_VERBS: Readonly<Record<string, string>> = {
+  'run-many':
+    '`nx run-many` is `vx run <task> --all` here; -t, -p, --exclude and --parallel work as they are',
+  affected:
+    '`nx affected` is `vx run <task> --affected` here; -t, --base and --exclude work as they are',
+}
+
+/**
+ * Rewrite each aliased foreign flag into its vx argv, or refuse the first
+ * refused one. A `same` flag and anything unknown pass through to the
+ * parser. Arguments after `--` are the task's and are never read.
+ */
+export function translateForeign(args: readonly string[]): string[] | { error: string } {
+  const out: string[] = []
+  const sep = args.indexOf('--')
+  const before = sep === -1 ? args : args.slice(0, sep)
+  for (let i = 0; i < before.length; i++) {
+    const a = before[i]!
+    const eq = a.indexOf('=')
+    const name = eq === -1 ? a : a.slice(0, eq)
+    const inline = eq === -1 ? undefined : a.slice(eq + 1)
+    const entries = FOREIGN_FLAGS.filter((f) => f.names.includes(name) || f.names.includes(a))
+    const next = before[i + 1]
+    const spaced = inline === undefined && next !== undefined && !next.startsWith('-')
+    const hit = entries.find((f) => {
+      const v = f.value ? (inline ?? (spaced ? next : undefined)) : inline
+      return f.when === undefined || f.when(v)
+    })
+    if (hit === undefined || hit.outcome === 'same') {
+      out.push(a)
+      continue
+    }
+    const v = hit.value ? (inline ?? (spaced ? next : undefined)) : inline
+    if (hit.value && inline === undefined && spaced) i++
+    if (hit.outcome === 'refuse') return { error: `${name} (${hit.runner}): ${hit.vx}` }
+    out.push(...hit.to!(v))
+  }
+  return sep === -1 ? out : [...out, ...args.slice(sep)]
+}
+
+/** cli.md's parity table, one row per entry. */
+export function renderForeignFlags(): string {
+  const rows = FOREIGN_FLAGS.map((f) => {
+    const flag = f.shown ?? f.names.map((n) => `\`${n}${f.value ? ' <v>' : ''}\``).join(', ')
+    return `| ${f.runner} | ${flag.replaceAll('|', '\\|')} | ${f.outcome} | ${f.vx.replaceAll('|', '\\|')} |`
+  })
+  return ['| runner | flag | outcome | in vx |', '| --- | --- | --- | --- |', ...rows].join('\n')
+}

package/src/cli/index.ts

@@ -6,6 +6,8 @@ import { VERSION } from '../version.js'
 import { runCmd } from './run.js'
 import { CORE_VERBS, printHelp } from './help.js'
 import { pluginCommandHelp, resolvePluginCommand, pluginVerbs } from './plugin-commands.js'
+import { FOREIGN_VERBS } from './foreign-flags.js'
+import { taskVerbHint } from './task-verb.js'
 import { isUserError, MOVED_VERBS, nearest, UserError } from '../util/index.js'
 
 // Every verb but `run` is imported when invoked. `vx run` is the hot path
@@ -45,8 +47,9 @@ export async function run(argv: readonly string[]): Promise<number> {
         // for the whole reference: it printed 145 lines and no hint.
         const resolved = await resolvePluginCommand(verb)
         const unknown = resolved === null || 'declaredVerbs' in resolved
-        if (unknown && MOVED_VERBS[verb] !== undefined) {
-          process.stderr.write(`${MOVED_VERBS[verb]}\n`)
+        const pointer = MOVED_VERBS[verb] ?? FOREIGN_VERBS[verb]
+        if (unknown && pointer !== undefined) {
+          process.stderr.write(`${pointer}\n`)
           return 1
         }
         if (unknown) {
@@ -127,11 +130,18 @@ export async function run(argv: readonly string[]): Promise<number> {
       // A verb core owned once (`migrate`, `prune`) and a package owns now:
       // the pointer, but only after the plugins had their chance — a
       // workspace that declares a plugin verb of that name keeps it.
-      const moved = MOVED_VERBS[command]
+      const moved = MOVED_VERBS[command] ?? FOREIGN_VERBS[command]
       if (moved !== undefined) {
         process.stderr.write(`${moved}${loadNote}\n`)
         return 1
       }
+      // 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 task = loadNote === '' ? await taskVerbHint(command, rest, process.cwd()) : null
+      if (task !== null) {
+        process.stderr.write(`vx: ${task}\n`)
+        return 1
+      }
       if (command === 'serve' || command === 'dev') {
         // vx core is only a task runner — it has no service layer of its
         // own. A dashboard, remote cache, distributed execution, etc. are

package/src/cli/run.ts

@@ -1,5 +1,6 @@
 import { appendFileSync, mkdirSync } from 'node:fs'
 import path from 'node:path'
+import { translateForeign } from './foreign-flags.js'
 import { flagHint, seeHelp } from './help.js'
 import { defaultAffectedBase, findWorkspaceRoot } from '../workspace/index.js'
 import {
@@ -109,7 +110,7 @@ export function parseConcurrency(v: string, cpus = machineParallelism()): number
   return n === null || n < 1 ? null : n
 }
 
-export function parseRunArgs(args: readonly string[]): RunArgs {
+export function parseRunArgs(rawArgs: readonly string[]): RunArgs {
   const out: RunArgs = {
     tasks: [],
     filters: [],
@@ -133,6 +134,10 @@ export function parseRunArgs(args: readonly string[]): RunArgs {
     reportFile: undefined,
   }
 
+  // A Turbo or Nx spelling becomes vx's, or a refusal naming vx's.
+  const translated = translateForeign(rawArgs)
+  if ('error' in translated) return { ...out, error: translated.error }
+  const args = translated
   const sepIdx = args.indexOf('--')
   const before = sepIdx === -1 ? args : args.slice(0, sepIdx)
   out.forwardArgs = sepIdx === -1 ? [] : args.slice(sepIdx + 1)

package/src/cli/task-verb.ts

@@ -0,0 +1,38 @@
+// `turbo build` runs the build; `nx build app` builds app. A Turbo or Nx
+// user types the task where vx wants a verb, and `vx build` answered
+// "unknown command" with no way on. The answer names the `vx run` that
+// does it. It stays a refusal: a verb that runs whatever task shares its
+// name would change meaning the day a plugin declares that verb.
+
+import { findWorkspaceRoot, listProjects, loadWorkspace } from '../workspace/index.js'
+import { findCwdProject } from './select.js'
+import { loadCliProjects } from './workspace-config.js'
+
+/** The `vx run` a task typed as a verb means, or null when no project declares it. */
+export async function taskVerbHint(
+  command: string,
+  rest: readonly string[],
+  cwd: string,
+): Promise<string | null> {
+  if (command.includes('#')) return `\`${command}\` is a task: vx run ${command}`
+  let projects: Awaited<ReturnType<typeof loadCliProjects>>
+  try {
+    const root = await findWorkspaceRoot(cwd)
+    projects = await loadCliProjects(root, await listProjects(await loadWorkspace(root)), 'all', {
+      noCreate: true,
+    })
+  } catch {
+    // No workspace, or a config that does not load: the plain unknown-command line stands.
+    return null
+  }
+  if (![...projects.values()].some((p) => p.config.tasks?.[command] !== undefined)) return null
+  // Nx's `nx build app`: the word after the target is its project.
+  const project = rest[0] !== undefined && projects.has(rest[0]) ? rest[0] : undefined
+  const run =
+    project !== undefined
+      ? `vx run ${command} --filter ${project}`
+      : (await findCwdProject(cwd)) === null
+        ? `vx run ${command} --all`
+        : `vx run ${command}`
+  return `\`${command}\` is a task here, not a command: ${run}`
+}

package/src/orchestrator/execute-task.ts

@@ -106,6 +106,8 @@ export interface ExecuteArgs {
    *  where a locally-placed consumer fetches its producers from. */
   deferred?: DeferredOutputs
   nestedProjectDirs: string[]
+  /** The run's cache directory: walled off from a sandboxed task's grants. */
+  cacheDir?: string
   /** Anchor for hrtime spans across all tasks in this run. */
   runStartHrTimeNs: bigint
   /**
@@ -312,6 +314,7 @@ async function executePersistentTask(args: ExecuteArgs): Promise<TaskOutcome> {
       args.workspaceRoot,
       undefined,
       args.nestedProjectDirs,
+      args.cacheDir,
     )
     placeholders = sb.placeholders
     const wrapped = await wrapSandboxedCommand({
@@ -757,6 +760,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       const endClean = span('miss: clean outputs')
       const cleanedRels = await cleanOutputs(cleanArgs)
       endClean()
+      args.gitFilesCache?.noteClean(node.id, node.projectDir, cleanedRels)
       args.gitFilesCache?.markOutputsChanged(node.projectDir, cleanedRels)
     }
     if (additive && willWrite && !deferralRequested && wsOutputs.length > 0) {
@@ -872,6 +876,18 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
         signal: res.signal,
       })
       if (verdict !== undefined) log.taskStderr(node, `\n${verdict}\n`)
+      // A committed file another task's clean removed, still gone: vx
+      // cleans outputs before a run where Turbo does not, so a reader with
+      // no edge to the producer fails naming only the file (A-48).
+      if (code !== 0) {
+        for (const c of (args.gitFilesCache?.trackedCleansMissing(node.id) ?? []).slice(0, 3)) {
+          const rel = path.relative(args.workspaceRoot, c.path).split(path.sep).join('/')
+          log.taskStderr(
+            node,
+            `\n[vx] ${rel} is tracked by git, and ${c.by} removed it as an output before its run; it is still missing. A task that reads it needs dependsOn on ${c.by}.\n`,
+          )
+        }
+      }
     }
     return { result: res, exitCode: code }
   }
@@ -1002,6 +1018,7 @@ async function executeCachedTask(args: ExecuteArgs): Promise<TaskOutcome> {
       args.workspaceRoot,
       cfgCacheable ? args.keyedProjects(node) : undefined,
       args.nestedProjectDirs,
+      args.cacheDir,
     )
     placeholders = sb.placeholders
     withheld = sb.withheld

package/src/orchestrator/run.ts

@@ -755,6 +755,7 @@ async function runOnBus(
         ...(placements.remoteOnlyNoop.has(node.id) ? { remoteOnlyNoop: true } : {}),
         ...(placements.remoteOnly.has(node.id) ? { remoteOnly: true } : {}),
         nestedProjectDirs: nestedDirsByProject.get(node.projectName) ?? [],
+        cacheDir,
         runStartHrTimeNs,
         persistentRegistry,
         liveChildren,

package/src/orchestrator/sandbox-request.ts

@@ -174,6 +174,12 @@ export async function sandboxRequestFor(
   keyed: ReadonlySet<string> | undefined,
   /** The projects nested in this one (their dirs): a wall its grants do not reach. */
   nested: readonly string[] = [],
+  /**
+   * The run's cache directory. `.vx` is walled wherever it is; a
+   * `cacheDir` configured inside a project was not, and a task whose write
+   * grant covered it could plant artifacts and index rows (L-24).
+   */
+  cacheDir?: string,
 ): Promise<SandboxRequest> {
   const depDirs = [
     path.join(node.projectDir, 'node_modules'),
@@ -192,9 +198,15 @@ export async function sandboxRequestFor(
   // Pre-create what the task said it will write — after the grants are
   // resolved, which refuses one that leaves the project through a link
   // before anything is created along it (item 1003).
-  const walls = [...nested, path.join(workspaceRoot, '.git'), path.join(workspaceRoot, '.vx')].map(
-    toRealPath,
-  )
+  const walls = [
+    ...nested,
+    path.join(workspaceRoot, '.git'),
+    path.join(workspaceRoot, '.vx'),
+    ...(cacheDir !== undefined &&
+    toRealPath(cacheDir).startsWith(toRealPath(workspaceRoot) + path.sep)
+      ? [cacheDir]
+      : []),
+  ].map(toRealPath)
   const config = wallOff(
     resolveSandboxConfig(sandbox, node.projectDir, walls),
     workspaceRoot,

package/src/workspace/migrate-scripts.ts

@@ -243,7 +243,20 @@ function upstreamBuildOnWorker(tasks: GeneratedTask[]): void {
 export function migrateScripts(metas: readonly ProjectMeta[]): MigrationPlan {
   const projects: GeneratedProject[] = []
   const hookMemo = new Map<string, boolean>()
+  // The workspace root among members: its scripts run the workspace
+  // (`npm run build --workspaces`, `pnpm -r build`), and a root task made
+  // of one ran every member's build again under `--all`. Since D-39 a
+  // hand-written root config makes the root a project, and `--force`
+  // replaced it so (D-45). A lone package is its repo's project and maps.
+  const root = metas.length > 1 ? workspaceRootOf(metas) : undefined
+  const notes: string[] = []
+  if (root !== undefined) {
+    notes.push(
+      `${root.name} (the workspace root) not mapped: its scripts run the workspace; declare its own tasks in its vx.config by hand`,
+    )
+  }
   for (const meta of metas) {
+    if (meta === root) continue
     const scripts = scriptsOf(meta)
     const runsHooks = runsScriptHooks(meta.dir, hookMemo)
     const runnable = Object.keys(scripts).filter(
@@ -350,6 +363,13 @@ export function migrateScripts(metas: readonly ProjectMeta[]): MigrationPlan {
     ],
     projects,
     extraFiles: [],
-    notes: [],
+    notes,
   }
 }
+
+/** The member whose directory holds every other member's, if one does. */
+function workspaceRootOf(metas: readonly ProjectMeta[]): ProjectMeta | undefined {
+  const outer = metas.reduce((a, b) => (b.dir.length < a.dir.length ? b : a))
+  const prefix = outer.dir.endsWith(path.sep) ? outer.dir : outer.dir + path.sep
+  return metas.every((m) => m === outer || m.dir.startsWith(prefix)) ? outer : undefined
+}