@vzn/vx-migrate 0.0.635 → 0.0.637

package/src/paths.ts

@@ -13,7 +13,7 @@
 // cheapest moment to collapse a duplicate is before it does.
 
 import path from 'node:path'
-import type { ProjectMeta } from '@vzn/vx'
+import type { PackageMeta } from './packages.js'
 
 /** `to` relative to `from`, POSIX-separated — core's `relPosix`, which is not on the façade. */
 export function relPosix(from: string, to: string): string {
@@ -30,7 +30,7 @@ export function relPosix(from: string, to: string): string {
  * mappers did not. Null-prototype, so a turbo.json task or Nx target named
  * `constructor` or `toString` finds no script rather than Object's method.
  */
-export function packageScripts(meta: ProjectMeta): Record<string, unknown> {
+export function packageScripts(meta: PackageMeta): Record<string, unknown> {
   const raw = (meta.packageJson as unknown as { scripts?: unknown }).scripts
   const scripts: Record<string, unknown> = Object.create(null)
   if (!isRecord(raw)) return scripts

package/src/remote-cache.ts

@@ -0,0 +1,118 @@
+// The remote cache a Turbo or Nx repo already uses, as the repo shows it,
+// so the workspace file a migration writes keeps sharing it: native or
+// keep, from `vx init` or `bunx @vzn/vx-migrate` (M, 2026-10-14). Nx
+// Cloud's wire is Nx's own, so it is named, never declared.
+
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+
+/** The cache plugin each runner's remote speaks through, from this package. */
+export const REMOTE_CACHE = { turbo: 'turboCache', nx: 'nxCache' } as const
+
+/** The variable each runner's self-hosted remote cache is set by, as its plugin reads it. */
+const REMOTE_CACHE_ENV = { turbo: 'TURBO_TOKEN', nx: 'NX_SELF_HOSTED_REMOTE_CACHE_SERVER' } as const
+
+const CI_FILES = ['.gitlab-ci.yml', '.circleci/config.yml']
+
+/**
+ * Where the repo shows a remote cache its runner uses, or undefined:
+ * turbo.json's enabled `remoteCache`, a `turbo link`ed `.turbo/config.json`,
+ * or a CI file that sets the runner's cache variable (a local repo holds
+ * no token; CI does).
+ */
+export function remoteCacheSignal(root: string, runner: 'turbo' | 'nx'): string | undefined {
+  if (runner === 'turbo') {
+    for (const f of ['turbo.json', 'turbo.jsonc']) {
+      let rc: unknown
+      try {
+        rc = (
+          Bun.JSONC.parse(readFileSync(path.join(root, f), 'utf8')) as { remoteCache?: unknown }
+        )?.remoteCache
+      } catch {
+        continue
+      }
+      if (typeof rc === 'object' && rc !== null) {
+        // Turned off in turbo.json is off, whatever CI sets.
+        if ((rc as { enabled?: unknown }).enabled === false) return undefined
+        return `${f} names a remoteCache`
+      }
+    }
+    // `turbo link` writes the team here (gitignored, on the machine that
+    // linked); turboCache() reads it, so a linked repo has a remote cache.
+    let linked: unknown
+    try {
+      linked = JSON.parse(readFileSync(path.join(root, '.turbo', 'config.json'), 'utf8'))
+    } catch {}
+    if (
+      typeof linked === 'object' &&
+      linked !== null &&
+      Object.entries(linked).some(
+        ([k, v]) => /^(teamid|teamslug|token)$/i.test(k) && typeof v === 'string' && v !== '',
+      )
+    ) {
+      return '.turbo/config.json links a team (turbo link)'
+    }
+  }
+  const variable = REMOTE_CACHE_ENV[runner]
+  // A line that sets it (`TURBO_TOKEN: …`, `TURBO_TOKEN=…`), not one that
+  // names it: a comment or a doc line counted as "sets" (J's lead).
+  const sets = new RegExp(`^(?!\\s*#).*\\b${variable}\\s*[:=]`, 'm')
+  const workflows = new Bun.Glob('.github/workflows/*.{yml,yaml}')
+  const files = [...workflows.scanSync({ cwd: root, dot: true })].sort().concat(CI_FILES)
+  for (const f of files) {
+    let text: string
+    try {
+      text = readFileSync(path.join(root, f), 'utf8')
+    } catch {
+      continue
+    }
+    if (sets.test(text)) return `${f} sets ${variable}`
+  }
+  return undefined
+}
+
+/**
+ * nx.json names an Nx Cloud workspace (`nxCloudId`, `nxCloudAccessToken`,
+ * or the legacy `nx-cloud` runner). Its wire is Nx's own, so a user who
+ * expected their remote cache under vx heard nothing and ran cold.
+ */
+function usesNxCloud(root: string): boolean {
+  let json: {
+    nxCloudId?: unknown
+    nxCloudAccessToken?: unknown
+    tasksRunnerOptions?: { default?: { runner?: unknown } }
+  } | null
+  try {
+    json = Bun.JSONC.parse(readFileSync(path.join(root, 'nx.json'), 'utf8')) as typeof json
+  } catch {
+    return false
+  }
+  const set = (v: unknown) => typeof v === 'string' && v !== ''
+  const runner = json?.tasksRunnerOptions?.default?.runner
+  return (
+    set(json?.nxCloudId) ||
+    set(json?.nxCloudAccessToken) ||
+    (typeof runner === 'string' && /(^|\/)nx-cloud$/.test(runner))
+  )
+}
+
+/**
+ * The report's line about the remote cache, or undefined: the cache plugin
+ * declared (`declared`), the one a kept file still lacks, or Nx Cloud.
+ */
+export function remoteCacheNote(
+  root: string,
+  runner: 'turbo' | 'nx',
+  declared: boolean,
+): string | undefined {
+  const signal = remoteCacheSignal(root, runner)
+  const cache = REMOTE_CACHE[runner]
+  if (signal !== undefined) {
+    return declared
+      ? `${cache}(): ${signal}, so vx shares that remote cache (inert where the variable is unset).`
+      : `${signal}: add ${cache}() from @vzn/vx-migrate to its plugins and vx shares that remote cache.`
+  }
+  return runner === 'nx' && usesNxCloud(root)
+    ? 'nx.json connects Nx Cloud, whose cache vx cannot share: runs cache on this machine (nxCache() serves a self-hosted Nx cache).'
+    : undefined
+}

package/src/shared-outputs.ts

@@ -26,13 +26,15 @@ import { isLiteralPattern, outputsOverlap, type GeneratedTask } from '@vzn/vx'
 import { relPosix } from './paths.js'
 import type { TrackedKinds } from './tracked-outputs.js'
 
-// Core refuses an output glob that covers the project's own package.json
-// or vx.config (config-schema's `ownFilesCovered`): vx cleans outputs before
-// a run and restores them on a hit, so the manifest would go. Turbo caches
-// it: trpc's client build lists `package.json` (it rewrites `exports`), and
-// the one task made core refuse the whole run (2026-09-28). The façade does
-// not export the check; tests/own-file-outputs.test.ts holds this copy to
-// the loader in both directions.
+// vx cleans outputs before a run and restores them on a hit, so an output
+// glob that covers the project's own package.json or vx.config would delete
+// it. Core refuses the config file (config-schema's `ownFilesCovered`); the
+// manifest it no longer guards (core keys no package file, 2026-10-14), but
+// a mapped task still must not delete it. Turbo caches it: trpc's client
+// build lists `package.json` (it rewrites `exports`), and the one task made
+// core refuse the whole run (2026-09-28). The façade does not export the
+// check; tests/own-file-outputs.test.ts holds the config half of this copy
+// to the loader in both directions.
 const OWN_FILES = ['package.json', 'vx.config.ts', 'vx.config.mts', 'vx.config.js', 'vx.config.mjs']
 
 /**
@@ -102,7 +104,7 @@ export function ownFileTodo(own: { glob: string; file: string }): string {
 export function wildcardOutput(
   files: readonly string[],
   tracked?: TrackedKinds,
-  /** Let a literal-tail glob through once its tracked matches are taken back (`literalTailMatches`). */
+  /** Let a literal-tail glob through: it reaches only the committed files it names, which core keeps (`literalTailMatches`). */
   literalTail = false,
 ): string | undefined {
   return files.find(
@@ -110,20 +112,16 @@ export function wildcardOutput(
       !o.startsWith('!') &&
       !isLiteralPattern(o.split('/')[0] ?? '') &&
       !untrackedKind(o, tracked) &&
-      !(
-        literalTail &&
-        (literalTailMatches(o, tracked)?.every((m) => files.includes(`!${m}`)) ?? false)
-      ),
+      !(literalTail && literalTailMatches(o, tracked) !== null),
   )
 }
 
 /**
  * The tracked files a wildcard-first glob with a literal rest can reach
  * (clerk's builds output `*\/package.json`, the subpath stubs it commits):
- * it reaches no other file, so with each of these taken back by a `!` it
- * reaches no source. Null for any other shape, or with `tracked` unknown.
+ * it reaches no other file, and core never cleans a committed one. Null for any other shape, or with `tracked` unknown.
  */
-export function literalTailMatches(glob: string, tracked?: TrackedKinds): string[] | null {
+function literalTailMatches(glob: string, tracked?: TrackedKinds): string[] | null {
   if (tracked === undefined || glob.startsWith('!')) return null
   const segs = glob.replace(/^(\.\/)+/, '').split('/')
   const [first, ...rest] = segs
@@ -159,6 +157,15 @@ export function wildcardTodo(glob: string): string {
   )
 }
 
+export function wildcardCleanTodo(glob: string): string {
+  return (
+    `output ${JSON.stringify(glob)}: vx cleans outputs before a run and a restore, so every ` +
+    'untracked file this glob reaches is deleted; committed files are kept'
+  )
+}
+
+const TSBUILDINFO = /(?:^|\/)[^/]*tsbuildinfo[^/]*$/i
+
 interface Cached {
   index: number
   name: string
@@ -204,7 +211,12 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
     )
     if (group.length === 0) continue
     const all = [a, ...group]
-    const keeper = all.find((c) => c.hasUpstreamEdge) ?? all[0]!
+    // `build` is the product Turbo and Nx repos run: typescript-eslint's
+    // typecheck (with `^typecheck`) writes declarations into build's dist,
+    // and keeping typecheck left every build uncached (Growth parity,
+    // 2026-10-14).
+    const keeper =
+      all.find((c) => c.name === 'build') ?? all.find((c) => c.hasUpstreamEdge) ?? all[0]!
     const kept: Cached[] = [keeper]
     for (const c of all) {
       if (c === keeper) continue
@@ -215,8 +227,28 @@ export function resolveSharedOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
         kept.push(c)
         continue
       }
-      dropped.add(c.index)
       const t = tasks[c.index]!
+      // tsc's incremental state is no product: create-t3-turbo's build and
+      // typecheck both output `.cache/tsbuildinfo.json`, and typecheck ran
+      // uncached on every first run (Growth funnel F8). Left to the keeper,
+      // it costs a task that emits nothing else nothing to cache. A task
+      // that emits more stays uncached: `tsc --incremental` skips a file
+      // the keeper's tsbuildinfo calls built, missing or not, so its save
+      // could be a partial dist.
+      const sharedFiles = c.files.filter((gb) =>
+        kept.some((k) => k.files.some((ga) => outputsOverlap(ga, gb))),
+      )
+      if (
+        sharedFiles.length === c.files.length &&
+        sharedFiles.every((g) => isLiteralPattern(g) && TSBUILDINFO.test(g))
+      ) {
+        c.files = c.files.filter((g) => !sharedFiles.includes(g))
+        const outputs = (t.task!['cache'] as { outputs: { files: string[] } }).outputs
+        outputs.files = outputs.files.filter((g) => !sharedFiles.includes(g))
+        kept.push(c)
+        continue
+      }
+      dropped.add(c.index)
       const shared = c.files.find((gb) => clash.files.some((ga) => outputsOverlap(ga, gb)))!
       delete t.task!['cache']
       t.todos.push(
@@ -276,6 +308,15 @@ function prefixIndex(): {
   }
 }
 
+/**
+ * A keyed group (`cache`, no `exec`: the `nx-input:<name>` twins, Turbo's
+ * transit nodes) runs nothing, so core lets its key read what a task
+ * writes (`detectInputOverlaps` exempts it). Uncaching one left `{}`, a
+ * task core refuses, and every verb failed.
+ */
+export const isKeyedGroup = (t: { readonly task: Record<string, unknown> | null }): boolean =>
+  t.task !== null && t.task['exec'] === undefined && t.task['cache'] !== undefined
+
 /** A task's cached `inputs` block, when it has one with a `files` list. */
 function inputsOf(t: GeneratedTask): { files: string[]; workspaceFiles?: unknown } | undefined {
   const inputs = (t.task?.['cache'] as { inputs?: { files?: unknown } } | undefined)?.inputs
@@ -294,8 +335,8 @@ function inputsOf(t: GeneratedTask): { files: string[]; workspaceFiles?: unknown
  * files git tracks, and a build's outputs are not, so the adopted tool
  * never keyed them either. A literal input another task writes cannot be
  * taken back (core refuses a `!` over a literal input), so that task runs
- * uncached with a todo. Committed files under an output are the tracked
- * pass's (`spareTrackedOutputs`).
+ * uncached with a todo. A reader whose `!` hides a committed file is the
+ * tracked pass's (`spareTrackedOutputs`).
  */
 export function excludeSiblingOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
   const writers = tasks.flatMap((t, index) => {
@@ -314,6 +355,7 @@ export function excludeSiblingOutputs(tasks: GeneratedTask[]): GeneratedTask[] {
         const read = positive.filter((g) => outputsOverlap(g, out))
         if (read.length === 0) continue
         const literal = read.find((g) => isLiteralPattern(g))
+        if (literal !== undefined && isKeyedGroup(t)) continue
         if (literal !== undefined) {
           delete t.task!['cache']
           t.todos.push(
@@ -463,6 +505,7 @@ export function excludeWorkspaceOutputs(
           const read = reads.filter((g) => outputsOverlap(g, out))
           if (read.length === 0) continue
           const literal = read.find((g) => isLiteralPattern(g))
+          if (literal !== undefined && isKeyedGroup(t)) continue
           if (literal !== undefined) {
             delete t.task!['cache']
             t.todos.push(
@@ -497,6 +540,7 @@ export function excludeWorkspaceOutputs(
           // An output that reaches in from above (`**/gen/**`) has no
           // project-relative `!` that takes it back.
           const literal = out.startsWith(at) ? read.find((g) => isLiteralPattern(g)) : read[0]
+          if (literal !== undefined && isKeyedGroup(t)) continue
           if (literal !== undefined) {
             delete t.task!['cache']
             t.todos.push(

package/src/tracked-outputs.ts

@@ -11,6 +11,7 @@ import { lstat, readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { isLiteralPattern, outputsOverlap } from '@vzn/vx'
 import { relPosix } from './paths.js'
+import { isKeyedGroup } from './shared-outputs.js'
 
 /** The files git tracks under `root`, root-relative; null outside a repo or without git. */
 export async function trackedFiles(root: string): Promise<string[] | null> {
@@ -118,8 +119,8 @@ export function trackedKinds(tracked: readonly string[]): (rel: string) => Track
  * checkout, a pull appends to it), HEAD itself, and the index's size and
  * mtime (`git add`, `git rm`). Stats and a small read, so a kept mapping
  * stays a hit between them; a run does not write the index. Without the
- * index, a file `git add`ed under an output and not yet committed was not
- * taken back by the kept mapping, and the run's clean deleted it. Under
+ * index, a file `git add`ed under an output and not yet committed left a
+ * reader that its `!` hides cached by the kept mapping. Under
  * reftable storage HEAD reads `ref: refs/heads/.invalid` and no reflog file
  * exists, so the ref stack's table list stands for both: every ref update
  * names a new table in it.
@@ -191,8 +192,25 @@ function hidden(globs: unknown, files: readonly string[]): string | undefined {
   )
 }
 
-/** Past this many, a task's take-backs cost its runs more than its cache saves. */
-export const MAX_SPARED = 16
+/** `globs` without the `!` entries in `backs` that take back one of `files`. */
+function unhidden(
+  globs: readonly unknown[],
+  backs: ReadonlySet<string>,
+  files: readonly string[],
+): unknown[] {
+  return globs.filter(
+    (g) =>
+      !(
+        typeof g === 'string' &&
+        g.startsWith('!') &&
+        backs.has(g.slice(1)) &&
+        files.some((f) => outputsOverlap(g.slice(1), f))
+      ),
+  )
+}
+
+const positives = (v: unknown): string[] =>
+  Array.isArray(v) ? v.filter((g): g is string => typeof g === 'string' && !g.startsWith('!')) : []
 
 interface Outputs {
   files?: unknown
@@ -200,9 +218,11 @@ interface Outputs {
 }
 
 /**
- * Take back every committed file a mapped task's outputs cover, in place,
- * and return one `[pkg#task, todo]` per task that had any. `tracked` is
- * root-relative.
+ * Fit a mapped task's outputs to the committed files they cover, in place,
+ * and return one `[pkg#task, todo]` per task this leaves uncached. Core
+ * never cleans a committed file (owner, 2026-10-14), so
+ * the outputs keep them; what is left is the readers' `!` that hides one.
+ * `tracked` is root-relative.
  */
 export function spareTrackedOutputs(
   root: string,
@@ -244,7 +264,7 @@ export function spareTrackedOutputs(
     for (const t of p.tasks) {
       const outputs = (t.task?.['cache'] as { outputs?: Outputs } | undefined)?.outputs
       if (outputs === undefined) continue
-      const hits: [key: 'files' | 'workspaceFiles', globs: string[], hit: string[]][] = []
+      const hits: [key: 'files' | 'workspaceFiles', hit: string[]][] = []
       for (const [key, base] of [
         ['files', own],
         ['workspaceFiles', tracked],
@@ -253,9 +273,9 @@ export function spareTrackedOutputs(
         if (!Array.isArray(globs) || globs.length === 0) continue
         let strings = globs.filter((g): g is string => typeof g === 'string')
         // An output naming one committed file (eslint's
-        // `eslint-suppressions.json`) is a source: its `!` would take the
-        // whole entry back, so the entry goes, and so does the `!` a
-        // reader's inputs got for it, or every reader ran uncached (hono).
+        // `eslint-suppressions.json`) is a source: the entry goes, and so
+        // does the `!` a reader's inputs got for it, or every reader ran
+        // uncached (hono).
         const rootedOf = (g: string) => (key === 'files' && rel !== '' ? `${rel}/${g}` : g)
         const sources = new Set(
           strings.filter((g) => isLiteralPattern(g) && trackedSet.has(rootedOf(g))),
@@ -266,17 +286,26 @@ export function spareTrackedOutputs(
           for (const g of sources) unhide(key === 'files' ? p : null, rootedOf(g))
         }
         const hit = coveredTracked(strings, base)
-        if (hit.length > 0) hits.push([key, strings, hit])
+        if (hit.length > 0) hits.push([key, hit])
       }
-      const spared = hits.flatMap(([, , hit]) => hit)
-      if (spared.length === 0) continue
+      if (hits.length === 0) continue
       // A committed file under these outputs is still a source, and the `!`
       // entry `excludeSiblingOutputs` gave a reader over the whole output
       // hides it from that reader's key: such a reader runs uncached (X-54).
-      const local = hits.flatMap(([key, , hit]) => (key === 'files' ? hit : []))
-      const rooted = hits.flatMap(([key, , hit]) =>
+      const local = hits.flatMap(([key, hit]) => (key === 'files' ? hit : []))
+      const rooted = hits.flatMap(([key, hit]) =>
         key === 'files' ? hit.map((f) => (rel === '' ? f : `${rel}/${f}`)) : hit,
       )
+      // The `!` entries the sibling passes gave readers for these outputs.
+      const ownOut = positives(outputs.files)
+      const fileBacks = new Set(ownOut)
+      const wsBacks = new Set([
+        ...positives(outputs.workspaceFiles),
+        ...ownOut.map((g) => {
+          const bare = g.replace(/^(\.\/)+/, '')
+          return rel === '' ? bare : `${rel}/${bare}`
+        }),
+      ])
       for (const q of projects) {
         for (const r of q.tasks) {
           if (r === t) continue
@@ -286,6 +315,15 @@ export function spareTrackedOutputs(
             (q === p ? hidden(inputs.files, local) : undefined) ??
             hidden(inputs.workspaceFiles, rooted)
           if (f === undefined) continue
+          if (isKeyedGroup(r)) {
+            // Its key reads the committed files, as Nx hashes them. Only the
+            // take-backs of this output go, never a `!` the input declares.
+            if (q === p && Array.isArray(inputs.files))
+              inputs.files = unhidden(inputs.files, fileBacks, local)
+            if (Array.isArray(inputs.workspaceFiles))
+              inputs.workspaceFiles = unhidden(inputs.workspaceFiles, wsBacks, rooted)
+            continue
+          }
           delete r.task!['cache']
           todos.push([
             `${q.name}#${r.name}`,
@@ -294,25 +332,6 @@ export function spareTrackedOutputs(
           ])
         }
       }
-      const shown = spared.slice(0, 3).join(', ') + (spared.length > 3 ? ', …' : '')
-      // Each `!` is matched against every output path on each save, clean
-      // and restore: 4,200 of them cost typescript-eslint's warm run 1.2 s.
-      if (spared.length > MAX_SPARED) {
-        delete t.task!['cache']
-        todos.push([
-          `${p.name}#${t.name}`,
-          `outputs cover ${spared.length} committed files (${shown}), which vx cleans before ` +
-            'every run — task runs uncached; declare the exact outputs in a vx.config to cache it',
-        ])
-        continue
-      }
-      for (const [key, strings, hit] of hits)
-        outputs[key] = [...strings, ...hit.map((f) => `!${f}`)]
-      todos.push([
-        `${p.name}#${t.name}`,
-        `outputs cover ${spared.length} committed file(s) (${shown}) — vx cleans outputs ` +
-          'before a run, so they are taken back with `!` and kept',
-      ])
     }
   }
   return todos

package/src/turbo/index.ts

@@ -2,7 +2,7 @@
 //
 // Fills the `project` stage: every package the workspace discovers is given
 // the tasks turbo.json + its package.json scripts define, mapped by the same
-// mapper `vx migrate --from turbo` renders files from — so what runs here is
+// mapper `bunx @vzn/vx-migrate` renders files from — so what runs here is
 // what a migration would have written, minus the file. Turbo's global fields
 // are inlined into each task instead of imported from a generated preset.
 // A task the package's own vx.config already declares wins; the plugin never
@@ -11,7 +11,9 @@
 import { readFileSync } from 'node:fs'
 import { availableParallelism } from 'node:os'
 import path from 'node:path'
-import type { ProjectMeta, VxPlugin } from '@vzn/vx'
+import type { ProjectMeta, VxPlugin, WorkspaceConfig } from '@vzn/vx'
+import type { PackageMeta } from '../packages.js'
+import { memberProjects, withManifests } from '../manifests.js'
 import { refuseUnknownOptions, type PluginOptionKinds } from '@vzn/vx'
 import { type AdoptionRun, adoptionPlugin } from '../adoption-plugin.js'
 import type { AdoptionMapping } from '../mapping-cache.js'
@@ -60,29 +62,38 @@ export function turbo(options: TurboPluginOptions = {}): VxPlugin {
     {
       async config(workspace, ctx) {
         const keys = await workspaceKeys(options.root ?? ctx.workspaceRoot)
-        if (workspace.concurrency === undefined && keys.concurrency !== undefined)
-          workspace.concurrency = keys.concurrency
-        if (workspace.cacheRetention === undefined && keys.cacheRetention !== undefined)
-          workspace.cacheRetention = keys.cacheRetention
+        if (workspace.run?.concurrency === undefined && keys.concurrency !== undefined)
+          workspace.run = { ...workspace.run, concurrency: keys.concurrency }
+        if (workspace.cache?.retention === undefined && keys.cacheRetention !== undefined)
+          workspace.cache = {
+            ...workspace.cache,
+            // `olderThan` is built with its unit below.
+            retention: keys.cacheRetention as NonNullable<
+              NonNullable<WorkspaceConfig['cache']>['retention']
+            >,
+          }
         // `turbo run --affected` compares with TURBO_SCM_BASE when set, and
         // on GitHub Actions with what the event names.
         const base =
           Bun.env['TURBO_SCM_BASE']?.trim() ||
           githubActionsBase(options.root ?? ctx.workspaceRoot, keys.remoteBaseFallback === true)
-        if (workspace.affectedBase === undefined && base) workspace.affectedBase = base
+        if (workspace.run?.affectedBase === undefined && base)
+          workspace.run = { ...workspace.run, affectedBase: base }
       },
-      // `//#task` keys run on the root, as Turbo runs them: named here, the
-      // root is a project with no vx.config written (a create-turbo repo's
-      // `//#format`). A package that holds the root's name keeps it, and
-      // the mapping's note says so.
+      // Turbo's packages are the package manager's members, each a project
+      // with no vx.config written. `//#task` keys run on the root, as Turbo
+      // runs them: named here, the root is a project too (a create-turbo
+      // repo's `//#format`). A package that holds the root's name keeps it,
+      // and the mapping's note says so.
       async discover(ctx) {
-        if (options.root !== undefined) return []
+        const members = await memberProjects(ctx.workspaceRoot)
+        if (options.root !== undefined) return members
         const named = await rootTaskProject(ctx.workspaceRoot)
-        if (named === null) return []
-        const taken = ctx.projects.some(
-          (m) => m.name === named.name && path.resolve(m.dir) !== path.resolve(named.dir),
-        )
-        return taken ? [] : [named]
+        if (named === null) return members
+        const rootDir = path.resolve(named.dir)
+        const known = [...ctx.projects, ...members.map((m) => ({ name: m.name, dir: m.dir }))]
+        const taken = known.some((m) => m.name === named.name && path.resolve(m.dir) !== rootDir)
+        return taken ? members : [...members.filter((m) => path.resolve(m.dir) !== rootDir), named]
       },
     },
   )
@@ -229,7 +240,8 @@ const textOf = (file: string): Promise<string> =>
  * `turbo.json` / `turbo.jsonc`, every package manifest, the root's,
  * `.yarnrc.yml` and the microfrontends configs.
  */
-async function run(root: string, metas: readonly ProjectMeta[]): Promise<AdoptionRun> {
+async function run(root: string, projects: readonly ProjectMeta[]): Promise<AdoptionRun> {
+  const metas = await withManifests(projects)
   const dirs = [root, ...metas.map((m) => m.dir)]
   const configs = await Promise.all(
     dirs.flatMap((d) => ['turbo.json', 'turbo.jsonc'].map((f) => textOf(path.join(d, f)))),
@@ -264,7 +276,7 @@ async function run(root: string, metas: readonly ProjectMeta[]): Promise<Adoptio
  */
 async function mapAll(
   root: string,
-  metas: readonly ProjectMeta[],
+  metas: readonly PackageMeta[],
   envNames: readonly string[],
   trackedFiles: () => Promise<readonly string[] | null>,
 ): Promise<AdoptionMapping> {
@@ -275,7 +287,7 @@ async function mapAll(
     ),
   )
   const mapped = await mapTurboWorkspace(root, metas, {
-    // Inline: the values themselves, where `vx migrate` splices a preset import.
+    // Inline: the values themselves, where `bunx @vzn/vx-migrate` splices a preset import.
     splice: (_kind, values) => values,
     persistentTodo: PERSISTENT_NOTE,
     envNames,