@vzn/vx 0.0.642 → 0.0.644

package/src/orchestrator/prepare.ts

@@ -26,20 +26,23 @@ import {
   writesRunStore,
   type PluginCache,
   type ResolvedRemote,
-  ScopedCache,
+  BranchScope,
   applyGitEnumeration,
   gitPathspecs,
   MAX_SCOPED_PATHSPECS,
   startGitEnumeration,
   lazyGitEnumeration,
   measureFsClockLag,
+  DEFAULT_STORE,
+  type StoreOptions,
 } from '../cache/index.js'
 import {
   buildPackageGraph,
   computeNestedProjectDirs,
   findWorkspaceRoot,
-  cacheScopeEnvError,
-  isCacheScope,
+  type AffectedChanges,
+  branchChanges,
+  configuredBaseBranch,
   type LoadReads,
   PROJECT_CONFIG_FILENAMES,
   readClaimedFiles,
@@ -78,17 +81,17 @@ import {
   lockReader,
   type LoadedProjects,
 } from './projects.js'
-import { keptByAffected } from './affected-tasks.js'
+import { keptByAffected, keyedByChange } from './affected-tasks.js'
 import { applyGraphStage } from './graph-stage.js'
 import { keyExcludedDependencies } from './excluded-keys.js'
 import { FingerprintWatch } from './fingerprint-watch.js'
 import type { VxPlugin } from './plugin.js'
 import { askIgnoredOutputs, gatedOutputs } from './stable-keys.js'
-import { currentBranch } from './run-context.js'
+import { currentBranch, resolveCacheScope } from './run-context.js'
 import { createHashCache, type HashCache } from './task-hash.js'
 import { type Logger, warnOf } from '../report/index.js'
 import type { RunOptions } from './options.js'
-import { runRules } from '../settings.js'
+import { resolveSetting, runRules } from '../settings.js'
 
 export interface PreparedRun {
   workspaceRoot: string
@@ -113,6 +116,8 @@ export interface PreparedRun {
   hasRemoteLayer: boolean
   /** `--cache-policy` with the workspace's `cacheScope` applied: what the layers were built under. */
   cachePolicy: CachePolicy
+  /** The scope this run's cache reads and writes, when one is set; named on the summary's `info` row. */
+  cacheScope: string | undefined
   /** The run's remotes in declared order, as the policy gates each; `openRemotes` turns one off. */
   remotes: ResolvedRemote[]
   /**
@@ -249,8 +254,21 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     (reused !== undefined ? gitOfDiscovery(reused.projects) : undefined) ??
     lazyGitEnumeration(workspaceRoot)
   if (wholeTree) void git.start()
-  const { workspaceConfig, plugins } = await loadWorkspacePlugins(workspaceRoot, warnOf(log))
+  const {
+    workspaceConfig,
+    plugins,
+    branch: branchFacts,
+  } = await loadWorkspacePlugins(workspaceRoot, warnOf(log))
   mark('workspace config')
+  const baseBranch = configuredBaseBranch(workspaceConfig)
+  const cacheScope =
+    options.cacheScope ??
+    resolveCacheScope(
+      workspaceRoot,
+      branchFacts.trusted === true ? null : branchFacts.scope,
+      plugins.some((p) => p.cache !== undefined),
+      baseBranch,
+    )
   let learnedBranch: string | null | undefined
   const branch = (): string | null =>
     learnedBranch === undefined
@@ -269,10 +287,38 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // Asked now, read when the cache opens: a repository with no remote is
   // named by its root commit, a git spawn the discovery below overlaps.
   const storeRoot = options.cacheDir ? null : resolveStoreRoot(workspaceRoot, workspaceConfig)
-  const projectMetas =
+  const discovering =
     reused !== undefined
-      ? reused.projects
-      : await discoverProjects(workspaceRoot, readLock, plugins, cacheDir, warnOf(log), git)
+      ? Promise.resolve(reused.projects)
+      : discoverProjects(workspaceRoot, readLock, plugins, cacheDir, warnOf(log), git)
+  // What the branch changed decides which tasks read the scope (owner,
+  // 2026-10-17). Only a scoped run's first remote call asks git: a run the
+  // local cache answers makes no remote call, and diffing beside discovery
+  // cost it 20-60 ms at 1k-5k projects.
+  const scopeChanges: (() => Promise<AffectedChanges>) | undefined =
+    cacheScope === undefined
+      ? undefined
+      : options.scopeChanges !== undefined
+        ? async () => options.scopeChanges!
+        : () =>
+            branchChanges(
+              workspaceRoot,
+              options.scopeBase ?? branchFacts.base,
+              baseBranch,
+              discovering,
+              {
+                untracked: async () => (await git.start()).untracked,
+                // A scoped enumeration lists only its projects: null asks git.
+                links: async () => {
+                  const g = await git.start()
+                  if (!g.scopes.includes('.')) return null
+                  const out: string[] = []
+                  for (const [rel, oid] of g.trusted) if (oid.startsWith('120000:')) out.push(rel)
+                  return out
+                },
+              },
+            )
+  const projectMetas = await discovering
   mark('discover projects')
 
   // SCOPED config loading: configs are programs, and evaluating 1090
@@ -314,12 +360,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // so a reader profiling that stage was sent to the wrong code.
   mark('package graph')
 
-  // `--cache-scope`, then `VX_CACHE_SCOPE`, win over the workspace (and `github()`'s guess):
-  // a CI job that knows its trust level says so without editing config.
-  const envScope = process.env['VX_CACHE_SCOPE'] || undefined
-  if (envScope !== undefined && !isCacheScope(envScope)) throw cacheScopeEnvError()
   const workspacePolicy = workspaceCachePolicy(workspaceConfig)
-  const cacheScope = options.cacheScope ?? envScope ?? workspaceConfig?.cache?.scope
   const asked =
     options.cache ?? applyCacheFlags(workspacePolicy ?? FULL_CACHE_POLICY, options.cacheFlags)
   // A laptop reads the shared cache and does not write it unless a policy
@@ -337,6 +378,14 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     options.artifactCeiling,
     'open',
     await storeRoot,
+    {
+      embeddings: (resolveSetting('cache.store.embeddings', workspaceConfig).value ??
+        DEFAULT_STORE.embeddings) as number,
+      decompress: (resolveSetting('cache.store.decompress', workspaceConfig).value ??
+        DEFAULT_STORE.decompress) as boolean,
+      verify: (resolveSetting('cache.store.verify', workspaceConfig).value ??
+        DEFAULT_STORE.verify) as StoreOptions['verify'],
+    },
   )
   const unwritable = localCache.readOnlyNotice()
   if (unwritable !== null) warnOf(log)(`[vx] ${unwritable}`)
@@ -470,6 +519,9 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   // cache plugin.
   let cache: CacheLayer
   const remotes: ResolvedRemote[] = []
+  // A scope only picks remote keys (owner, 2026-10-17): the local store
+  // keeps every branch's entries under the task keys.
+  const branchScope = cacheScope === undefined ? undefined : new BranchScope(cacheScope)
   if (options.remoteCache) {
     remotes.push({
       remote: options.remoteCache,
@@ -480,7 +532,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   }
   try {
     cache = options.remoteCache
-      ? new LayeredCache(localCache, remotes)
+      ? new LayeredCache(localCache, remotes, branchScope, options.uploadConcurrency)
       : await resolveCache(plugins, {
           workspaceRoot,
           cacheDir,
@@ -489,6 +541,10 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
           localCache,
           policy,
           remotes,
+          ...(branchScope !== undefined ? { branch: branchScope } : {}),
+          ...(options.uploadConcurrency !== undefined
+            ? { uploadConcurrency: options.uploadConcurrency }
+            : {}),
         })
   } catch (err) {
     // A cache plugin that throws or returns something off-contract is
@@ -499,8 +555,6 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     localCache.close()
     throw err
   }
-  // One scoping rule above every layer, local and remote alike.
-  if (cacheScope !== undefined) cache = new ScopedCache(cache, cacheScope)
   // 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
@@ -534,6 +588,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       localCache,
       hasRemoteLayer,
       cachePolicy: policy,
+      cacheScope,
       remotes,
       keepRunEntry: undefined,
       priorities: () => Promise.resolve(new Map()),
@@ -721,6 +776,13 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     if (hasHook(plugins, 'key')) {
       await applyKeyHooks(plugins, nodes, { workspaceRoot, cacheDir, warn: warnOf(log) })
     }
+    // The final inputs decide which tasks the branch changed: they read
+    // the scope, every other task the default key.
+    if (branchScope !== undefined && scopeChanges !== undefined) {
+      branchScope.routeTasks(async () =>
+        keyedByChange(nodes, await scopeChanges(), projects, packageGraph),
+      )
+    }
     refuseFiltersThroughGroups(nodes)
     const exclude = options.excludeDependencies
     let keyOnly: ReadonlyMap<string, TaskNode> = new Map()
@@ -783,6 +845,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
       localCache,
       hasRemoteLayer,
       cachePolicy: policy,
+      cacheScope,
       remotes,
       priorities,
       branch,

package/src/orchestrator/projects.ts

@@ -25,6 +25,8 @@ import type { WorkspaceConfig } from '../config.js'
 import { lazyGitEnumeration, type LazyGitEnumeration } from '../cache/index.js'
 import { relPosix, UserError } from '../util/index.js'
 import {
+  cacheScopeError,
+  isCacheScope,
   loadWorkspaceConfig,
   discoveredProject,
   linkDiscoveredEdges,
@@ -33,7 +35,7 @@ import {
 } from '../workspace/index.js'
 import { parseDependencySpec } from '../graph/index.js'
 import { applyConfigHooks, applyDiscoverHooks, applyProjectHooks, hasHook } from './plugin-host.js'
-import type { VxPlugin } from './plugin.js'
+import type { BranchFacts, VxPlugin } from './plugin.js'
 
 /**
  * The workspace config with the plugin `config` stage applied — the first
@@ -43,10 +45,16 @@ import type { VxPlugin } from './plugin.js'
 export async function loadWorkspacePlugins(
   workspaceRoot: string,
   warn: (message: string) => void,
-): Promise<{ workspaceConfig: WorkspaceConfig | null; plugins: readonly VxPlugin[] }> {
+): Promise<{
+  workspaceConfig: WorkspaceConfig | null
+  plugins: readonly VxPlugin[]
+  branch: BranchFacts
+}> {
   const loaded = await loadWorkspaceConfig(workspaceRoot)
   const plugins = (loaded?.plugins ?? []) as readonly VxPlugin[]
-  if (loaded === null || !hasHook(plugins, 'config')) return { workspaceConfig: loaded, plugins }
+  const branch: BranchFacts = {}
+  if (loaded === null || !hasHook(plugins, 'config'))
+    return { workspaceConfig: loaded, plugins, branch }
   // Bun keeps one module per specifier, so the file's export is one object
   // per process: the CLI's selection pass, the run and each `vx watch`
   // cycle handed the hooks what the last load's hooks had edited
@@ -60,10 +68,23 @@ export async function loadWorkspacePlugins(
   // Re-validated after each plugin, as the `project` stage is: an edit
   // the loader would refuse from a user (`concurrency: -3`) hung the run,
   // and `cacheDir: 42` reached `path.resolve` as a TypeError.
-  await applyConfigHooks(plugins, workspaceConfig, { workspaceRoot, warn }, (plugin) =>
+  const setBranch = (facts: BranchFacts): void => {
+    if (facts.scope !== undefined && !isCacheScope(facts.scope))
+      throw new UserError(`setBranch: ${cacheScopeError('scope')}`)
+    if (facts.trusted === true) {
+      delete branch.scope
+      branch.trusted = true
+    }
+    if (facts.scope !== undefined) {
+      branch.scope = facts.scope
+      delete branch.trusted
+    }
+    if (facts.base !== undefined) branch.base = facts.base
+  }
+  await applyConfigHooks(plugins, workspaceConfig, { workspaceRoot, warn, setBranch }, (plugin) =>
     validateWorkspace(workspaceConfig, `.vx/workspace (after plugin '${plugin.name}')`),
   )
-  return { workspaceConfig, plugins }
+  return { workspaceConfig, plugins, branch }
 }
 
 /**

package/src/orchestrator/remote-prefetch.ts

@@ -37,7 +37,7 @@ export interface PrefetchArgs {
   nestedDirsByProject: Map<string, string[]>
   gitFilesCache: GitFilesCache
   hashCache: HashCache
-  /** Cap on concurrent in-flight prefetches — the run's concurrency. */
+  /** Cap on concurrent in-flight prefetches (`cache.concurrency.download`). */
   concurrency: number
   /** When false (remote reads disabled), no prefetch fires. */
   remoteRead: boolean
@@ -75,10 +75,14 @@ export function startRemotePrefetch(args: PrefetchArgs): Promise<void> {
   // a still-in-flight prefetch can never ingest into a closed DB. Errors
   // degrade inside LayeredCache.prefetch; the catch keeps the handle
   // from ever rejecting.
-  return runPrefetch(args).catch(() => {})
+  const started = Promise.withResolvers<void>()
+  args.cache.probeFirst?.(started.promise)
+  return runPrefetch(args, started.resolve)
+    .catch(() => {})
+    .finally(started.resolve)
 }
 
-async function runPrefetch(args: PrefetchArgs): Promise<void> {
+async function runPrefetch(args: PrefetchArgs, probing: () => void): Promise<void> {
   const stableKeys = await deriveStableKeys(args)
   if (stableKeys.length === 0) return
 
@@ -94,7 +98,10 @@ async function runPrefetch(args: PrefetchArgs): Promise<void> {
   let toPrefetch = held === null ? stableKeys : stableKeys.filter((k) => !held.has(k.hash))
   if (toPrefetch.length === 0) return
   const uniqueHashes = [...new Set(toPrefetch.map((k) => k.hash))]
-  const present = (await args.cache.remoteHasMany?.(uniqueHashes)) ?? null
+  const asked = args.cache.remoteHasMany?.(uniqueHashes)
+  // Every lookup that waited on the probe now finds its hash in it.
+  probing()
+  const present = (await asked) ?? null
   if (present !== null) {
     args.cache.markRemoteAbsent?.(uniqueHashes.filter((h) => !present.has(h)))
     // The pre-mark above already answers a pull for an absent hash from

package/src/orchestrator/run-context.ts

@@ -15,6 +15,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { executablePath, gitEnv, relPosix, ulid, xxh3hex } from '../util/index.js'
 import { resolveSetting } from '../settings.js'
+import { branchCacheScope, cacheScopeEnvError, isCacheScope } from '../workspace/index.js'
 import { VERSION } from '../version.js'
 import type { RunContextRecord } from './telemetry.js'
 
@@ -525,6 +526,90 @@ export function currentBranch(
   return set ?? captureGitContext(workspaceRoot, null, env).branch
 }
 
+/**
+ * The cache scope a checkout on a branch reads, from the `.git` files
+ * alone (owner, 2026-10-17): `<owner>/<repo>:<branch>`, the branch it
+ * tracks (`branch.<name>.merge` on `branch.<name>.remote`), else its own
+ * name on `origin`, the repository named by that remote's URL. None on
+ * the default branch, on a detached HEAD, or with no remote URL. CI writes
+ * that scope for the same branch (`github()`), so a laptop reads what its
+ * branch's CI saved.
+ */
+export function localBranchScope(
+  workspaceRoot: string,
+  baseBranch: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const head = readHeadDirect(workspaceRoot)
+  if (head === null || head.branch === null) return undefined
+  const config = gitConfigSections(workspaceRoot)
+  const own = config.get(`branch "${head.branch}"`)
+  const name = own?.get('merge')?.replace(/^refs\/heads\//, '') ?? head.branch
+  const url = config.get(`remote "${own?.get('remote') ?? 'origin'}"`)?.get('url')
+  const repo = url === undefined ? undefined : repoOfUrl(url)
+  if (repo === undefined) return undefined
+  const trunk = baseBranch ?? captureDefaultBranch(env, workspaceRoot)
+  if (trunk === null ? name === 'main' || name === 'master' : name === trunk) return undefined
+  return branchCacheScope(repo, name)
+}
+
+/**
+ * The repository's path on its host (`owner/repo`; a GitLab subgroup's
+ * `group/sub/repo` whole, as `gitlab()` names it); undefined for a local path.
+ */
+function repoOfUrl(url: string): string | undefined {
+  const parts = normalizeRemoteUrl(url).split('/')
+  return parts.length < 3 ? undefined : parts.slice(1).join('/')
+}
+
+/** `.git/config`'s sections, each a key → value map (last wins); empty when it cannot be read. */
+function gitConfigSections(workspaceRoot: string): Map<string, Map<string, string>> {
+  const sections = new Map<string, Map<string, string>>()
+  try {
+    const dirs = refDirsOf(workspaceRoot)
+    if (dirs === null) return sections
+    let at: Map<string, string> | undefined
+    for (const raw of fs.readFileSync(path.join(dirs.commonDir, 'config'), 'utf8').split('\n')) {
+      const line = raw.trim()
+      const section = /^\[\s*(\w+)(?:\s+"(.*)")?\s*\]$/.exec(line)
+      if (section !== null) {
+        const key = section[2] === undefined ? section[1]! : `${section[1]} "${section[2]}"`
+        at = sections.get(key) ?? new Map()
+        sections.set(key, at)
+        continue
+      }
+      const kv = /^(\w+)\s*=\s*(.*)$/.exec(line)
+      if (kv !== null) at?.set(kv[1]!.toLowerCase(), kv[2]!.trim())
+    }
+  } catch {
+    // no config to read: no remote, so no scope.
+  }
+  return sections
+}
+
+/**
+ * The run's cache scope (owner, 2026-10-17): `VX_CACHE_SCOPE` (empty: none),
+ * else a plugin's (`setBranch`, `github()` on Actions; null: the plugin
+ * named the run trusted), else, with a cache plugin to share it, the
+ * branch's from git. Undefined: the default keys.
+ */
+export function resolveCacheScope(
+  workspaceRoot: string,
+  pluginScope: string | null | undefined,
+  hasRemote: boolean,
+  baseBranch: string | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+): string | undefined {
+  const named = env['VX_CACHE_SCOPE']
+  if (named !== undefined) {
+    if (named === '') return undefined
+    if (!isCacheScope(named)) throw cacheScopeEnvError()
+    return named
+  }
+  if (pluginScope === null) return undefined
+  return pluginScope ?? (hasRemote ? localBranchScope(workspaceRoot, baseBranch, env) : undefined)
+}
+
 export interface TelemetryRunContextArgs {
   runId: string
   /** The invocation, already masked. */

package/src/orchestrator/run-settings.ts

@@ -14,6 +14,9 @@ const FROM_OPTIONS = {
   retries: 'run.retries',
   continueMode: 'run.continue',
   download: 'cache.download',
+  downloadConcurrency: 'cache.concurrency.download',
+  uploadConcurrency: 'cache.concurrency.upload',
+  restoreConcurrency: 'cache.concurrency.restore',
 } as const satisfies Partial<Record<keyof RunOptions, string>>
 
 /**

package/src/orchestrator/run.ts

@@ -11,6 +11,7 @@ import {
   type CachePolicy,
   cachesNothing,
   formatCachePolicy,
+  networkConcurrency,
   stopRuntimeProbes,
   sweepStaging,
 } from '../cache/index.js'
@@ -259,6 +260,10 @@ function refuseRunOptions(options: RunOptions): void {
   const { concurrency, retries, timeout } = options
   if (concurrency !== undefined && !(Number.isInteger(concurrency) && concurrency > 0))
     refuse('concurrency', concurrency, 'a positive integer')
+  for (const field of ['downloadConcurrency', 'uploadConcurrency', 'restoreConcurrency'] as const) {
+    const v = options[field]
+    if (v !== undefined && !(Number.isInteger(v) && v > 0)) refuse(field, v, 'a positive integer')
+  }
   if (retries !== undefined && !(Number.isInteger(retries) && retries >= 0))
     refuse('retries', retries, 'a non-negative integer')
   if (
@@ -618,7 +623,7 @@ async function runOnBus(
   // `vx cache clean` can evict entries the run just hit. Once-only
   // because the normal path closes before the persistent-task wait —
   // holding the handle open for a dev server's whole lifetime would be
-  // worse — and because close() re-runs its retention DELETEs.
+  // worse.
   let cacheClosed = false
   const closeCache = async (): Promise<void> => {
     if (cacheClosed) return
@@ -799,6 +804,7 @@ async function runOnBus(
       version: VERSION,
       packageCount: packagesInScope.size,
       remoteCacheEnabled,
+      cacheScope: prepared.cacheScope,
       cache: {
         local: policy.localRead || policy.localWrite,
         localWrite: policy.localWrite,
@@ -870,7 +876,7 @@ async function runOnBus(
           nestedDirsByProject,
           gitFilesCache,
           hashCache,
-          concurrency,
+          concurrency: options.downloadConcurrency ?? networkConcurrency(),
           remoteRead: policy.remoteRead,
           remoteWrite: policy.remoteWrite,
         }),
@@ -1087,6 +1093,7 @@ async function runOnBus(
     const outcomes = await runGraph({
       nodes,
       concurrency,
+      restoreConcurrency: options.restoreConcurrency ?? 2 * concurrency,
       settledOf: (o) => deferredSaves.get(o.node.id),
       ...(hasPooledExecutor(executors) ? { poolOf: poolOfPlacement(placements) } : {}),
       ...(admit !== undefined ? { admit } : {}),
@@ -1348,9 +1355,6 @@ async function runOnBus(
     // The miss path's output-directory snapshots first (miss-save.ts).
     await step('vx:snapshots', () => recordOutputDirSnapshots(cache, outputDirSnapshots))
     mark('output dir snapshots')
-    // Not on a stopped run: one stopped while it waited on another run's
-    // lock never held it, and its prune evicted under that run (item 858).
-    if (!stop.signal.aborted) await step('vx:retention', () => applyCacheRetention(prepared))
     // A plugin hears the run until its teardown and nothing after: released
     // only in the finally, its handlers heard a kept server through the
     // whole keep-alive wait below (C-66). Idempotent; the finally's stay.
@@ -1487,27 +1491,6 @@ async function runOnBus(
   }
 }
 
-/**
- * `cache.retention`, after every save and upload of this run
- * has landed (so nothing this run wrote is mid-flight) and before the cache
- * closes. Housekeeping, not the run's work: silent, and a failure is never
- * a failed run. Declared nowhere → one property read.
- */
-async function applyCacheRetention(prepared: PreparedRun): Promise<void> {
-  const ws = prepared.workspaceConfig
-  const maxAgeMs = resolveSetting('cache.retention.olderThan', ws).value as number | undefined
-  const maxBytes = resolveSetting('cache.retention.maxSize', ws).value as number | undefined
-  if (maxAgeMs === undefined && maxBytes === undefined) return
-  try {
-    await prepared.localCache.evictIfDue({
-      ...(maxAgeMs !== undefined ? { maxAgeMs } : {}),
-      ...(maxBytes !== undefined ? { maxBytes } : {}),
-    })
-  } catch {
-    // Housekeeping says nothing (owner): the next due run tries again.
-  }
-}
-
 /** Why an `--affected` run has nothing to run, said alike by the run and its `--dry` plan. */
 function noneAffected(prepared: PreparedRun, options: RunOptions): string {
   // A changed project declares the task, so `--affected`'s task walk is

package/src/orchestrator/task-hash.ts

@@ -97,6 +97,12 @@ export interface ComputeHashArgs {
  */
 export async function computeTaskHash(args: ComputeHashArgs): Promise<string> {
   if (isKeyless(args.node.config)) return keylessHash(args.node.id)
+  const key = await taskHash(args)
+  args.cache.noteKey?.(args.node.id, key)
+  return key
+}
+
+async function taskHash(args: ComputeHashArgs): Promise<string> {
   const end = span('task hash')
   try {
     const folds = args.captureInto === undefined ? args.hashCache?.folds : undefined

package/src/report/logger.ts

@@ -382,7 +382,6 @@ export function defaultLogger(
   let saved = 0
   let notSaved = 0
   let skippedCount = 0
-  let savedMs = 0
   // Each finished task's cache bucket by its key: its remote traffic moves it.
   const buckets = new Map<string, CacheBucket>()
   // The graph is done and vx's own closing steps run: the region stays,
@@ -530,7 +529,6 @@ export function defaultLogger(
               notSaved,
               miss: succeeded + failed - noCache,
               noCache,
-              savedMs,
               left: total - done - stopped - notRun,
               ...(etaMs !== undefined && !tail && !stopping ? { etaMs } : {}),
               buckets,
@@ -1028,12 +1026,10 @@ export function defaultLogger(
           case 'cache-hit':
             if (outcome.restored === false) upToDate++
             else restoredLocal++
-            savedMs += outcome.storedDurationMs ?? 0
             break
           case 'cache-hit-remote':
             if (outcome.restored === false) upToDate++
             else restoredRemote++
-            savedMs += outcome.storedDurationMs ?? 0
             break
           case 'skipped':
             skippedCount++

package/src/report/summary.ts

@@ -5,7 +5,6 @@
 
 import type { TaskOutcome } from '../graph/index.js'
 import { tallyOutcomes } from './tally.js'
-import { isCacheHit } from '../graph/index.js'
 import { outcomeLabel, projectOutcome, ranNoCache } from './events.js'
 import { isGroupTask } from '../graph/index.js'
 import {
@@ -106,8 +105,6 @@ export interface SummaryStats {
   held?: { count: number; sumMs: number }
   /** Live section only: the forecast of what is left, from history. */
   etaMs?: number
-  /** The hits' stored exec times summed: the work the cache skipped. */
-  savedMs?: number
   /** A run of groups only: their names, so `0 tasks` says why. */
   emptyGroups?: readonly string[]
   /** Each finished task's cache bucket by its key and its id (its run bytes), so its remote traffic can move it. */
@@ -188,6 +185,8 @@ export interface RunContext {
   /** Worker-pool size for this run; shown on the `info` row. */
   concurrency?: number
   remoteCacheEnabled: boolean
+  /** The run's cache scope, named after the cache mode: `scope vznjs/vx:feat-x`. */
+  cacheScope?: string | undefined
   /**
    * The cache layers the run used, so the legend reads `local 1= 2↓ 4↑ ·
    * remote 3↓ 4↑`. Absent: the plain `N miss` legend.
@@ -390,10 +389,6 @@ export function formatSummarySection(
     }
   }
   const timeParts = [total]
-  // What the cache paid back, beside what the run cost: the stored exec
-  // time of every hit, never the restore this run spent on it.
-  if ((stats.savedMs ?? 0) >= 1)
-    timeParts.push(paint(SUCCESS, `${formatElapsed(stats.savedMs!)} saved`, colors))
   // The live run's forecast leads the spread: the one number on the row
   // that is about the future.
   if (stats.etaMs !== undefined)
@@ -407,6 +402,7 @@ export function formatSummarySection(
     if (context.concurrency !== undefined)
       info.push(`${context.concurrency} worker${context.concurrency === 1 ? '' : 's'}`)
     info.push(context.remoteCacheEnabled ? 'local + remote cache' : 'local cache')
+    if (context.cacheScope !== undefined) info.push(`scope ${context.cacheScope}`)
     // The plugin's hand on the run: a task a policy held with a worker
     // free would otherwise have started; without the line nothing says
     // the policy acted. The duration is the waits summed, task-seconds
@@ -489,9 +485,6 @@ export function formatRunSummary(
   const durations = outcomes
     .filter((o) => (o.status === 'success' || o.status === 'failed') && !isGroupTask(o.node))
     .map((o) => o.durationMs)
-  let savedMs = 0
-  for (const o of outcomes)
-    if (isCacheHit(o.status) && !isGroupTask(o.node)) savedMs += o.storedDurationMs ?? 0
   const heldOutcomes = outcomes.filter((o) => o.admissionHeldMs !== undefined)
   const notRun = outcomes.filter((o) => neverStarted(o) && !isGroupTask(o.node)).length
   const emptyGroups = outcomes.every((o) => isGroupTask(o.node))
@@ -512,7 +505,6 @@ export function formatRunSummary(
       notSaved: outcomes.filter((o) => !isGroupTask(o.node) && ranUnsaved(o)).length,
       miss: t.total - t.skipped - (t.cachedLocal + t.cachedRemote) - noCache,
       noCache,
-      savedMs,
       spread:
         durations.length > 0
           ? {