@vzn/vx 0.0.636 → 0.0.638

package/src/cli/select.ts

@@ -14,11 +14,9 @@ import {
   buildPackageGraph,
   defaultAffectedBase,
   findWorkspaceRoot,
-  type LoadReads,
   type FingerprintClaims,
-  FROZEN_WITHOUT_LOCK,
-  loadProjectConfig,
-  loadWorkspace,
+  lockKey,
+  NO_LOCK,
   parseFilter,
   type ProjectMeta,
   readLockfile,
@@ -34,6 +32,7 @@ import {
   maskedLine,
   nearest,
   UserError,
+  sayNotice,
 } from '../util/index.js'
 import {
   claimedAffected,
@@ -49,15 +48,15 @@ import {
   loadCliProjects,
   loadCliWorkspace,
 } from './workspace-config.js'
+import { resolveSetting } from '../settings.js'
 
 /**
  * The projects whose tasks declare a `cache.inputs.workspaceFiles` glob
  * matching a changed path, one inside another project included (item
  * 954): `--affected` selects them, since the glob is that task's input. Through the run
  * path's staged load, so a glob a `project` plugin gave a config-less
- * package counts; evaluated live as a default run does, or read from the
- * lock as a `--frozen` run does. A load that fails drops to the config files that
- * do load, one by one — a broken out-of-scope config does not fail a
+ * package counts; read from the lock as a run does. A load that fails drops to the lock's
+ * entries, one by one — a project the lock does not hold does not fail a
  * scoped run, and must not fail its selection either.
  */
 export async function workspaceGlobOwners(
@@ -85,26 +84,23 @@ export async function workspaceGlobOwners(
   } catch {
     // Fall through to the per-file sweep.
   }
-  // A frozen run with no lock is refused here, before the tolerant sweep
-  // below could answer "nothing affected" and exit 0 without ever reaching
-  // the run's own refusal. Asked only once the staged load failed: a
-  // frozen load that succeeded read the lock, and a second read parsed it
-  // again (1,000 projects: a 1.1 MB lock, ~10 ms).
-  if (load.frozen === true && (await readLockfile(root)) === null) {
-    throw new UserError(FROZEN_WITHOUT_LOCK)
-  }
+  // No lock is refused here, before the tolerant sweep below could answer
+  // "nothing affected" and exit 0 without ever reaching the run's own
+  // refusal. The sweep reads each entry from the lock: it never evaluates.
+  const lock = await readLockfile(root)
+  if (lock === null) throw new UserError(NO_LOCK)
   const owners: string[] = []
-  await Promise.all(
-    projects.map(async (meta) => {
-      if (meta.configPath === null || meta.configPath === '') return
-      try {
-        if (declaresMatch(await loadProjectConfig(meta.configPath))) owners.push(meta.name)
-      } catch {
-        // A config that will not load cannot be shown to declare a matching
-        // glob; surfacing it here would fail a run the loader itself tolerates.
-      }
-    }),
-  )
+  for (const meta of projects) {
+    if (meta.configPath === null || meta.configPath === '') continue
+    const dir = lockKey(root, meta.dir)
+    if (!Object.hasOwn(lock.projects, dir)) continue
+    try {
+      if (declaresMatch(lock.projects[dir]!.config)) owners.push(meta.name)
+    } catch {
+      // A hand-edited entry that will not read cannot be shown to declare a
+      // matching glob; surfacing it here would fail a run the load tolerates.
+    }
+  }
   return owners
 }
 
@@ -133,9 +129,7 @@ async function workspaceFingerprintClaims(
 }
 
 async function loadWorkspaceProjects(cwd: string): Promise<ProjectMeta[]> {
-  const reads: LoadReads = new Map()
-  const root = await findWorkspaceRoot(cwd, reads)
-  return await discoverCliProjects(await loadWorkspace(root, reads))
+  return await discoverCliProjects(await findWorkspaceRoot(cwd))
 }
 
 export async function findCwdProject(cwd: string): Promise<string | null> {
@@ -150,9 +144,8 @@ export async function findCwdProject(cwd: string): Promise<string | null> {
 export async function findCwdSelection(
   cwd: string,
 ): Promise<{ name: string; discovered: { root: string; projects: ProjectMeta[] } } | null> {
-  const reads: LoadReads = new Map()
-  const root = await findWorkspaceRoot(cwd, reads)
-  const projects = await discoverCliProjects(await loadWorkspace(root, reads))
+  const root = await findWorkspaceRoot(cwd)
+  const projects = await discoverCliProjects(root)
   const abs = path.resolve(cwd)
   const within = (dirOf: (p: ProjectMeta) => string): string | null => {
     let best: string | null = null
@@ -251,14 +244,17 @@ function refusalOf(err: unknown): Refusal {
 
 /**
  * The filter `--affected[=<base>]` stands for: `...[<base>]`, the changed
- * projects and their dependents. An empty base is the workspace's
- * `affectedBase` (or a plugin's `config` stage, from nx.json's
+ * projects and their dependents. An empty base is `run.affectedBase`
+ * (its variable, then the workspace's, which a plugin's `config` stage may set from nx.json's
  * `defaultBase` or `TURBO_SCM_BASE`), then the guess.
  */
 export async function affectedFilterFor(cwd: string, affected: string): Promise<string | Refusal> {
   const root = await findWorkspaceRoot(cwd)
   let base = affected
-  if (base === '') base = (await loadCliWorkspace(root)).workspaceConfig?.affectedBase ?? ''
+  if (base === '') {
+    const ws = (await loadCliWorkspace(root)).workspaceConfig
+    base = (resolveSetting('run.affectedBase', ws).value as string | undefined) ?? ''
+  }
   if (base === '') {
     try {
       base = await defaultAffectedBase(root)
@@ -339,7 +335,6 @@ export async function resolveFilters(
         workspaceGlobOwners: (changed: readonly string[], nested: readonly string[]) =>
           workspaceGlobOwners(root, projects, changed, load, stagedOnce, nested),
         fingerprintClaims: () => workspaceFingerprintClaims(root, projects, load),
-        taskEdges: async () => edges ?? taskEdgesFrom(await stagedOnce()),
         ...(git !== undefined ? { untracked: async () => (await git.start()).untracked } : {}),
       }
       let names: Set<string>
@@ -440,8 +435,10 @@ export async function resolveFilters(
   // Something matched, so the run proceeds; a pattern that matched nothing
   // alongside it is still worth a line — it is probably a typo.
   for (const f of unmatched)
-    process.stderr.write(
-      `vx: filter "${f}" matched no projects${didYouMean([f], projects, tags)}\n`,
+    sayNotice(
+      'warn',
+      'vx run',
+      `filter "${f}" matched no projects${didYouMean([f], projects, tags)}`,
     )
   // Each include is a union: what `--filter other` selected runs its tasks
   // whether or not the `--affected` diff reaches them, and an exclude
@@ -517,14 +514,18 @@ export async function pickTask(
     }
   }
   if (entries.length === 0 && only !== undefined) {
-    process.stderr.write(
-      `vx run: no tasks declared in the selected projects (${[...only].sort().join(', ')})\n`,
+    sayNotice(
+      'error',
+      'vx run',
+      `no tasks declared in the selected projects (${[...only].sort().join(', ')})`,
     )
     return null
   }
   if (entries.length === 0) {
-    process.stderr.write(
-      'vx run: no tasks declared in any project; declare one under `tasks` in a vx.config, or run `vx init` to write them from package.json scripts\n',
+    sayNotice(
+      'error',
+      'vx run',
+      'no tasks declared in any project. Declare one under `tasks` in a vx.config, or run `vx init` to write them from package.json scripts, then `vx lock`',
     )
     return null
   }
@@ -568,13 +569,15 @@ export async function pickTask(
       if (!(err instanceof Error) || err.name !== 'AbortError') throw err
       if (interrupted) return 'interrupted'
       out.write('\n')
-      process.stderr.write(`vx run: no task picked\n`)
+      sayNotice('info', 'vx run', 'no task picked')
       return null
     }
     const n = Number(answer)
     if (!Number.isInteger(n) || n < 1 || n > entries.length) {
-      process.stderr.write(
-        `vx run: invalid selection: ${answer} (type a number from 1 to ${entries.length})\n`,
+      sayNotice(
+        'error',
+        'vx run',
+        `invalid selection: ${answer} (type a number from 1 to ${entries.length})`,
       )
       return null
     }
@@ -604,7 +607,7 @@ function didYouMeanProject(
   projects: Iterable<{ name: string }>,
 ): string {
   const names = [...projects].map((p) => p.name)
-  // A scoped name typed without its scope (`vx-mcp` for `@vzn/vx-mcp`) is
+  // A scoped name typed without its scope (`vx-otel` for `@vzn/vx-otel`) is
   // many edits from the whole name and none from the part after the `/`.
   const byBare = new Map<string, string[]>()
   for (const n of names) {
@@ -615,7 +618,7 @@ function didYouMeanProject(
     const typed = pattern.replace(/^!|\.\.\.$|^\.\.\.|\^/g, '')
     // Two edits from any two-letter name: `--filter //` hinted `ui` (X-13).
     if (typed === '//') {
-      return ". `//` is Turbo's root package, but the workspace root is no project here: give it a package.json name and a vx.config"
+      return '. `//` is the workspace root, which is no project here: add a vx.config there and run `vx lock`'
     }
     const best = nearest(typed, names)
     if (best !== undefined) return `. Did you mean ${best}?`

package/src/cli/show.ts

@@ -1,17 +1,27 @@
-// `vx show [target]` — introspect the workspace's LIVE resolved configs:
-// what a run would see here, now. Configs load through the same path a
-// run uses (`loadProjects`): the plugin `config` and `project` stages
-// apply, so a package a plugin gives tasks to shows them. No target: one
-// line per project. `<project>`: every task's resolved config. `<pkg>#
-// <task>`: one task. `<task>`: that task in every project declaring it.
-// Deliberately NOT the lock — vx-lock.json is already the frozen JSON.
+// `vx show [target]` — introspect the workspace's resolved configs: what a
+// run would see here, now. Configs load through the same path a run uses
+// (`loadProjects`): from the lock, with the plugin `config` and `project`
+// stages applied, so a package a plugin gives tasks to shows them. No lock
+// is `NO_LOCK`. No target: one line per project. `<project>`: every task's
+// resolved config. `<pkg>#<task>`: one task. `<task>`: that task in every
+// project declaring it.
 
 import path from 'node:path'
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { affectedTaskProjects, isDefaultBuild } from '../orchestrator/index.js'
 import { flagHint, formatValue, refuse, seeHelp } from './help.js'
-import { listed, nearMatches, relPosix, secretMask, UserError } from '../util/index.js'
+import {
+  type ColorSupport,
+  detectColors,
+  listed,
+  nearMatches,
+  relPosix,
+  secretMask,
+  UserError,
+  sayNotice,
+  ui,
+} from '../util/index.js'
 import { affectedFilterFor, resolveFilters } from './select.js'
 import {
   discoverCliProjects,
@@ -23,11 +33,10 @@ import {
   type AffectedChanges,
   buildPackageGraph,
   findWorkspaceRoot,
-  type LoadReads,
-  loadWorkspace,
   type ProjectEntry,
   type ProjectMeta,
 } from '../workspace/index.js'
+import { runRules } from '../settings.js'
 
 interface ShowArgs {
   target?: string
@@ -83,9 +92,8 @@ export function parseShowArgs(args: readonly string[]): ShowArgs {
 export async function showCmd(args: readonly string[]): Promise<number> {
   const parsed = parseShowArgs(args)
   if (parsed.error) return refuse('show', args, parsed.error, 'VX_E_USAGE')
-  const reads: LoadReads = new Map()
-  const root = await findWorkspaceRoot(process.cwd(), reads)
-  const metas = await discoverCliProjects(await loadWorkspace(root, reads))
+  const root = await findWorkspaceRoot(process.cwd())
+  const metas = await discoverCliProjects(root)
   const byName = new Map(metas.map((m) => [m.name, m]))
 
   // `//#task` is Turbo's root package's task: the root project here (D-39),
@@ -149,20 +157,20 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       affected = f
       raw.unshift(f)
     }
-    const r = await resolveFilters(process.cwd(), raw, { noCreate: true }, affected)
+    const r = await resolveFilters(process.cwd(), raw, {}, affected)
     if ('error' in r) throw new UserError(`vx show: ${r.error}`, r.code ?? 'VX_E_USAGE')
-    if ('empty' in r) process.stderr.write(`vx show: ${r.empty}\n`)
+    if ('empty' in r) sayNotice('info', 'vx show', r.empty)
     selected = new Set('empty' in r ? [] : r.names)
     if ('names' in r && r.affected !== undefined)
       byDiff = { changes: r.affected, outright: r.outright }
   }
   const inSelection = (name: string): boolean => selected === undefined || selected.has(name)
 
-  const projects = await loadCliProjects(root, metas, scope, { noCreate: true, closure: true })
+  const projects = await loadCliProjects(root, metas, scope, { closure: true })
 
   if (parsed.target === undefined) {
     const shown = metas.filter((m) => inSelection(m.name))
-    process.stdout.write(renderList(root, shown, projects, parsed.format))
+    process.stdout.write(renderList(root, shown, projects, parsed.format, colorsOut()))
     return 0
   }
 
@@ -200,13 +208,13 @@ export async function showCmd(args: readonly string[]): Promise<number> {
           plugins: ws.plugins,
           workspaceRoot: root,
           cacheDir: ws.cacheDir,
-          rules: ws.workspaceConfig?.rules,
+          rules: runRules(ws.workspaceConfig),
           warn: warnToStderr,
         }),
       )
       shown = shown.filter((p) => kept.has(p.name))
     }
-    process.stdout.write(renderTaskAcross(root, shown, projectName!, parsed.format))
+    process.stdout.write(renderTaskAcross(root, shown, projectName!, parsed.format, colorsOut()))
     return 0
   }
 
@@ -217,7 +225,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
 
   if (taskName === undefined) {
     process.stdout.write(
-      renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format),
+      renderProject(meta.name, dir, config, meta.configPath !== null, parsed.format, colorsOut()),
     )
     return 0
   }
@@ -229,7 +237,7 @@ export async function showCmd(args: readonly string[]): Promise<number> {
       'VX_E_UNKNOWN_TASK',
     )
   }
-  process.stdout.write(renderTask(meta.name, dir, taskName, task, parsed.format))
+  process.stdout.write(renderTask(meta.name, dir, taskName, task, parsed.format, colorsOut()))
   return 0
 }
 
@@ -286,11 +294,20 @@ function shownConfig(config: ProjectConfig | null): ProjectConfig | null {
   }
 }
 
+const colorsOut = (): ColorSupport => detectColors(process.stdout)
+const PLAIN: ColorSupport = { enabled: false }
+
+/** One block of several, with no blank line between them. */
+const joined = (blocks: readonly ui.Block[]): ui.Block => ({
+  lines: (c) => blocks.flatMap((b) => b.lines(c)),
+})
+
 function renderList(
   root: string,
   metas: readonly ProjectMeta[],
   projects: ReadonlyMap<string, ProjectEntry>,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   const rows = metas.map((meta) => {
     const tasks = projects.get(meta.name)?.config.tasks ?? {}
@@ -311,9 +328,8 @@ function renderList(
     )}\n`
   }
   if (rows.length === 0) return ''
-  const nameW = Math.max(...rows.map((r) => r.name.length))
-  const dirW = Math.max(...rows.map((r) => r.dir.length))
-  const lines = rows.map((r) => {
+  const anyTags = rows.some((r) => r.tags.length > 0)
+  const cells = rows.map((r) => {
     const n = r.tasks.length
     const count = `${n} task${n === 1 ? '' : 's'}`
     // A package with no config file has only tasks a plugin gave it, or the
@@ -321,14 +337,14 @@ function renderList(
     const tasks = r.configured
       ? count
       : n === 0
-        ? '(no vx config)'
+        ? 'no vx config'
         : r.onlyDefault
-          ? `${count} (no vx config; default build)`
-          : `${count} (no vx config; from plugins)`
-    const tags = r.tags.length > 0 ? `  [${r.tags.join(', ')}]` : ''
-    return `${r.name.padEnd(nameW)}  ${r.dir.padEnd(dirW)}  ${tasks}${tags}`
+          ? `${count}, default build (no vx config)`
+          : `${count} from plugins (no vx config)`
+    return [ui.id(r.name), r.dir, tasks, ...(anyTags ? [r.tags.join(', ')] : [])]
   })
-  return `${lines.join('\n')}\n`
+  const columns = ['project', 'dir', 'tasks', ...(anyTags ? ['tags'] : [])]
+  return ui.render([ui.table(columns, cells)], colors)
 }
 
 function renderProject(
@@ -337,23 +353,27 @@ function renderProject(
   config: ProjectConfig | null,
   hasConfigFile: boolean,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   if (format === 'json') {
     // Round-trip so the printed object is exactly the JSON form of the
     // resolved config (drops `undefined` fields).
     const shown = shownConfig(config)
-    return `${JSON.stringify(JSON.parse(JSON.stringify({ name, dir, config: shown })), null, 2)}\n`
+    return `${JSON.stringify({ name, dir, config: shown })}\n`
   }
   const tags = config?.tags ?? []
   const tasks = Object.entries(config?.tasks ?? {})
-  const head = `${name} — ${dir}${tags.length > 0 ? `\n  tags: ${tags.join(', ')}` : ''}${
+  const head: ui.FieldRow[] = [
+    ['dir', dir],
+    ...(tags.length > 0 ? [['tags', tags.join(', ')] as const] : []),
     // A config-less package a dependant reaches has the default `build` (X-9).
-    hasConfigFile || tasks.length === 0 ? '' : '\n  (no vx config)'
-  }`
-  if (tasks.length === 0)
-    return `${head}\n  ${hasConfigFile ? '(no tasks declared)' : '(no vx config)'}\n`
-  const blocks = tasks.map(([taskName, task]) => taskBlock(taskName, task))
-  return `${head}\n\n${blocks.join('\n')}`
+    ...(hasConfigFile ? [] : [['config', 'none'] as const]),
+    ...(tasks.length === 0 && hasConfigFile ? [['tasks', 'none declared'] as const] : []),
+  ]
+  const blocks = tasks.map(([taskName, task]) =>
+    joined([ui.text(ui.id(`${name}#${taskName}`)), ui.fields(taskRows(task))]),
+  )
+  return ui.render([ui.report(name, head), ...blocks], colors)
 }
 
 function renderTask(
@@ -362,12 +382,13 @@ function renderTask(
   taskName: string,
   task: TaskConfig,
   format: 'pretty' | 'json',
+  colors: ColorSupport = PLAIN,
 ): string {
   if (format === 'json') {
     const obj = { name, dir, task: taskName, config: shownTask(task) }
-    return `${JSON.stringify(JSON.parse(JSON.stringify(obj)), null, 2)}\n`
+    return `${JSON.stringify(obj)}\n`
   }
-  return `${name} — ${dir}\n\n${taskBlock(taskName, task)}`
+  return ui.render([taskReport(name, dir, taskName, task)], colors)
 }
 
 function renderTaskAcross(
@@ -375,6 +396,7 @@ function renderTaskAcross(
   declaring: readonly ProjectEntry[],
   taskName: string,
   format: 'pretty' | 'json',
+  colors: ColorSupport,
 ): string {
   if (format === 'json') {
     const list = declaring.map((p) => ({
@@ -383,20 +405,30 @@ function renderTaskAcross(
       task: taskName,
       config: shownTask(p.config.tasks![taskName]!),
     }))
-    return `${JSON.stringify(JSON.parse(JSON.stringify(list)), null, 2)}\n`
+    return `${JSON.stringify(list)}\n`
   }
-  return declaring
-    .map(
-      (p) =>
-        `${p.name} — ${relPosix(root, p.dir) || '.'}\n\n${taskBlock(taskName, p.config.tasks![taskName]!)}`,
-    )
-    .join('\n')
+  if (declaring.length === 0) return ''
+  return ui.render(
+    [
+      joined(
+        declaring.map((p) =>
+          taskReport(p.name, relPosix(root, p.dir) || '.', taskName, p.config.tasks![taskName]!),
+        ),
+      ),
+    ],
+    colors,
+  )
+}
+
+/** `─ app#build ───`, the project's dir, then every field the run reads. */
+function taskReport(name: string, dir: string, taskName: string, task: TaskConfig): ui.Block {
+  return ui.report(`${name}#${taskName}`, [['dir', dir], ...taskRows(task)])
 }
 
 /** Every field the run reads, in the order the schema declares them. */
-function taskBlock(taskName: string, raw: TaskConfig): string {
+function taskRows(raw: TaskConfig): ui.FieldRow[] {
   const task = shownTask(raw)
-  const rows: [string, string][] = []
+  const rows: ui.FieldRow[] = []
   const list = (xs: readonly string[] | undefined): string | undefined =>
     xs === undefined ? undefined : xs.join(', ')
   const add = (label: string, value: string | number | boolean | undefined): void => {
@@ -406,7 +438,7 @@ function taskBlock(taskName: string, raw: TaskConfig): string {
   const exec = task.exec
   rows.push(['command', exec?.command ?? '(group)'])
   add('dependsOn', list(task.dependsOn))
-  add('timeout', exec?.timeout === undefined ? undefined : `${exec.timeout}ms`)
+  add('timeout', exec?.timeout)
   add('retries', exec?.retries)
   add('env.passThrough', list(exec?.env?.passThrough))
   add(
@@ -439,13 +471,5 @@ function taskBlock(taskName: string, raw: TaskConfig): string {
     add('outputs.files', list(cache.outputs.files))
     add('outputs.workspaceFiles', list(cache.outputs.workspaceFiles))
   }
-  const labelW = Math.max(...rows.map(([label]) => label.length))
-  // A multi-line value (a generated `vx_script` wrapper, a heredoc)
-  // continues under its first line, not at column 0 where it reads as
-  // the next task's header.
-  const indent = `\n${' '.repeat(labelW + 4)}`
-  const body = rows.map(
-    ([label, value]) => `  ${`${label}:`.padEnd(labelW + 1)} ${value.replaceAll('\n', indent)}`,
-  )
-  return `${taskName}\n${body.join('\n')}\n`
+  return rows
 }

package/src/cli/task-verb.ts

@@ -5,7 +5,7 @@
 // name would change meaning the day a plugin declares that verb.
 
 import { isDefaultBuild, nxProjectTarget, projectNamed } from '../orchestrator/index.js'
-import { findWorkspaceRoot, loadWorkspace } from '../workspace/index.js'
+import { findWorkspaceRoot } from '../workspace/index.js'
 import { nearest } from '../util/index.js'
 import { findCwdProject } from './select.js'
 import { discoverCliProjects, loadCliProjects } from './workspace-config.js'
@@ -21,7 +21,7 @@ export async function taskVerbHint(
   cwd: string,
   typo = false,
 ): Promise<string | null> {
-  if (command.includes('#')) return `\`${command}\` is a task: vx run ${command}`
+  if (command.includes('#')) return `\`${command}\` is a task (did you mean vx run ${command}?)`
   const projects = await workspaceProjects(cwd)
   if (projects === null) return null
   const tasks = new Set<string>()
@@ -40,8 +40,8 @@ export async function taskVerbHint(
         ? `vx run ${task} --all`
         : `vx run ${task}`
   return task === command
-    ? `\`${command}\` is a task here, not a command: ${run}`
-    : `unknown command: ${command}; did you mean the task \`${task}\`? ${run}`
+    ? `\`${command}\` is a task here, not a command (did you mean ${run}?)`
+    : `unknown command: ${command}, a typo of the task \`${task}\` (did you mean ${run}?)`
 }
 
 /**
@@ -54,7 +54,7 @@ export async function nxTargetHint(tasks: readonly string[], cwd: string): Promi
   if (projects === null) return null
   const specs = tasks.map((t) => nxProjectTarget(t, projects))
   if (specs.some((s) => s === undefined)) return null
-  return `\`${tasks.join(' ')}\` is Nx's project:target: vx run ${specs.join(' ')}`
+  return `\`${tasks.join(' ')}\` is Nx's project:target (did you mean vx run ${specs.join(' ')}?)`
 }
 
 /**
@@ -79,14 +79,7 @@ async function workspaceProjects(
 ): Promise<Awaited<ReturnType<typeof loadCliProjects>> | null> {
   try {
     const root = await findWorkspaceRoot(cwd)
-    return await loadCliProjects(
-      root,
-      await discoverCliProjects(await loadWorkspace(root)),
-      'all',
-      {
-        noCreate: true,
-      },
-    )
+    return await loadCliProjects(root, await discoverCliProjects(root))
   } catch {
     // No workspace, or a config that does not load: the caller's plain line stands.
     return null