@vzn/vx 0.0.18 → 0.0.21

package/src/orchestrator/plugin.ts

@@ -8,11 +8,15 @@
 // run with a clean UserError naming plugin + hook. A plugin that throws
 // inside a bus hook is logged and disabled for the remainder of the run.
 
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import type { Cache, CacheLayer, CachePolicy } from '../cache/index.js'
-import type { ProjectConfig, WorkspaceConfig } from '../config.js'
+import { PLUGIN_PACKAGE, type ProjectConfig, type WorkspaceConfig } from '../config.js'
 import type { TaskExecutor } from '../exec/index.js'
 import type { TaskNode, TaskOutcome } from '../graph/index.js'
 import { UserError } from '../util/index.js'
+import type { ProjectMeta } from '../workspace/index.js'
 import type { EventBus, RunStartInfo } from './events.js'
 import type { TelemetryContext, TelemetrySink } from './telemetry.js'
 
@@ -32,7 +36,12 @@ import type { TelemetryContext, TelemetrySink } from './telemetry.js'
  * outside the list.
  */
 export interface VxPlugin {
-  /** Stable identifier, convention `'org/name'`. Used in errors + precedence logs. */
+  /**
+   * The name of the package the plugin was defined in — set by
+   * `definePlugin` from the nearest `package.json`, never by the plugin.
+   * Heads every warning about the plugin, every `vx info` line, and the
+   * key material a `key` hook contributes.
+   */
   readonly name: string
 
   // --- PIPELINE stages (shape the run before it executes — opt-in) ----------
@@ -54,7 +63,10 @@ export interface VxPlugin {
    * One project's validated config, right after it loaded and before the
    * graph is built. Add, remove or edit tasks. Runs for every loaded project
    * on every run — a config's cached evaluation is the user's file, and the
-   * hook is applied on top of it live.
+   * hook is applied on top of it live. A package with NO config file is
+   * loaded too, as `{ tasks: {} }`, so a plugin can give tasks to packages
+   * that never wrote one (`ctx.packageJson` carries their scripts); with no
+   * `project` plugin such a package is never visited.
    */
   project?(config: ProjectConfig, ctx: ProjectHookContext): void | Promise<void>
 
@@ -82,6 +94,20 @@ export interface VxPlugin {
     | undefined
     | Promise<Readonly<Record<string, string>> | undefined>
 
+  /**
+   * Workspace-root files this plugin keys on its own, taken OUT of the
+   * workspace fingerprint. Core folds every lockfile it knows into every
+   * task's key, so one `pnpm install` re-keys the whole workspace. A plugin
+   * that reads the lockfile and folds each project's own dependency
+   * closure through `key` claims the file here: core leaves it out of the
+   * fingerprint every key sees (the config-evaluation cache still keys on
+   * it — a config may import a dependency), and `--affected` asks
+   * `affected` which projects a change to it touches instead of selecting
+   * every project. A file has one claimant; a name core does not fold is
+   * refused, since there is nothing to take out.
+   */
+  readonly fingerprint?: FingerprintClaim
+
   /**
    * Scheduling priorities: task id → weight, higher runs first among READY
    * tasks (merged over the structural baseline, which stays the tie-break).
@@ -93,6 +119,20 @@ export interface VxPlugin {
     ctx: ScheduleHookContext,
   ): ReadonlyMap<string, number> | undefined | Promise<ReadonlyMap<string, number> | undefined>
 
+  /**
+   * Admission over the worker count: asked for every task about to start
+   * on this machine, with the tasks running here right now. Return `false`
+   * to hold it until something finishes (it is asked again then). Asked
+   * many times per run, so it must be cheap and synchronous; a throw is
+   * reported once and the plugin admits from then on — a policy never
+   * breaks a run. Restore-tier hits and tasks on an executor pool hold no
+   * local resources and are never asked. When several plugins answer, all
+   * must admit. Core keeps no notion of what a task needs: a plugin that
+   * packs memory or CPU learns or declares the numbers itself
+   * (`@vzn/vx-schedule-history` packs what past executions used).
+   */
+  admit?(task: TaskNode, ctx: AdmitContext): boolean
+
   // --- CLI verbs (opt-in) ---------------------------------------------------
 
   /**
@@ -110,8 +150,9 @@ export interface VxPlugin {
    * Contribute a cache layer. Returns a CacheLayer wrapping (or replacing)
    * the local Cache, or undefined to decline. Consulted ONCE per prepareRun.
    * Precedence: first non-undefined plugin cache wins, in declaration
-   * order. `@vzn/vx/plugins/local-cache` hands back the bare local Cache;
-   * a list with no provider fails the run before any task starts.
+   * order, ahead of core's own `.vx/cache` handle at the tail. A layer
+   * that WRAPS the local handle subsumes that tail, so it is not written
+   * twice.
    */
   cache?(ctx: CacheContext): CacheLayer | undefined | Promise<CacheLayer | undefined>
 
@@ -119,10 +160,10 @@ export interface VxPlugin {
    * Contribute a task executor — WHERE one task's command runs. Consulted
    * ONCE per run; every contributed executor is kept, in declaration order,
    * and per task the first whose `accepts()` passes executes it. Nothing is
-   * appended: a workspace declares `localExecutorPlugin()` (from
-   * `@vzn/vx/plugins/local-executor`) like any other, and a run with no
-   * executor at all fails before any task runs. Persistent tasks never
-   * reach an executor (local by construction).
+   * appended in front: core's own local executor is always the TAIL, so
+   * declining a task hands it back to this machine rather than failing
+   * the run. Persistent tasks never reach an executor (local by
+   * construction).
    */
   executor?(ctx: ExecutorContext): TaskExecutor | undefined | Promise<TaskExecutor | undefined>
 
@@ -188,6 +229,18 @@ export interface ProjectHookContext extends BaseContext {
   readonly dir: string
   /** The parsed `package.json`, read-only. */
   readonly packageJson: Readonly<Record<string, unknown>>
+  /**
+   * Every package the workspace discovered — the one being visited, the
+   * rest of the run's scope and the packages outside it, config file or
+   * not — as core read them at startup. A plugin whose mapping needs the
+   * whole workspace (a `dependsOn` is only valid against every package's
+   * scripts at once) reads it here instead of walking the workspace a
+   * second time. The same array is handed to every visit of a run and a
+   * new one to the next run — a plugin instance outlives a run under `vx
+   * watch`, so a per-run memo keys on this array's identity, never on the
+   * process.
+   */
+  readonly projects: readonly ProjectMeta[]
 }
 
 export interface GraphHookContext extends BaseContext {
@@ -197,6 +250,42 @@ export interface GraphHookContext extends BaseContext {
 
 export interface KeyHookContext extends BaseContext {}
 
+/** A plugin's claim on workspace fingerprint files — see `VxPlugin.fingerprint`. */
+export interface FingerprintClaim {
+  /** Root-relative names from `WORKSPACE_FINGERPRINT_FILES`, e.g. `['pnpm-lock.yaml']`. */
+  readonly files: readonly string[]
+  /**
+   * The projects (package names) a change to a claimed file affects. Called
+   * by `--affected` with the file's bytes at the base ref and in the
+   * working tree (`null` where it does not exist). Return `undefined` to
+   * select every project — the answer a claimant gives when it cannot
+   * tell, and what core does for an unclaimed file.
+   */
+  affected(
+    change: FingerprintChange,
+    ctx: FingerprintContext,
+  ): Iterable<string> | undefined | Promise<Iterable<string> | undefined>
+}
+
+export interface FingerprintChange {
+  /** The claimed file's root-relative name. */
+  readonly file: string
+  readonly before: Uint8Array | null
+  readonly after: Uint8Array | null
+}
+
+export interface FingerprintContext extends BaseContext {
+  /** Every project in the workspace: package name and absolute directory. */
+  readonly projects: ReadonlyArray<{ readonly name: string; readonly dir: string }>
+}
+
+export interface AdmitContext {
+  /** The tasks executing on this machine right now, in dispatch order. */
+  readonly running: readonly TaskNode[]
+  /** The run's worker count — the ceiling the count gate already applies. */
+  readonly concurrency: number
+}
+
 export interface ScheduleHookContext extends BaseContext {
   /** The run's local cache handle — its `dbHandle()` holds the run history a policy can learn from. */
   readonly localCache: Cache
@@ -263,6 +352,70 @@ export interface Plugin {
   setup?(ctx: PluginContext): void | Promise<void>
 }
 
+/** What a plugin author writes: every hook, and no name. */
+export type PluginHooks = Omit<VxPlugin, 'name'>
+
+/**
+ * Where a plugin is defined — `import.meta` of its module. `dir` is Bun's
+ * field; `url` is the standard one, for a module evaluated elsewhere.
+ */
+export interface PluginOrigin {
+  readonly dir?: string
+  readonly url?: string
+}
+
+const packageNameByDir = new Map<string, string>()
+
+/** The name of the nearest `package.json` above `dir` — the one that owns it. */
+function pluginPackageName(dir: string): string {
+  const memo = packageNameByDir.get(dir)
+  if (memo !== undefined) return memo
+  for (let d = dir; ;) {
+    let text: string | undefined
+    try {
+      text = readFileSync(path.join(d, 'package.json'), 'utf8')
+    } catch {
+      /* not here; look one level up */
+    }
+    if (text !== undefined) {
+      const name = (JSON.parse(text) as { name?: unknown }).name
+      if (typeof name !== 'string' || name.length === 0) {
+        throw new UserError(
+          `definePlugin: ${path.join(d, 'package.json')} has no name — a plugin is a package, and its name is the package's`,
+        )
+      }
+      packageNameByDir.set(dir, name)
+      return name
+    }
+    const parent = path.dirname(d)
+    if (parent === d) {
+      throw new UserError(
+        `definePlugin: no package.json above ${dir} — a plugin is a package, and its name is the package's`,
+      )
+    }
+    d = parent
+  }
+}
+
+/**
+ * The one way to make a plugin: `definePlugin(import.meta, { ...hooks })`.
+ * The name is read from the package the calling module belongs to — the
+ * nearest `package.json` above it — and stamped where the workspace loader
+ * checks for it, so a plugin cannot be named anything but its package.
+ */
+export function definePlugin(origin: PluginOrigin, hooks: PluginHooks): VxPlugin {
+  if ('name' in hooks) {
+    throw new UserError(`definePlugin: a plugin's name is its package name — drop the 'name' field`)
+  }
+  const dir =
+    origin.dir ?? (origin.url !== undefined ? path.dirname(fileURLToPath(origin.url)) : undefined)
+  if (dir === undefined) {
+    throw new UserError(`definePlugin: the first argument must be the plugin module's import.meta`)
+  }
+  const name = pluginPackageName(dir)
+  return { ...hooks, name, [PLUGIN_PACKAGE]: name } as VxPlugin
+}
+
 export interface InstallPluginsArgs {
   plugins: readonly Plugin[]
   workspaceRoot: string

package/src/orchestrator/prepare.ts

@@ -8,10 +8,11 @@
 // try/finally around its plan() call.
 
 import path from 'node:path'
-import type { ProjectConfig, WorkspaceConfig } from '../config.js'
+import type { WorkspaceConfig } from '../config.js'
 import { mark, UserError } from '../util/index.js'
 import {
   Cache,
+  noteSchemaReset,
   type CacheLayer,
   type CachePolicy,
   FULL_CACHE_POLICY,
@@ -25,34 +26,30 @@ import {
 import {
   buildPackageGraph,
   computeNestedProjectDirs,
-  computeWorkspaceFingerprint,
+  computeWorkspaceFingerprints,
   findWorkspaceRoot,
-  frozenProjectConfig,
   listProjects,
-  loadProjectConfigs,
   loadWorkspace,
-  loadWorkspaceConfig,
+  FROZEN_WITHOUT_LOCK,
   readLockfile,
   resolveCacheDir,
-  validateProjectConfig,
   type ProjectEntry,
 } from '../workspace/index.js'
 import {
   buildTaskGraph,
   expandRequested,
-  parseDependencySpec,
   type TaskNode,
   unresolvedRequests,
 } from '../graph/index.js'
 import {
-  applyConfigHooks,
   applyGraphHooks,
   applyKeyHooks,
-  applyProjectHooks,
   applyScheduleHooks,
+  fingerprintClaims,
   hasHook,
   resolveCache,
 } from './plugin-host.js'
+import { loadProjects, loadWorkspacePlugins, type LoadedProjects } from './projects.js'
 import type { VxPlugin } from './plugin.js'
 import { createHashCache, type HashCache } from './task-hash.js'
 import type { Logger } from './logger.js'
@@ -76,8 +73,7 @@ export interface PreparedRun {
    * injected remote layer, or one a plugin's `cache` capability built. The
    * remote axes of the policy only mean anything then: without a remote
    * layer a `remote:w` policy writes NOWHERE, so a task that believed it
-   * would be saved still cleans its outputs before executing and (under
-   * `--verify`) restores an artifact that was never written.
+   * would be saved still cleans its outputs before executing.
    */
   hasRemoteLayer: boolean
   /**
@@ -96,6 +92,12 @@ export interface PreparedRun {
   unresolvedTasks: readonly string[]
   /** Every discovered project — the declared task names a typo is measured against. */
   projects: ReadonlyMap<string, ProjectEntry>
+  /**
+   * True iff at least one package in the workspace has a `vx.config.*` at
+   * all — regardless of scope, so a `--filter` that matched nothing is not
+   * mistaken for a workspace vx was never set up in.
+   */
+  anyProjectConfig: boolean
   workspaceFingerprint: string
   nestedDirsByProject: Map<string, string[]>
   /**
@@ -129,25 +131,6 @@ export interface PreparedRun {
   empty: null | 'no-tasks-declared' | 'empty-graph'
 }
 
-/** Project names named by a `pkg#task` dependsOn entry anywhere in `config`. */
-function crossDepProjects(config: ProjectConfig): string[] {
-  const out: string[] = []
-  for (const task of Object.values(config.tasks ?? {})) {
-    for (const raw of task.dependsOn ?? []) {
-      // A malformed spec is the graph builder's error to report — it names
-      // the offending task. Here it just contributes no project.
-      if (!raw.includes('#')) continue
-      try {
-        const spec = parseDependencySpec(raw)
-        if (spec.kind === 'cross') out.push(spec.project)
-      } catch {
-        continue
-      }
-    }
-  }
-  return out
-}
-
 /**
  * Build the prepared-run context: workspace discovery, project-config
  * load, package + task graph, cache handle (local, optionally wrapped
@@ -178,16 +161,9 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // await further down still sees the error).
   earlyGit?.catch(() => {})
   const workspace = await loadWorkspace(workspaceRoot)
-  const workspaceConfig = await loadWorkspaceConfig(workspaceRoot)
-  // The `config` stage runs before anything is derived from the workspace
-  // config; the plugin list itself is already fixed.
-  const plugins = (workspaceConfig?.plugins ?? []) as readonly VxPlugin[]
-  if (workspaceConfig !== null && hasHook(plugins, 'config')) {
-    await applyConfigHooks(plugins, workspaceConfig, {
-      workspaceRoot,
-      warn: (m) => log.status(m),
-    })
-  }
+  const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, (m) =>
+    log.status(m),
+  )
   mark('workspace config')
   const projectMetas = await listProjects(workspace)
   mark('discover projects')
@@ -201,17 +177,11 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // Turbo-like: a broken config in an unrelated package no longer
   // fails a scoped run — it surfaces when that package enters scope.
   const packageGraph = buildPackageGraph(projectMetas)
-  const projectsWithConfigs = projectMetas.filter(
-    (m): m is typeof m & { configPath: string } =>
-      typeof m.configPath === 'string' && m.configPath.length > 0,
-  )
-  const haveConfig = new Set(projectsWithConfigs.map((m) => m.name))
-
-  // Seeds: explicit scope, plus anchored pkg#task targets (which
-  // bypass scope by design). With no explicit scope, bare task names
-  // fan out across the whole workspace — but when EVERY spec is
-  // anchored, the anchors alone are the scope and nothing else needs
-  // its config evaluated.
+  // Seeds: explicit scope, plus anchored pkg#task targets (which bypass
+  // scope by design). With no explicit scope, bare task names fan out
+  // across the whole workspace — but when EVERY spec is anchored, the
+  // anchors alone are the scope and nothing else needs its config
+  // evaluated.
   const anchored: string[] = []
   let hasBare = false
   for (const spec of options.tasks) {
@@ -219,16 +189,8 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     if (hashIdx > 0) anchored.push(spec.slice(0, hashIdx))
     else hasBare = true
   }
-  const seeds = new Set<string>(
-    options.projects
-      ? options.projects.filter((p) => haveConfig.has(p))
-      : hasBare
-        ? haveConfig
-        : [],
-  )
-  for (const project of anchored) {
-    if (haveConfig.has(project)) seeds.add(project)
-  }
+  const seeds: 'all' | string[] =
+    options.projects !== undefined ? [...options.projects, ...anchored] : hasBare ? 'all' : anchored
 
   // The local cache opens BEFORE the configs load: it is also where their
   // cached evaluations live. `--cache-dir <path>` (RunOptions.cacheDir)
@@ -239,25 +201,17 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     ? path.resolve(options.cwd, options.cacheDir)
     : resolveCacheDir(workspaceRoot, workspaceConfig)
   const localCache = new Cache(cacheDir, { read: policy.localRead, write: policy.localWrite })
-  const workspaceFingerprint = await computeWorkspaceFingerprint(workspaceRoot)
+  noteSchemaReset(localCache, (m) => log.status(m))
+  // Two digests from one read: the config-evaluation cache keys on every
+  // file (a config may import a dependency), the task keys on the files no
+  // plugin claims (`VxPlugin.fingerprint`).
+  const fingerprints = await computeWorkspaceFingerprints(
+    workspaceRoot,
+    new Set(fingerprintClaims(plugins).keys()),
+  )
+  const workspaceFingerprint = fingerprints.unclaimed
   mark('open cache')
 
-  type ConfigMeta = (typeof projectsWithConfigs)[number]
-  const metaByName = new Map<string, ConfigMeta>(projectsWithConfigs.map((m) => [m.name, m]))
-  const needed = new Set<string>()
-  const pending: ConfigMeta[] = []
-  const consider = (name: string): void => {
-    if (needed.has(name)) return
-    needed.add(name)
-    const meta = metaByName.get(name)
-    if (meta) pending.push(meta)
-  }
-  const considerWithDeps = (name: string): void => {
-    consider(name)
-    for (const dep of packageGraph.transitiveDeps(name)) consider(dep)
-  }
-  for (const seed of seeds) considerWithDeps(seed)
-
   // Frozen mode (--frozen, CI): configs load FROM vx-lock.json after a
   // content-hash tripwire — no evaluation; env-dependent configs keep
   // their locked values. Default (local) runs ALWAYS evaluate live:
@@ -267,55 +221,31 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // See docs/design/config-lock-2026-06.md.
   const lock = options.frozen === true ? await readLockfile(workspaceRoot) : null
   if (options.frozen === true && lock === null) {
-    throw new UserError(
-      `--frozen requires vx-lock.json at the workspace root — run 'vx lock' and commit it`,
-    )
+    throw new UserError(FROZEN_WITHOUT_LOCK)
   }
 
-  // Load in rounds to a fixpoint. A `pkg#task` dependsOn entry names a
-  // project the PACKAGE graph cannot reach (the cross form ignores npm
-  // deps by design), so its config has to be pulled in — and that config
-  // may declare cross edges of its own. The common case (no cross deps)
-  // is a single round, identical to loading the closure in one batch.
-  const projects = new Map<string, ProjectEntry>()
-  const projectStage = hasHook(plugins, 'project')
+  let loaded: LoadedProjects
   try {
-    while (pending.length > 0) {
-      const round = pending.splice(0, pending.length)
-      const configs = lock
-        ? await Promise.all(round.map((m) => frozenProjectConfig(lock, m, workspaceRoot)))
-        : await loadProjectConfigs(
-            round.map((m) => m.configPath),
-            { evalCache: { store: localCache, workspaceFingerprint } },
-          )
-      for (let i = 0; i < round.length; i++) {
-        const meta = round[i]!
-        const config = configs[i] as ProjectConfig
-        if (projectStage) {
-          // The `project` stage edits the validated object in place; core
-          // then re-validates so a plugin can only produce what the loader
-          // accepts from a user. The message names the config file — the
-          // plugin's edit is a defect in THAT project's tasks.
-          await applyProjectHooks(plugins, config, {
-            workspaceRoot,
-            cacheDir,
-            warn: (m) => log.status(m),
-            name: meta.name,
-            dir: meta.dir,
-            packageJson: meta.packageJson as unknown as Readonly<Record<string, unknown>>,
-          })
-          validateProjectConfig(config, `${meta.configPath} (after plugins)`)
-        }
-        projects.set(meta.name, { name: meta.name, dir: meta.dir, config })
-        for (const name of crossDepProjects(config)) considerWithDeps(name)
-      }
-    }
+    loaded = await loadProjects({
+      workspaceRoot,
+      cacheDir,
+      plugins,
+      projectMetas,
+      packageGraph,
+      seeds,
+      closure: true,
+      lock,
+      evalCache: { store: localCache, workspaceFingerprint: fingerprints.all },
+      warn: (m) => log.status(m),
+      ...(options.staged !== undefined ? { staged: options.staged } : {}),
+    })
   } catch (err) {
     // The cache opened before the configs loaded (it holds their cached
     // evaluations); a config error must not leak the handle.
     localCache.close()
     throw err
   }
+  const { projects, configured: projectsWithConfigs } = loaded
   mark('load configs')
 
   // Boundary geometry considers every config-bearing project in the
@@ -333,24 +263,32 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   const unresolvedTasks = unresolvedRequests(options.tasks, candidateProjects, projects)
 
   // Cache seam precedence: an EXPLICITLY injected remote layer
-  // (RunOptions.remoteCache — a distribution agent or serve that already
+  // (RunOptions.remoteCache — a distribution agent or daemon that already
   // holds a wire client) wins outright; else a plugin's `cache` capability;
   // else the local cache alone. Core ships no wire client — the remote
-  // cache is a plugin concern (native-cache-wire-2026-07). Injection
+  // cache is a plugin concern (docs/patterns.md § Remote cache wire). Injection
   // winning prevents double-wrapping when the workspace also declares a
   // cache plugin.
-  const cache = options.remoteCache
-    ? new LayeredCache(localCache, options.remoteCache, {
-        policy,
-        onRemoteError: (err) => log.status(`[vx] remote cache: ${err.message}`),
-      })
-    : await resolveCache(plugins, {
-        workspaceRoot,
-        cacheDir,
-        warn: (m) => log.status(m),
-        localCache,
-        policy,
-      })
+  let cache: CacheLayer
+  try {
+    cache = options.remoteCache
+      ? new LayeredCache(localCache, options.remoteCache, {
+          policy,
+          onRemoteError: (err) => log.status(`[vx] remote cache: ${err.message}`),
+        })
+      : await resolveCache(plugins, {
+          workspaceRoot,
+          cacheDir,
+          warn: (m) => log.status(m),
+          localCache,
+          policy,
+        })
+  } catch (err) {
+    // A cache plugin that throws or returns something off-contract is
+    // refused by name; the local handle opened above must not leak with it.
+    localCache.close()
+    throw err
+  }
   // Ask the LAYER, don't infer. Identity against `localCache` answers a
   // DIFFERENT question — "did the plugin hand back something other than the
   // handle I passed in?" — which an ordinary pass-through decorator (a
@@ -397,6 +335,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       nodes: new Map(),
       unresolvedTasks,
       projects,
+      anyProjectConfig: projectsWithConfigs.length > 0,
       workspaceFingerprint,
       nestedDirsByProject,
       gitFilesCache,
@@ -414,6 +353,11 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       ? { excludeDependencies: options.excludeDependencies }
       : {}),
   })
+  // The graph is built; what follows is the plugins' (graph, key,
+  // schedule). Two rows, so a plugin's key stage reads as its own cost
+  // and not as graph building — a lockfile plugin's 1000 stats per run
+  // hid inside one `prepare (graph)` row until 2026-09-10.
+  mark('build graph')
   if (hasHook(plugins, 'graph')) {
     await applyGraphHooks(plugins, nodes, {
       workspaceRoot,
@@ -447,6 +391,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     nodes,
     unresolvedTasks,
     projects,
+    anyProjectConfig: projectsWithConfigs.length > 0,
     workspaceFingerprint,
     nestedDirsByProject,
     gitFilesCache,