@vzn/vx 0.0.643 → 0.0.644

package/src/config.ts

@@ -79,15 +79,6 @@ export interface CacheSettings {
    * `.vx/cache` and its entries in the user's shared store.
    */
   dir?: string
-  /**
-   * Evict from the local cache at the end of every run, whatever its
-   * policy (a remote hit is ingested under any), by the same policy
-   * `vx cache clean` takes as flags: entries not used for `olderThan`
-   * (`'30d'`, `'12h'`), then least-recently-used entries until the cache
-   * is under `maxSize` (`'10GB'`, `'500MB'`). Either or both. Omitted →
-   * nothing is evicted unless you run `vx cache clean`.
-   */
-  retention?: { olderThan?: Duration; maxSize?: string }
   /**
    * Which layers a run reads and writes (`'local:rw,remote:r'`; a layer it
    * leaves out stays on); `--no-cache` and `--force` still apply on top.
@@ -107,6 +98,21 @@ export interface CacheSettings {
    * both (`'always'`). Only a run whose policy writes a remote keeps any.
    */
   upload?: { failures?: 'ci' | 'local' | 'always' }
+  /**
+   * How the local cache keeps an entry. `embeddings` (default `'32KiB'`):
+   * an entry up to this size inside the index; `false`, none. `decompress` (default true): a larger one as its
+   * plain files, which a hit copies or clones out with no decode; off, as
+   * one `.tar.zst`. `verify` (default `'stat'`): what a hit on plain files
+   * checks first, each file's size and mtime, every byte (`'hash'`), or
+   * nothing (`'none'`).
+   */
+  store?: { embeddings?: false | string; decompress?: boolean; verify?: 'stat' | 'hash' | 'none' }
+  /**
+   * Cache transfers at once. `download` and `upload` (per remote) default
+   * to min(96, max(cores × 3, 64)); `restore`, local hits writing their
+   * outputs, to twice `run.concurrency`.
+   */
+  concurrency?: { download?: number; upload?: number; restore?: number }
 }
 
 /** `WorkspaceConfig.lock`. */
@@ -786,7 +792,6 @@ export function defineWorkspace<T extends WorkspaceConfig>(
         rules?: Known<At<At<T, 'run'>, 'rules'>, WorkspaceRules>
       }
       cache?: Known<At<T, 'cache'>, CacheSettings> & {
-        retention?: Known<At<At<T, 'cache'>, 'retention'>, NonNullable<CacheSettings['retention']>>
         inputStability?: Known<At<At<T, 'cache'>, 'inputStability'>, InputStability>
       }
       lock?: Known<At<T, 'lock'>, LockSettings>

package/src/exec/sandbox-paths.ts

@@ -16,8 +16,8 @@ import path from 'node:path'
  * move that spelling into the scan, which finds nothing before the task has
  * written, and turn a working grant into `Read-only file system`. The two
  * predicates answer different questions: whether a declaration must be
- * MATCHED against other declarations (495; `GLOB_WILDCARDS`, where a bracket
- * is literal since item 667), and whether a grant can be mounted (here).
+ * MATCHED against other declarations (495; `GLOB_WILDCARDS`), and whether a
+ * grant can be mounted (here).
  * Item 577 gave each question one spelling.
  */
 export const MOUNT_WILDCARDS = /[*?[\]]/

package/src/graph/scheduler.ts

@@ -239,6 +239,8 @@ export type ContinueMode = 'never' | 'deps-ok' | 'always'
 export interface ScheduleOptions {
   nodes: Map<string, TaskNode>
   concurrency: number
+  /** Restore-tier tasks at once; twice `concurrency` unset. */
+  restoreConcurrency?: number
   /**
    * An aborted run dispatches nothing further: every task not yet
    * started completes `aborted` (the ones in flight are being killed by
@@ -604,7 +606,7 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
   // the two lanes share its one slot, where a lane each let an 80 MB
   // restore run inside another task's execution (item 1103).
   let activeRestore = 0
-  const restoreConcurrency = 2 * concurrency
+  const restoreConcurrency = options.restoreConcurrency ?? 2 * concurrency
   const serial = concurrency === 1
   const execRoom = (): boolean => (serial ? active + activeRestore < 1 : active < concurrency)
   const restoreRoom = (): boolean =>

package/src/graph/task-graph.ts

@@ -4,6 +4,7 @@ import {
   checkIgnoreSync,
   ignoreProbes,
   isLiteralPattern,
+  literalPath,
   listedSync,
   normalizeGlob,
   relPosix,
@@ -915,15 +916,17 @@ export function outputsOverlap(rawA: string, rawB: string): boolean {
   // A built path proves overlap only between globs as written: a literal's
   // `/**` twin reads it as a directory, and `dist/types.d.ts` met
   // `dist/**/*.js` at `dist/types.d.ts/x.js`, a file no one can write.
-  const bothGlobs = !isLiteralPattern(rawA) && !isLiteralPattern(rawB)
+  const bothGlobs = literalPath(rawA) === null && literalPath(rawB) === null
   for (const a of asTrees([rawA])) {
     for (const b of asTrees([rawB])) {
-      if (isLiteralPattern(a) && isLiteralPattern(b)) {
-        if (a === b) return true
-      } else if (isLiteralPattern(a)) {
-        if (taskGlob(b).match(a)) return true
-      } else if (isLiteralPattern(b)) {
-        if (taskGlob(a).match(b)) return true
+      const la = literalPath(a)
+      const lb = literalPath(b)
+      if (la !== null && lb !== null) {
+        if (la === lb) return true
+      } else if (la !== null) {
+        if (taskGlob(b).match(la)) return true
+      } else if (lb !== null) {
+        if (taskGlob(a).match(lb)) return true
       } else if (a === b || covers(a, b) || covers(b, a) || (bothGlobs && witnessed(a, b)))
         return true
     }
@@ -1202,13 +1205,13 @@ function collideAcross(
  * found no match outside the head this cuts, and thousands once `\` and
  * `!` were left out (item 746).
  */
-const GLOB_HEAD_END = /[*?{}\\!]/
+const GLOB_HEAD_END = /[*?{}[\]\\!]/
 
 /** `firstSegment`'s answer for a glob that can start anywhere. */
 const ANYWHERE = ''
 
 /** Where a glob's first segment ends: a separator, or anything `GLOB_HEAD_END` stops at. */
-const FIRST_SEGMENT_END = /[*?{}\\!/]/
+const FIRST_SEGMENT_END = /[*?{}[\]\\!/]/
 
 const firstSegments = new Map<string, string>()
 
@@ -1315,8 +1318,9 @@ function overlapCandidates<T>(
     const s = sideOf?.(tasks[i]!) === true ? 1 : 0
     side.push(s)
     for (const tree of asTrees(globsOf(tasks[i]!) ?? [])) {
-      if (isLiteralPattern(tree)) {
-        literals.push([i, tree])
+      const lit = literalPath(tree)
+      if (lit !== null) {
+        literals.push([i, lit])
         continue
       }
       file(globs[s]!, tree, i)

package/src/index.ts

@@ -20,7 +20,7 @@ export { PLUGIN_HOOKS, type PluginHook } from './config.js'
 // the second, so the cgroup walk has one implementation.
 export { machineMemoryBytes, machineParallelism } from './util/index.js'
 // How core reads a task glob — its spelling, and which characters are
-// wildcards (`[` `]` are not; item 667) — for a plugin that turns declared
+// wildcards (`[` `]` and an escape are) — for a plugin that turns declared
 // outputs into something else (`@vzn/vx-reapi`'s literal `output_paths`).
 export { isLiteralPattern, normalizeGlob, restorableOutput } from './util/index.js'
 

package/src/orchestrator/doctor.ts

@@ -18,7 +18,6 @@ import {
   isUserError,
   machineMemoryBytes,
   machineParallelism,
-  parseSize,
   treeBytes,
 } from '../util/index.js'
 import { vxPath } from '../handoff.js'
@@ -99,8 +98,6 @@ export interface InfoFacts {
     string,
     { value: string | number | boolean | null; source: 'env' | 'workspace' | 'default' }
   >
-  /** `cache.retention`, with `maxSize` in bytes; null when none is set. */
-  cacheRetention: { olderThan?: string; maxSize?: string; maxBytes?: number } | null
   orphans: { artifacts: number; bytes: number }
   runs24h: number
   hits24h: number
@@ -261,7 +258,6 @@ async function collectWorkspaceInfo(
     cacheEntries: stats.entryCount,
     cacheBytes: stats.totalBytes,
     settings: settingsFact(workspaceConfig),
-    cacheRetention: retentionFact(workspaceConfig),
     // A row-less artifact is indexed again only when its task asks for its
     // key; the rest only `vx cache clean` reclaims (after an upgrade's
     // schema reset, most often).
@@ -395,16 +391,3 @@ function settingsFact(config: WorkspaceConfig | null): InfoFacts['settings'] {
   }
   return out
 }
-
-function retentionFact(config: WorkspaceConfig | null): InfoFacts['cacheRetention'] {
-  const raw = (path: string): string | undefined =>
-    process.env[envName(path)] || (atPath(config, path) as string | undefined)
-  const olderThan = raw('cache.retention.olderThan')
-  const maxSize = raw('cache.retention.maxSize')
-  if (olderThan === undefined && maxSize === undefined) return null
-  return {
-    ...(olderThan !== undefined ? { olderThan } : {}),
-    // Validated before the run (env) or at load (workspace), so it parses.
-    ...(maxSize !== undefined ? { maxSize, maxBytes: parseSize(maxSize)! } : {}),
-  }
-}

package/src/orchestrator/execute-task.ts

@@ -335,7 +335,7 @@ async function restoreProbed(
 
 /**
  * A hit restored, or null when its artifact was removed after the probe (a
- * prune, another workspace's retention on a shared cache directory): a
+ * `vx cache clean`, here or for a workspace sharing the cache directory): a
  * miss. The restore has wiped the declared outputs by then; the run path
  * cleans them again and the task writes them.
  */

package/src/orchestrator/options.ts

@@ -130,6 +130,12 @@ export interface RunOptions {
    * Locally-placed tasks always write in place and ignore this.
    */
   download?: 'all' | 'toplevel' | 'none'
+  /** Remote downloads at once (`cache.concurrency.download`). */
+  downloadConcurrency?: number
+  /** Uploads at once, per remote (`cache.concurrency.upload`). */
+  uploadConcurrency?: number
+  /** Local hits restoring at once (`cache.concurrency.restore`); twice `concurrency` unset. */
+  restoreConcurrency?: number
   /**
    * Run intent, derived by the CLI from selection flags: 'broad' iff
    * `--all` / `--filter` / `--affected` was passed, else 'focused'.

package/src/orchestrator/plugin-host.ts

@@ -558,6 +558,8 @@ export interface CacheHost extends CacheContext {
   readonly remotes?: ResolvedRemote[]
   /** The run's branch scope, which picks each remote key. */
   readonly branch?: BranchScope
+  /** Uploads at once, per remote (`cache.concurrency.upload`). */
+  readonly uploadConcurrency?: number
 }
 
 /**
@@ -572,7 +574,7 @@ export async function resolveCache(
   plugins: readonly VxPlugin[],
   host: CacheHost,
 ): Promise<CacheLayer> {
-  const { localCache, policy, remotes, branch, ...ctx } = host
+  const { localCache, policy, remotes, branch, uploadConcurrency, ...ctx } = host
   const resolved: ResolvedRemote[] = []
   for (const plugin of plugins) {
     if (plugin.cache === undefined) continue
@@ -589,7 +591,9 @@ export async function resolveCache(
     resolved.push(entry)
     remotes?.push(entry)
   }
-  return resolved.length === 0 ? localCache : new LayeredCache(localCache, resolved, branch)
+  return resolved.length === 0
+    ? localCache
+    : new LayeredCache(localCache, resolved, branch, uploadConcurrency)
 }
 
 /** The plugin each resolved executor came from, so a hook of it that throws is named. */

package/src/orchestrator/plugin.ts

@@ -347,11 +347,14 @@ export interface WorkspaceHookContext {
  * cache scope (`'vznjs/vx:feat-x'`; `VX_CACHE_SCOPE` beats it, and it
  * beats the one git names), and `base`, the commit the branch is compared
  * with (a pull request's base), for a bare `--affected` and for which
- * tasks read the scope. A later plugin's field wins.
+ * tasks read the scope. `trusted`: the run has no scope, whatever git
+ * names, and reads and writes only the default keys (a merge queue's run,
+ * owner 2026-10-18). A later plugin's field wins.
  */
 export interface BranchFacts {
   scope?: string
   base?: string
+  trusted?: boolean
 }
 
 export interface ConfigContext extends WorkspaceHookContext {

package/src/orchestrator/prepare.ts

@@ -33,6 +33,8 @@ import {
   startGitEnumeration,
   lazyGitEnumeration,
   measureFsClockLag,
+  DEFAULT_STORE,
+  type StoreOptions,
 } from '../cache/index.js'
 import {
   buildPackageGraph,
@@ -89,7 +91,7 @@ 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
@@ -263,7 +265,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
     options.cacheScope ??
     resolveCacheScope(
       workspaceRoot,
-      branchFacts.scope,
+      branchFacts.trusted === true ? null : branchFacts.scope,
       plugins.some((p) => p.cache !== undefined),
       baseBranch,
     )
@@ -376,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}`)
@@ -522,7 +532,7 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
   }
   try {
     cache = options.remoteCache
-      ? new LayeredCache(localCache, remotes, branchScope)
+      ? new LayeredCache(localCache, remotes, branchScope, options.uploadConcurrency)
       : await resolveCache(plugins, {
           workspaceRoot,
           cacheDir,
@@ -532,6 +542,9 @@ export async function prepareRun(options: RunOptions, log: Logger): Promise<Prep
           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

package/src/orchestrator/projects.ts

@@ -71,7 +71,14 @@ export async function loadWorkspacePlugins(
   const setBranch = (facts: BranchFacts): void => {
     if (facts.scope !== undefined && !isCacheScope(facts.scope))
       throw new UserError(`setBranch: ${cacheScopeError('scope')}`)
-    if (facts.scope !== undefined) branch.scope = facts.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) =>

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

@@ -553,10 +553,13 @@ export function localBranchScope(
   return branchCacheScope(repo, name)
 }
 
-/** `owner/repo` from a remote URL (its last two path segments); undefined for a local path. */
+/**
+ * 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(-2).join('/')
+  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. */
@@ -586,12 +589,13 @@ function gitConfigSections(workspaceRoot: string): Map<string, Map<string, strin
 
 /**
  * The run's cache scope (owner, 2026-10-17): `VX_CACHE_SCOPE` (empty: none),
- * else a plugin's (`setBranch`, `github()` on Actions), else, with a cache
- * plugin to share it, the branch's from git. Undefined: the default keys.
+ * 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 | undefined,
+  pluginScope: string | null | undefined,
   hasRemote: boolean,
   baseBranch: string | undefined,
   env: NodeJS.ProcessEnv = process.env,
@@ -602,6 +606,7 @@ export function resolveCacheScope(
     if (!isCacheScope(named)) throw cacheScopeEnvError()
     return named
   }
+  if (pluginScope === null) return undefined
   return pluginScope ?? (hasRemote ? localBranchScope(workspaceRoot, baseBranch, env) : undefined)
 }
 

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
@@ -871,7 +876,7 @@ async function runOnBus(
           nestedDirsByProject,
           gitFilesCache,
           hashCache,
-          concurrency,
+          concurrency: options.downloadConcurrency ?? networkConcurrency(),
           remoteRead: policy.remoteRead,
           remoteWrite: policy.remoteWrite,
         }),
@@ -1088,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 } : {}),
@@ -1349,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.
@@ -1488,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/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. */
@@ -392,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)
@@ -492,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))
@@ -515,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
           ? {