@vzn/vx 0.0.636 → 0.0.638

package/src/orchestrator/options.ts

@@ -2,7 +2,7 @@
 // so internals like prepare.ts can import them without an upward
 // import of index.ts — the module entry must stay cycle-free.
 
-import type { CachePolicy, RemoteCacheLayer } from '../cache/index.js'
+import type { CacheFlags, CachePolicy, RemoteCacheLayer } from '../cache/index.js'
 import type { ContinueMode } from '../graph/index.js'
 import type { TaskOutcome } from '../graph/index.js'
 import type { AffectedReason } from './affected-tasks.js'
@@ -11,6 +11,7 @@ import type { TelemetrySink } from './telemetry.js'
 import type { Logger } from './logger.js'
 import type { RunSummaryJson } from './run-artifacts.js'
 import type { AffectedChanges, ProjectEntry, ProjectMeta } from '../workspace/index.js'
+import type { RunSettings } from '../config.js'
 
 export interface RunOptions {
   cwd: string
@@ -47,7 +48,7 @@ export interface RunOptions {
   affectedReasons?: Map<string, AffectedReason>
   /**
    * Configs a selection pass in this same process already loaded and
-   * staged with the same `cacheDir` and `frozen` (the CLI walks every
+   * staged with the same `cacheDir` (the CLI walks every
    * `pkg#task` edge for `--filter 'app...'` and `--affected`). The run
    * seeds and scopes as it always does and reuses these entries instead
    * of evaluating and staging them again. One run only — never carry a
@@ -67,42 +68,39 @@ export interface RunOptions {
   concurrency?: number
   /**
    * Cache directory override (`--cache-dir <path>`). Absolute, or relative
-   * to `cwd`. Takes precedence over the workspace `cacheDir` field and the
+   * to `cwd`. Takes precedence over the workspace `cache.dir` field and the
    * `.vx/cache` default. A per-run knob — never folded into a cache key.
    */
   cacheDir?: string
   /**
    * Granular cache read/write control across the local + remote layers.
    * Each of the four axes (localRead / localWrite / remoteRead /
-   * remoteWrite) is independent. Undefined → {@link FULL_CACHE_POLICY}
-   * (everything on). `--no-cache` sets all four false; `--force` sets
-   * both reads false (re-execute, still refresh the cache).
+   * remoteWrite) is independent. Undefined → the workspace's
+   * `cache.policy` with `cacheFlags` applied, else {@link FULL_CACHE_POLICY}
+   * (everything on).
    */
   cache?: CachePolicy
   /**
-   * The caller asked for a remote axis by name (`--cache=remote:rw`). With
+   * With no `cache`: `--no-cache` (all four off) and `--force` (both reads
+   * off), applied over the workspace's `cache.policy`.
+   */
+  cacheFlags?: CacheFlags
+  /**
+   * The caller asked for a remote axis by name (`--cache-policy=remote:rw`). With
    * no cache plugin supplying a remote layer the axes are inert, and a CI
    * job that believes it is filling a shared cache deserves one line
    * saying it is not.
    */
   remoteRequested?: boolean
-  /** This run's `cacheScope` (the CLI's `--cache-scope`), above `VX_CACHE_SCOPE` and `vx.workspace`. */
+  /** This run's `cache.scope` (the CLI's `--cache-scope`), above `VX_CACHE_SCOPE` and `.vx/workspace`. */
   cacheScope?: string
   /**
-   * The `cacheScope` a run takes when `vx.workspace` names none. The CLI
-   * passes `'read-only'` off CI (`CI` unset, `0` or `false`) unless
-   * `--cache` names the remote; omitted → trusted.
-   */
-  defaultCacheScope?: string
-  /**
-   * CI mode: load configs FROM the committed vx-lock.json instead of
-   * evaluating them (frozen-env reproducibility). Requires the lock
-   * to exist and pass its content-hash tripwire. Local runs default
-   * to live evaluation — byte hashes can't see a config's import
-   * closure, so a strict local mode would give false confidence.
-   * Pair with `vx lock --check` in CI for the full evaluation audit.
+   * The default policy's remote write is off (`remote:r`): the CLI passes it
+   * off CI (`CI` unset, `0` or `false`) unless `--cache-policy` or
+   * `VX_CACHE_POLICY` names the remote. Dropped when the workspace's
+   * `cache.policy` names the remote.
    */
-  frozen?: boolean
+  remoteReadOnlyByDefault?: boolean
   /**
    * Explicit per-task output volume for the default logger. ALWAYS
    * overrides the flow default. 'full': frames for work + one-liners
@@ -135,19 +133,18 @@ export interface RunOptions {
    */
   flow?: 'focused' | 'broad'
   /**
-   * Run-level retry default (`--retry <n>`): max additional attempts
+   * `run.retries` from its flag (`--retries <n>`): max additional attempts
    * after a failed attempt, for tasks that don't declare their own
-   * `exec.retries` (explicit config wins, including `retries: 0`).
-   * Threaded as an option only — never folded into any cache key, so
-   * the same run with and without `--retry` derives identical keys.
+   * `exec.retries` (explicit config wins, including `retries: 0`); unset,
+   * `VX_RUN_RETRIES`, then the workspace's. Never folded into any cache
+   * key, so the same run with and without `--retries` derives identical keys.
    * A non-negative integer; run() refuses anything else (C-61).
    */
   retries?: number
   /**
-   * Run-level default task timeout (ms), for tasks that declare no
-   * `exec.timeout`. Highest of the run-level defaults: `--timeout` /
-   * this option → `VX_TASK_TIMEOUT` env → workspace `timeout`. Per-task
-   * `exec.timeout` always wins. Threaded as an option only — never
+   * `run.timeout` in ms from its flag (`--timeout 30m`), for tasks that
+   * declare no `exec.timeout`; unset, `VX_RUN_TIMEOUT`, then the
+   * workspace's. Per-task `exec.timeout` always wins. Never
    * folded into any cache key (a timed-out task fails and is never
    * cached), so a `--timeout` run cache-hits a plain run's entry.
    * A positive integer of ms up to `2 ** 31 - 1`; run() refuses anything
@@ -163,6 +160,16 @@ export interface RunOptions {
    * `--continue[=never|deps-ok|always]`; bare `--continue` = 'always'.
    */
   continueMode?: ContinueMode
+  /** `--branch`; unset, `VX_RUN_BRANCH`, then git's, then the CI provider's. */
+  branch?: string
+  /** `run.schedule` from its flag; unset, `VX_RUN_SCHEDULE`, then the workspace's. */
+  schedule?: NonNullable<RunSettings['schedule']>
+  /** `run.killGrace` in ms from its flag; unset, `VX_RUN_KILL_GRACE`, then the workspace's. */
+  killGrace?: number
+  /** `run.teardownTimeout` in ms from its flag; unset, `VX_RUN_TEARDOWN_TIMEOUT`, then the workspace's. */
+  teardownTimeout?: number
+  /** `run.readyNotice` in ms from its flag; unset, `VX_RUN_READY_NOTICE`, then the workspace's. */
+  readyNotice?: number
   /**
    * Filter `dependsOn` expansion. `'all'` drops every edge (just the
    * requested task runs). A string array drops only those task names
@@ -190,6 +197,12 @@ export interface RunOptions {
    * here. Not called on a refused run.
    */
   beforeFooter?: (outcomes: readonly TaskOutcome[], ok: boolean) => string
+  /**
+   * `false`: no footer, live or printed, and no blank line opening the
+   * task log; the run is its task rows (`vx watch`, which frames each
+   * cycle with its own line).
+   */
+  footer?: boolean
   /**
    * If set, write a Chrome-trace JSON profile of the run's wallclock
    * spans. Path is cwd-relative. Default `profile.json` is selected

package/src/orchestrator/output-host.ts

@@ -0,0 +1,72 @@
+// The `output` capability: a plugin may take the terminal for a run. Sibling
+// to telemetry-host.ts. With no plugin declaring the hook nothing here runs,
+// and core's renderer is the run's, byte for byte.
+
+import { terminalSubscriber, type RunEventSubscriber } from './events.js'
+import type { Logger } from './logger.js'
+import type { OutputContext, VxPlugin } from './plugin.js'
+
+const REQUIRED = ['status', 'taskStdout', 'taskStderr', 'taskComplete'] as const
+const OPTIONAL = ['runStart', 'taskStart', 'runEnd'] as const
+
+/** Reject anything that is not Logger-shaped, naming what is missing. */
+function checkLogger(value: unknown): Logger {
+  if (typeof value !== 'object' || value === null) {
+    throw new Error(`output must be a Logger object, got ${value === null ? 'null' : typeof value}`)
+  }
+  const o = value as Record<string, unknown>
+  const missing = REQUIRED.filter((k) => typeof o[k] !== 'function')
+  if (missing.length > 0) throw new Error(`output Logger has no ${missing.join(', ')}`)
+  const wrong = OPTIONAL.filter((k) => o[k] !== undefined && typeof o[k] !== 'function')
+  if (wrong.length > 0) throw new Error(`output Logger's ${wrong.join(', ')} must be functions`)
+  return value as Logger
+}
+
+/**
+ * The first plugin, in declaration order, whose `output` returns a Logger.
+ * A hook that throws or returns something else is warned about and passed
+ * over: a renderer must never fail a run.
+ */
+export async function claimOutput(
+  plugins: readonly VxPlugin[],
+  ctx: OutputContext,
+): Promise<{ logger: Logger; owner: string } | undefined> {
+  for (const plugin of plugins) {
+    if (plugin.output === undefined) continue
+    try {
+      const logger = await plugin.output(ctx)
+      if (logger !== undefined) return { logger: checkLogger(logger), owner: plugin.name }
+    } catch (err) {
+      ctx.warn(
+        `[vx] plugin '${plugin.name}' output: ${err instanceof Error ? err.message : String(err)}; vx renders the run`,
+      )
+    }
+  }
+  return undefined
+}
+
+/**
+ * The bus subscriber for a plugin's Logger. The first throw hands that
+ * event and every later one to `fallback` (core's renderer), after one
+ * status line naming the plugin.
+ */
+export function guardedOutput(
+  claimed: { logger: Logger; owner: string },
+  fallback: RunEventSubscriber,
+): RunEventSubscriber {
+  const render = terminalSubscriber(claimed.logger)
+  let failed = false
+  return (event) => {
+    if (failed) return fallback(event)
+    try {
+      render(event)
+    } catch (err) {
+      failed = true
+      fallback({
+        kind: 'run:status',
+        line: `[vx] plugin '${claimed.owner}' output failed: ${err instanceof Error ? err.message : String(err)}; vx renders the rest of the run`,
+      })
+      fallback(event)
+    }
+  }
+}

package/src/orchestrator/plan.ts

@@ -50,7 +50,7 @@ export interface PlannedTask {
   executor?: string
   /**
    * `'deferred'` when this task's outputs would stay in the remote store
-   * (`--download=none` / `toplevel`). Attached only when it is TRUE — an
+   * (`--cache-download=none` / `toplevel`). Attached only when it is TRUE — an
    * eager task is the default and saying so on every line says nothing.
    */
   download?: 'deferred'
@@ -91,22 +91,21 @@ export interface RunPlan {
   /** Set when `--affected` left nothing to run: the line the run would print, and why. */
   noneAffected?: string
   /**
-   * Producers `--download` WANTED to defer but could not, mapped to why.
-   * Without this the gate is invisible: a user asks for `--download=none`,
+   * Producers `--cache-download` WANTED to defer but could not, mapped to why.
+   * Without this the gate is invisible: a user asks for `--cache-download=none`,
    * gets no deferral, and has nothing to read. Empty/absent under
-   * `--download=all`, which defers nothing by definition.
+   * `--cache-download=all`, which defers nothing by definition.
    */
   downloadDowngrades?: ReadonlyArray<{ taskId: string; reason: string }>
 }
 
 export interface PlanArgs {
   nodes: Map<string, TaskNode>
-  /** Per-task `--download` decision, when the policy is not `all`. */
+  /** Per-task `--cache-download` decision, when the policy is not `all`. */
   downloadOf?: (id: string) => 'eager' | 'deferred' | 'never' | undefined
   /** See `RunPlan.downloadDowngrades`. */
   downloadDowngrades?: ReadonlyArray<{ taskId: string; reason: string }>
   workspaceRoot: string
-  workspaceFingerprint: string
   cache: CacheLayer
   cachePolicy?: CachePolicy
   forwardArgs?: readonly string[] | undefined
@@ -150,7 +149,6 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
         node,
         upstream,
         workspaceRoot: args.workspaceRoot,
-        workspaceFingerprint: args.workspaceFingerprint,
         cache: args.cache,
         forwardArgs: args.forwardArgs,
         nestedProjectDirs: args.nestedDirsByProject.get(node.projectName) ?? [],
@@ -166,7 +164,7 @@ export async function plan(args: PlanArgs): Promise<RunPlan> {
 
       // Prediction keys off READS: a no-read policy re-executes every task,
       // so nothing is probed. Whether that run is a miss or no cache at all
-      // is the WRITE axes': `--force` and `--cache=local:w` save what they
+      // is the WRITE axes': `--force` and `--cache-policy=local:w` save what they
       // run, and the plan called them `no-cache`, the label a task with no
       // `cache` block gets (item 991). The probe below routes through the
       // policy-aware cache layer, which itself respects read gating.

package/src/orchestrator/plugin-host.ts

@@ -8,11 +8,20 @@
 // See docs/design/pipeline-2026-09.md.
 
 import path from 'node:path'
-import { ChainedCache, type CacheLayer } from '../cache/index.js'
+import {
+  type Cache,
+  ChainedCache,
+  type CacheLayer,
+  type CachePolicy,
+  LayeredCache,
+  absentPluginCache,
+  type PluginCache,
+  type PluginCacheRemote,
+} from '../cache/index.js'
 import { localExecutor, type TaskExecutor } from '../exec/index.js'
 import { maskedLine, settleWithin, teardownTimeoutMs, UserError } from '../util/index.js'
-import type { ProjectConfig, WorkspaceConfig, WorkspaceRules } from '../config.js'
-import { checkGraph, type TaskNode } from '../graph/index.js'
+import type { ProjectConfig, WorkspaceConfig } from '../config.js'
+import { checkGraph, type GraphRules, type TaskNode } from '../graph/index.js'
 import type {
   CacheContext,
   DiscoverContext,
@@ -21,8 +30,9 @@ import type {
   FingerprintContext,
   GraphHookContext,
   KeyHookContext,
-  NamedProject,
+  DiscoveredProject,
   ProjectHookContext,
+  RunReport,
   ScheduleHookContext,
   VxPlugin,
   WorkspaceHookContext,
@@ -46,24 +56,8 @@ function isRecord(v: unknown): v is Record<string, unknown> {
   return proto === Object.prototype || proto === null
 }
 
-/** Every method `CacheLayer` requires (the optional ones are probed with `?.`). */
-export const CACHE_LAYER_METHODS: readonly string[] = [
-  'key',
-  'get',
-  'has',
-  'prefetch',
-  'loadOutputFilesBatch',
-  'isOutputsCurrent',
-  'restoreOutputs',
-  'save',
-  'ingest',
-  'recordRunBundle',
-  'stats',
-  'hashFile',
-  'outputsPath',
-  'prune',
-  'close',
-]
+/** Every method a `cache` hook's `RemoteCacheLayer` requires (`hasMany` is optional). */
+export const REMOTE_CACHE_METHODS: readonly string[] = ['has', 'get', 'put']
 
 /** What a capability hook handed back must be what the seam runs. */
 function assertShape(
@@ -96,7 +90,7 @@ async function safe<T>(plugin: VxPlugin, hook: string, fn: () => T | Promise<T>)
     return await fn()
   } catch (err) {
     // Masked here, not by whoever prints it: an embedder of `run()` and
-    // `vx mcp` print it as they get it, and the throw quotes what the
+    // a plugin's verb print it as they get it, and the throw quotes what the
     // plugin was told (a remote's reply, a header) (L-11).
     throw new UserError(
       maskedLine(
@@ -158,15 +152,21 @@ export async function applyConfigHooks(
 
 /**
  * `discover` stage: each plugin names directories to add to `projects`,
- * seeing the ones earlier plugins added. `add` turns one name into a meta
- * (null: already there) or refuses it.
+ * seeing the ones earlier plugins added. `add` turns one entry into the
+ * project it names, `added` when it is new, or refuses it. Returns every
+ * entry's edges with the project and plugin they came from, for the caller
+ * to resolve once every plugin has run.
  */
 export async function applyDiscoverHooks(
   plugins: readonly VxPlugin[],
   projects: ProjectMeta[],
   ctx: Omit<DiscoverContext, 'projects'>,
-  add: (named: NamedProject, plugin: VxPlugin) => Promise<ProjectMeta | null>,
-): Promise<void> {
+  add: (
+    entry: DiscoveredProject,
+    plugin: VxPlugin,
+  ) => Promise<{ meta: ProjectMeta; added: boolean }>,
+): Promise<DiscoveredEdges[]> {
+  const edges: DiscoveredEdges[] = []
   for (const plugin of plugins) {
     if (plugin.discover === undefined) continue
     const named = await safe(plugin, 'discover', () => plugin.discover!({ ...ctx, projects }))
@@ -175,11 +175,23 @@ export async function applyDiscoverHooks(
         `plugin '${plugin.name}' failed in discover: expected an array, got ${describeValue(named)}`,
       )
     }
-    for (const n of named as readonly NamedProject[]) {
-      const meta = await add(n, plugin)
-      if (meta !== null) projects.push(meta)
+    for (const entry of named as readonly DiscoveredProject[]) {
+      const { meta, added } = await add(entry, plugin)
+      if (added) projects.push(meta)
+      if (entry.deps !== undefined || entry.reach !== undefined) {
+        edges.push({ by: plugin.name, meta, deps: entry.deps, reach: entry.reach ?? [] })
+      }
     }
   }
+  return edges
+}
+
+export interface DiscoveredEdges {
+  readonly by: string
+  readonly meta: ProjectMeta
+  /** Absent when the entry carried none; `[]` still makes the workspace an edge source. */
+  readonly deps: readonly string[] | undefined
+  readonly reach: readonly string[]
 }
 
 /** `project` stage: every plugin edits one project's config in place. */
@@ -215,7 +227,7 @@ export async function applyGraphHooks(
   ctx: GraphHookContext,
   /** Runs after EACH plugin's edit, so a refused task config names the plugin that wrote it. */
   afterEach?: (plugin: VxPlugin) => void,
-  rules?: WorkspaceRules,
+  rules?: GraphRules,
 ): Promise<void> {
   let last: VxPlugin | undefined
   for (const plugin of plugins) {
@@ -377,12 +389,14 @@ export async function claimedAffected(
 export async function applyScheduleHooks(
   plugins: readonly VxPlugin[],
   nodes: ReadonlyMap<string, TaskNode>,
-  ctx: ScheduleHookContext,
+  ctx: Omit<ScheduleHookContext, 'cache'>,
+  cacheFor: (plugin: string) => PluginCache = () => absentPluginCache,
 ): Promise<ReadonlyMap<string, number>> {
   const merged = new Map<string, number>()
   for (const plugin of plugins) {
     if (plugin.schedule === undefined) continue
-    const weights = await safe(plugin, 'schedule', () => plugin.schedule!(nodes, ctx))
+    const own = { ...ctx, cache: cacheFor(plugin.name) }
+    const weights = await safe(plugin, 'schedule', () => plugin.schedule!(nodes, own))
     if (weights === undefined) continue
     // Iterating a string destructures its characters into `[id, w]` pairs
     // that match no task — a plugin returning `'fast'` used to be a no-op
@@ -466,58 +480,77 @@ export function buildAdmission(
   }
 }
 
+/** What `resolveCache` needs beyond a hook's context: the store and policy core owns. */
+export interface CacheHost extends CacheContext {
+  readonly localCache: Cache
+  readonly policy: CachePolicy
+  /** Filled with each remote and what its policy lets it do, for the plugins' `ctx.cache`. */
+  readonly remotes?: PluginCacheRemote[]
+}
+
 /**
- * Collect every plugin's `cache` layer in declaration order, with the local
- * store at the tail, and chain them (lookup walks them, save reaches all;
- * see ChainedCache). The local store is dropped when a declared layer wraps
- * it (`layer.local === ctx.localCache`), so a remote plugin that layers over
- * the local handle does not also write it directly. Only a single layer
- * left is used as is: the local store when no plugin declares one, or the
- * one layer that wraps it.
+ * Collect every plugin's remote (`cache` hook) in declaration order and
+ * layer each over the local store: a lookup asks the local store first,
+ * then each remote in order (owner, 2026-10-13), and a save reaches every
+ * remote. The run's policy, narrowed by a remote's `access`, and its scope
+ * gate each remote; a remote's throw is a miss and a warning naming its
+ * plugin. No remote → the local store alone.
  */
 export async function resolveCache(
   plugins: readonly VxPlugin[],
-  ctx: CacheContext,
+  host: CacheHost,
 ): Promise<CacheLayer> {
+  const { localCache, policy, remotes, ...ctx } = host
   const layers: CacheLayer[] = []
-  const owners = new Map<CacheLayer, string>()
+  const owners: string[] = []
   for (const plugin of plugins) {
     if (plugin.cache === undefined) continue
-    const layer = await safe(plugin, 'cache', () => plugin.cache!(ctx))
-    if (layer === undefined) continue
-    // The seam's WHOLE contract, checked once here: a layer missing a
-    // method otherwise failed at the first task that reached it — an
-    // internal TypeError deep in the chain, naming neither the plugin nor
-    // the hook. Five names were checked before, so a layer with those five
-    // passed and died at its first hit inside restoreOutputs.
-    assertShape(plugin, 'cache', layer, CACHE_LAYER_METHODS, 'a cache layer')
-    layers.push(layer)
-    if (!owners.has(layer)) owners.set(layer, `plugin '${plugin.name}'`)
+    const remote = await safe(plugin, 'cache', () => plugin.cache!(ctx))
+    if (remote === undefined) continue
+    // The hook returned a whole layer until 0.0.637: name the fix, not the
+    // three methods such a layer happens to have.
+    if (isRecordLike(remote) && typeof remote['restoreOutputs'] === 'function') {
+      throw new UserError(
+        `plugin '${plugin.name}' returned a cache layer from cache: since vx 0.0.637 the hook ` +
+          'returns the remote alone (a RemoteCacheLayer: has, get, put) and core layers it over ' +
+          'the local cache — return the remote you passed to LayeredCache',
+      )
+    }
+    assertShape(plugin, 'cache', remote, REMOTE_CACHE_METHODS, 'a remote cache layer')
+    const access = remote.access
+    const own: CachePolicy = {
+      ...policy,
+      remoteRead: policy.remoteRead && access?.read !== false,
+      remoteWrite: policy.remoteWrite && access?.write !== false,
+    }
+    remotes?.push({ remote, read: own.remoteRead, write: own.remoteWrite })
+    layers.push(
+      new LayeredCache(localCache, remote, {
+        policy: own,
+        onRemoteError: (err) => ctx.warn(`[vx] plugin '${plugin.name}': ${err.message}`),
+      }),
+    )
+    owners.push(`the cache layer of plugin '${plugin.name}'`)
   }
-  // Core's own store is the TAIL of the chain — the floor under every
-  // lookup, not a plugin a workspace has to declare. A layer that WRAPS
-  // the local handle subsumes it below, so a remote plugin does not write
-  // the local store twice.
-  if (!layers.includes(ctx.localCache)) layers.push(ctx.localCache)
-  const wrapsLocal = layers.some((l) => l !== ctx.localCache && l.local === ctx.localCache)
-  const distinct = wrapsLocal ? layers.filter((l) => l !== ctx.localCache) : layers
-  if (distinct.length === 1) return distinct[0]!
+  if (layers.length === 0) return localCache
+  if (layers.length === 1) return layers[0]!
   // One line per layer and method: a layer that throws on every lookup
   // would otherwise print once per task.
   const told = new Set<string>()
-  return new ChainedCache(distinct, (i, method, err) => {
-    const layer = distinct[i]!
-    const who =
-      layer === ctx.localCache ? 'the local cache' : (owners.get(layer) ?? 'a cache layer')
+  return new ChainedCache(layers, (i, method, err) => {
     if (told.has(`${i}\0${method}`)) return
     told.add(`${i}\0${method}`)
     const m = err instanceof Error ? err.message : String(err)
     const then =
       method === 'save' ? 'the other layers still save' : 'a miss there; the next layer answers'
-    ctx.warn(`[vx] ${who} failed in cache ${method}: ${m}; ${then}`)
+    ctx.warn(`[vx] ${owners[i]} failed in cache ${method}: ${m}; ${then}`)
   })
 }
 
+function isRecordLike(v: unknown): v is Record<string, unknown> {
+  return typeof v === 'object' && v !== null
+}
+
 /** The plugin each resolved executor came from, so a hook of it that throws is named. */
 const executorPlugin = new WeakMap<TaskExecutor, string>()
 
@@ -604,12 +637,13 @@ export async function resolveExecutors(
 export async function teardownPlugins(
   plugins: readonly VxPlugin[],
   warn: (message: string) => void,
+  report?: RunReport,
 ): Promise<void> {
   for (const plugin of plugins) {
     if (plugin.teardown === undefined) continue
     const ms = teardownTimeoutMs()
     try {
-      const settled = await settleWithin(Promise.resolve(plugin.teardown()), ms)
+      const settled = await settleWithin(Promise.resolve(plugin.teardown(report)), ms)
       // Same rule as the flush above. A teardown that never settles has left
       // whatever it owns un-released, and the run exits anyway — silence would
       // present that as a clean shutdown.