@vzn/vx 0.0.642 → 0.0.643

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.642",
+  "version": "0.0.643",
   "description": "Task orchestration you own: correct, sandboxed, extensible, with a content-addressed build cache.",
   "type": "module",
   "exports": {
@@ -21,10 +21,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.642",
-    "@vzn/vx-linux-arm64": "0.0.642",
-    "@vzn/vx-darwin-x64": "0.0.642",
-    "@vzn/vx-darwin-arm64": "0.0.642"
+    "@vzn/vx-linux-x64": "0.0.643",
+    "@vzn/vx-linux-arm64": "0.0.643",
+    "@vzn/vx-darwin-x64": "0.0.643",
+    "@vzn/vx-darwin-arm64": "0.0.643"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/cache.ts

@@ -812,12 +812,6 @@ export interface RemoteTraffic {
   /** Uploads queued or running across every remote. */
   inFlight: number
   readonly keys: Map<string, RemoteKeyTraffic>
-  /**
-   * A key a remote is asked under that is not the task's own (a scope's)
-   * → the task key it answers for: its traffic counts under the task key,
-   * which the footer and the run's rows look up.
-   */
-  readonly aliases: Map<string, string>
 }
 
 export class Cache implements CacheLayer {
@@ -830,7 +824,7 @@ export class Cache implements CacheLayer {
    */
   readonly uploads: UploadTally = { count: 0, bytes: 0, ms: 0, failed: 0 }
   /** The same remotes' traffic per key, filled by the same `LayeredCache`. */
-  readonly traffic: RemoteTraffic = { inFlight: 0, keys: new Map(), aliases: new Map() }
+  readonly traffic: RemoteTraffic = { inFlight: 0, keys: new Map() }
 
   private readonly db: Database
   private readonly insertEntry: ReturnType<Database['prepare']>

package/src/cache/index.ts

@@ -79,9 +79,14 @@ export {
   type GitEnumeration,
   type BlobSizeMemo,
 } from './git-inputs.js'
-export { LayeredCache, type RemoteCacheLayer, type RemoteOpenContext } from './layered-cache.js'
+export {
+  LayeredCache,
+  type RemoteCacheLayer,
+  type RemoteKey,
+  type RemoteOpenContext,
+} from './layered-cache.js'
 export type { ResolvedRemote } from './remote-lane.js'
-export { ScopedCache } from './scoped-cache.js'
+export { BranchScope } from './scoped-cache.js'
 export {
   absentPluginCache,
   pluginCache,

package/src/cache/layer.ts

@@ -576,6 +576,8 @@ export interface CacheLayer {
    * `hasRemote`.
    */
   probeBeforeUpload?(hashes: Promise<readonly string[]>): void
+  /** `taskId`'s key is `hash`: a scoped run picks each remote key by its task (`BranchScope`). */
+  noteKey?(taskId: string, hash: string): void
   /**
    * Resolve once every background write-through upload settles. The
    * orchestrator awaits it before `close()` — an upload reading layer state

package/src/cache/layered-cache.ts

@@ -36,6 +36,7 @@ import type {
 } from './cache.js'
 import type { OutputDirRow } from './cache.js'
 import { RemoteLane, type ResolvedRemote } from './remote-lane.js'
+import type { BranchScope } from './scoped-cache.js'
 import type { PluginSecrets } from '../util/index.js'
 
 const STOPPED: unique symbol = Symbol('stopped')
@@ -75,6 +76,16 @@ export interface RemoteOpenContext extends PluginSecrets {
   warn(message: string): void
 }
 
+/**
+ * Where a remote call's key lives: `scope` names the branch scope a scoped
+ * key was derived in (`scopedKey`), absent for a task's own key. The key
+ * alone is enough; a backend that keeps one store per scope may use it to
+ * go straight to that store. turboCache(), nxCache() and vx-reapi ignore it.
+ */
+export interface RemoteKey {
+  readonly scope?: string
+}
+
 /**
  * What a remote cache layer must provide — THE plugin seam for remote
  * caching. Core ships no wire client; a plugin's `cache` hook returns one
@@ -112,16 +123,16 @@ export interface RemoteCacheLayer {
    */
   open?(ctx: RemoteOpenContext): Promise<void>
   /** Existence probe: `--dry` and `--force` ask it per key when the remote cannot batch. */
-  has(hash: string): Promise<boolean>
+  has(hash: string, at?: RemoteKey): Promise<boolean>
   /**
    * Optional batch existence probe: given N hashes, return the subset stored
    * remotely in ONE round-trip. Its presence says the wire can batch: a run
    * asks it once for its keys, `--dry` before its per-key answers, and
    * `--force` in the background to skip uploads of held keys. Without it a
    * run GETs each key directly (no `has`). Never throws for control flow:
-   * `null` means "no batch info; use per-hash".
+   * `null` means "no batch info; use per-hash". `at[i]` is `hashes[i]`'s.
    */
-  hasMany?(hashes: readonly string[]): Promise<Set<string> | null>
+  hasMany?(hashes: readonly string[], at?: readonly RemoteKey[]): Promise<Set<string> | null>
   /**
    * Fetch an artifact; `null` = miss. `body` is read once, by core,
    * straight into the local cache — an HTTP wire returns its `fetch`
@@ -131,7 +142,10 @@ export interface RemoteCacheLayer {
    * nothing and the read is a miss, so a layer can check bytes as they pass
    * (a digest, a signature) and refuse at the end.
    */
-  get(hash: string): Promise<{ body: Blob | Response; durationMs: number | undefined } | null>
+  get(
+    hash: string,
+    at?: RemoteKey,
+  ): Promise<{ body: Blob | Response; durationMs: number | undefined } | null>
   /**
    * Store an artifact (fire-and-forget from LayeredCache's perspective).
    * `body` is file-backed (`Bun.file`) when the local store holds the
@@ -140,7 +154,7 @@ export interface RemoteCacheLayer {
    * key the remote holds keeps the stored bytes. Core never asks `has`
    * first; a wire that would overwrite checks inside.
    */
-  put(hash: string, body: Blob, meta: { durationMs: number }): Promise<void>
+  put(hash: string, body: Blob, meta: { durationMs: number } & RemoteKey): Promise<void>
 }
 
 export class LayeredCache implements CacheLayer {
@@ -176,8 +190,16 @@ export class LayeredCache implements CacheLayer {
   constructor(
     readonly local: Cache,
     remotes: readonly ResolvedRemote[],
+    /** The run's branch scope: it picks each remote key; the local store never sees it. */
+    private readonly branch?: BranchScope,
   ) {
-    this.lanes = remotes.map((r) => new RemoteLane(r, local.traffic))
+    this.lanes = remotes.map(
+      (r) => new RemoteLane(r, local.traffic, branch?.remote(r.remote) ?? r.remote),
+    )
+  }
+
+  noteKey(taskId: string, hash: string): void {
+    this.branch?.noteKey(taskId, hash)
   }
 
   // Asked, not kept: a remote whose `open` failed leaves the run after this is built.

package/src/cache/plugin-cache.ts

@@ -8,6 +8,7 @@
 
 import type { Database } from 'bun:sqlite'
 import { xxh3hex } from '../util/index.js'
+import type { RemoteKey } from './layered-cache.js'
 import type { CachePolicy } from './policy.js'
 import type { ResolvedRemote } from './remote-lane.js'
 import { scopedKey } from './scoped-cache.js'
@@ -85,13 +86,17 @@ async function capped(body: unknown, max = PLUGIN_ENTRY_MAX_BYTES): Promise<Uint
 }
 
 /**
- * `plugin`'s view of the cache. A scoped run reads the default key, then
- * the scope's, and writes only the scope's, as tasks do (`ScopedCache`).
+ * `plugin`'s view of the cache. The local store never knows a scope
+ * (owner, 2026-10-17): it keeps every entry under its name's key. A scoped
+ * run reads a remote under the default key, then the scope's, and writes
+ * a remote only under the scope's.
  */
 export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache {
   const { db, policy, scope } = host
   const readers = host.remotes.filter((r) => r.read)
   const writers = host.remotes.filter((r) => r.write)
+  const at: RemoteKey = scope === undefined ? {} : { scope }
+  const atOf = (key: string, name: string): RemoteKey => (key === entryKey(plugin, name) ? {} : at)
   const reads = (name: string): string[] => {
     const key = entryKey(plugin, name)
     return scope === undefined ? [key] : [key, scopedKey(scope, key)]
@@ -139,19 +144,18 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
 
   return {
     async get(name) {
+      const local = entryKey(plugin, name)
+      const hit = localGet(local)
+      if (hit !== null) return hit
       const keys = reads(name)
-      for (const key of keys) {
-        const hit = localGet(key)
-        if (hit !== null) return hit
-      }
       for (const { remote } of readers) {
         for (const key of keys) {
           try {
-            const got = await remote.get(key)
+            const got = await remote.get(key, atOf(key, name))
             if (got === null) continue
             const bytes = await capped(got.body)
             if (bytes === null) continue
-            if (policy.localWrite) localPut(key, bytes)
+            if (policy.localWrite) localPut(local, bytes)
             return bytes
           } catch {
             // a failing remote is a miss there
@@ -164,10 +168,10 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
     async put(name, bytes) {
       if (bytes.byteLength === 0 || bytes.byteLength > PLUGIN_ENTRY_MAX_BYTES) return
       const key = writeKey(name)
-      if (policy.localWrite) localPut(key, bytes)
+      if (policy.localWrite) localPut(entryKey(plugin, name), bytes)
       for (const { remote } of writers) {
         try {
-          await remote.put(key, new Blob([bytes]), { durationMs: 0 })
+          await remote.put(key, new Blob([bytes]), { durationMs: 0, ...at })
         } catch {
           // the other layers still keep it
         }
@@ -175,13 +179,13 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
     },
 
     async has(name) {
+      if (localHas([entryKey(plugin, name)]).size > 0) return true
       const keys = reads(name)
-      if (localHas(keys).size > 0) return true
       let answered = policy.localRead
       for (const { remote } of readers) {
         for (const key of keys) {
           try {
-            if (await remote.has(key)) return true
+            if (await remote.has(key, atOf(key, name))) return true
             answered = true
           } catch {
             // no answer from this remote
@@ -196,13 +200,16 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       for (const name of names) for (const key of reads(name)) byKey.set(key, name)
       const keys = [...byKey.keys()]
       const found = new Set<string>()
-      for (const key of localHas(keys)) found.add(byKey.get(key)!)
+      for (const key of localHas(names.map((n) => entryKey(plugin, n)))) found.add(byKey.get(key)!)
       for (const { remote } of readers) {
         const ask = keys.filter((k) => !found.has(byKey.get(k)!))
         if (ask.length === 0) break
         if (remote.hasMany === undefined) return null
         try {
-          const got: unknown = await remote.hasMany(ask)
+          const got: unknown = await remote.hasMany(
+            ask,
+            ask.map((k) => atOf(k, byKey.get(k)!)),
+          )
           if (!(got instanceof Set)) return null
           for (const key of got) if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
         } catch {
@@ -214,9 +221,9 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
 
     async getRun(name) {
       for (const { remote } of readers) {
-        for (const key of runReadKeys(name, scope)) {
+        for (const [i, key] of runReadKeys(name, scope).entries()) {
           try {
-            const got = await remote.get(key)
+            const got = await remote.get(key, i === 0 ? {} : at)
             if (got === null) continue
             const bytes = await capped(got.body, Infinity)
             if (bytes !== null) return bytes

package/src/cache/remote-lane.ts

@@ -133,9 +133,11 @@ export class RemoteLane {
   constructor(
     resolved: ResolvedRemote,
     private readonly traffic: RemoteTraffic,
+    /** The wire as this run asks it: a branch scope's view of `resolved.remote`. */
+    remote: RemoteCacheLayer = resolved.remote,
   ) {
     this.resolved = resolved
-    this.remote = resolved.remote
+    this.remote = remote
     this.onError = resolved.onError
     this.endpoint = printableEndpoint(resolved.remote.endpoint)
   }
@@ -257,7 +259,6 @@ export class RemoteLane {
     tally: { count: number; bytes: number; ms: number; failed: number },
   ): void {
     const key = this.trafficOf(hash)
-    const counted = this.traffic.aliases.get(hash) ?? hash
     key.uploading++
     this.traffic.inFlight++
     this.uploadQueue.push(async () => {
@@ -284,7 +285,7 @@ export class RemoteLane {
         // Nothing sent and nothing failed (the remote held it, or the run
         // stopped first): no traffic, so the footer counts no upload.
         if (key.uploading === 0 && !key.landed && key.failures.length === 0)
-          this.traffic.keys.delete(counted)
+          this.traffic.keys.delete(hash)
       }
     })
     this.pump()
@@ -359,11 +360,10 @@ export class RemoteLane {
   }
 
   private trafficOf(hash: string): RemoteKeyTraffic {
-    const counted = this.traffic.aliases.get(hash) ?? hash
-    let key = this.traffic.keys.get(counted)
+    let key = this.traffic.keys.get(hash)
     if (key === undefined) {
       key = { uploading: 0, landed: false, failures: [] }
-      this.traffic.keys.set(counted, key)
+      this.traffic.keys.set(hash, key)
     }
     return key
   }

package/src/cache/run-store.ts

@@ -44,7 +44,10 @@ export async function putRunEntry(
   for (const { remote, write } of remotes) {
     if (!write) continue
     try {
-      await remote.put(key, new Blob([bytes]), { durationMs: 0 })
+      await remote.put(key, new Blob([bytes]), {
+        durationMs: 0,
+        ...(scope === undefined ? {} : { scope }),
+      })
       kept = true
     } catch {
       // the other remotes still keep it

package/src/cache/scoped-cache.ts

@@ -1,20 +1,12 @@
-// The run's `cache.scope` over every layer at once (owner, 2026-10-14): a
-// scoped run reads the default key, then the scope's, and writes only the
-// scope's, in the local store and every remote alike. Below this wrapper no
-// layer knows a scope exists: the scope's key is a key like any other.
+// A branch's cache scope (owner, 2026-10-17): the local store never knows
+// one, so every branch shares one local pool under the task keys. Scopes
+// decide only which remote entry a task asks for: a task the branch changed
+// reads the scope's key, every other task the default key, and a scoped run
+// writes every remote under the scope's key. An artifact is packed under its
+// task key wherever it is stored, so a remote entry ingests under that key.
 
 import { xxh3hex } from '../util/index.js'
-import type {
-  CacheEntry,
-  CacheGetContext,
-  CacheLayer,
-  DeclaredOutputs,
-  IngestMeta,
-  InvocationRecord,
-  OutputDirRow,
-  RunRecord,
-  SaveArgs,
-} from './layer.js'
+import type { RemoteCacheLayer, RemoteKey } from './layered-cache.js'
 
 /** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
 export function scopedKey(scope: string, hash: string): string {
@@ -22,231 +14,74 @@ export function scopedKey(scope: string, hash: string): string {
 }
 
 /**
- * A layer as a scoped run sees it. Callers speak task keys; each answer is
- * remembered under the key that served it (the default key on a default hit,
- * the scope's on a scope hit or a save), so the restore, the output index and
- * the run's history all reach the entry that answered. An artifact records
- * the key it was packed under and ingest refuses another, so a derived-key
- * collision degrades to a miss. A default artifact a remote ingest refuses is
- * a miss there, and the scope's key is asked next (Security F6).
+ * Which remote key each task asks for, in a run with a scope. The routes
+ * come from the branch's diff, which only a remote call awaits: a run the
+ * local cache answers never waits on git.
  */
-export class ScopedCache implements CacheLayer {
-  readonly local?: CacheLayer['local']
-  readonly hasRemote?: boolean
-  readonly drainUploads?: () => Promise<void>
-  readonly stopUploads?: () => void
-  readonly remoteHasMany?: (hashes: readonly string[]) => Promise<Set<string> | null>
-  /** A scoped run saves under the scope's key, so that is the key asked. */
-  readonly probeBeforeUpload?: (hashes: Promise<readonly string[]>) => void
-  readonly getMany?: (
-    hashes: readonly string[],
-    ctx?: (hash: string) => CacheGetContext,
-  ) => Promise<Map<string, CacheEntry>>
-  /** Task key → the key that answers for it this run. */
-  private readonly served = new Map<string, string>()
-
-  constructor(
-    private readonly inner: CacheLayer,
-    private readonly scope: string,
-  ) {
-    if (inner.local !== undefined) this.local = inner.local
-    if (inner.hasRemote !== undefined) this.hasRemote = inner.hasRemote
-    if (inner.drainUploads !== undefined) this.drainUploads = () => inner.drainUploads!()
-    if (inner.stopUploads !== undefined) this.stopUploads = () => inner.stopUploads!()
-    if (inner.remoteHasMany !== undefined) this.remoteHasMany = (h) => this.scopedHasMany(h)
-    if (inner.probeBeforeUpload !== undefined)
-      this.probeBeforeUpload = (h) =>
-        inner.probeBeforeUpload!(h.then((keys) => keys.map((k) => this.own(k))))
-    if (inner.getMany !== undefined) this.getMany = (h, ctx) => this.scopedGetMany(h, ctx)
-  }
-
-  private own(hash: string): string {
-    const key = scopedKey(this.scope, hash)
-    this.local?.traffic.aliases.set(key, hash)
-    return key
-  }
-
-  private keyOf(hash: string): string {
-    return this.served.get(hash) ?? hash
-  }
-
-  /** A batch keyed by served keys, keyed back by task key. */
-  private batch<T>(
-    hashes: readonly string[],
-    read: (keys: string[]) => Map<string, T>,
-  ): Map<string, T> {
-    const keys = hashes.map((h) => this.keyOf(h))
-    const found = read(keys)
-    const out = new Map<string, T>()
-    for (let i = 0; i < hashes.length; i++) {
-      const v = found.get(keys[i]!)
-      if (v !== undefined) out.set(hashes[i]!, v)
+export class BranchScope {
+  /** Finds the tasks that read the scope, at the first remote call; null: every task does. */
+  private route: (() => Promise<ReadonlySet<string>>) | null = null
+  private routes: Promise<ReadonlySet<string>> | null = null
+  /** Task key → its task. */
+  private readonly taskOf = new Map<string, string>()
+
+  constructor(readonly scope: string) {}
+
+  /** Only the tasks `ids` finds read the scope; set before any remote call. */
+  routeTasks(ids: () => Promise<ReadonlySet<string>>): void {
+    this.route = ids
+  }
+
+  noteKey(taskId: string, hash: string): void {
+    this.taskOf.set(hash, taskId)
+  }
+
+  /** The remote key `hash` is read under, and the scope it is read in (none: the default key). */
+  private async readKey(hash: string): Promise<{ key: string; at: RemoteKey }> {
+    const id = this.taskOf.get(hash)
+    if (this.route !== null) this.routes ??= this.route()
+    const tasks = this.routes === null ? null : await this.routes
+    return tasks !== null && id !== undefined && !tasks.has(id)
+      ? { key: hash, at: {} }
+      : { key: scopedKey(this.scope, hash), at: { scope: this.scope } }
+  }
+
+  /**
+   * `inner` as this run asks it: each task key under its route's key; every
+   * write under the scope's. Each call also names its scope, for a backend
+   * that keeps one store per scope; no wire vx ships sends it.
+   */
+  remote(inner: RemoteCacheLayer): RemoteCacheLayer {
+    const read = (h: string) => this.readKey(h)
+    const at: RemoteKey = { scope: this.scope }
+    const hasMany = inner.hasMany
+    return {
+      ...(inner.endpoint !== undefined ? { endpoint: inner.endpoint } : {}),
+      ...(inner.open !== undefined ? { open: (ctx) => inner.open!(ctx) } : {}),
+      has: async (h) => {
+        const r = await read(h)
+        return inner.has(r.key, r.at)
+      },
+      ...(hasMany !== undefined
+        ? {
+            hasMany: async (hashes) => {
+              const reads = await Promise.all(hashes.map(read))
+              const keys = reads.map((r) => r.key)
+              const found = await hasMany.call(
+                inner,
+                keys,
+                reads.map((r) => r.at),
+              )
+              if (!(found instanceof Set)) return found
+              return new Set(hashes.filter((_, i) => found.has(keys[i]!)))
+            },
+          }
+        : {}),
+      get: async (h) => {
+        const r = await read(h)
+        return inner.get(r.key, r.at)
+      },
+      put: (h, body, meta) => inner.put(scopedKey(this.scope, h), body, { ...meta, ...at }),
     }
-    return out
-  }
-
-  /** A task key the store holds under the default key or the scope's. */
-  async localHasMany(hashes: readonly string[]): Promise<Set<string>> {
-    const held = await this.inner.localHasMany?.([...hashes, ...hashes.map((h) => this.own(h))])
-    if (held === undefined) return new Set()
-    return new Set(hashes.filter((h) => held.has(h) || held.has(this.own(h))))
-  }
-
-  private async scopedHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
-    const scoped = hashes.map((h) => this.own(h))
-    const [plain, own] = await Promise.all([
-      this.inner.remoteHasMany!(hashes),
-      this.inner.remoteHasMany!(scoped),
-    ])
-    if (plain == null || own == null) return null
-    const found = new Set(plain)
-    const scopeOnly: string[] = []
-    for (let i = 0; i < hashes.length; i++) {
-      if (plain.has(hashes[i]!) || !own.has(scoped[i]!)) continue
-      found.add(hashes[i]!)
-      scopeOnly.push(hashes[i]!)
-    }
-    // Their default key is known absent: its GET is skipped.
-    this.inner.markRemoteAbsent?.(scopeOnly)
-    return found
-  }
-
-  markRemoteAbsent(hashes: Iterable<string>): void {
-    const all: string[] = []
-    for (const h of hashes) all.push(h, this.own(h))
-    this.inner.markRemoteAbsent?.(all)
-  }
-
-  key(input: Parameters<CacheLayer['key']>[0]): Promise<string> {
-    return this.inner.key(input)
-  }
-
-  async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
-    // The scope's key first when only it is local: the default key's
-    // remote GET would cost a round-trip for the same inputs.
-    const own = this.own(hash)
-    const keys = (await this.inner.localHasMany?.([hash, own]))?.has(own)
-      ? [own, hash]
-      : [hash, own]
-    for (const key of keys) {
-      const entry = await this.inner.get(key, ctx)
-      if (entry === null) continue
-      this.served.set(hash, key)
-      return key === hash ? entry : { ...entry, hash }
-    }
-    return null
-  }
-
-  private async scopedGetMany(
-    hashes: readonly string[],
-    ctx?: (hash: string) => CacheGetContext,
-  ): Promise<Map<string, CacheEntry>> {
-    const out = await this.inner.getMany!(hashes, ctx)
-    for (const h of out.keys()) this.served.set(h, h)
-    const rest = hashes.filter((h) => !out.has(h))
-    if (rest.length === 0) return out
-    const byOwn = new Map(rest.map((h) => [this.own(h), h]))
-    const scoped = await this.inner.getMany!(
-      [...byOwn.keys()],
-      ctx === undefined ? undefined : (key) => ctx(byOwn.get(key)!),
-    )
-    for (const [key, entry] of scoped) {
-      const hash = byOwn.get(key)!
-      this.served.set(hash, key)
-      out.set(hash, { ...entry, hash })
-    }
-    return out
-  }
-
-  async has(hash: string): Promise<'local' | 'remote' | null> {
-    return (await this.inner.has(hash)) ?? (await this.inner.has(this.own(hash)))
-  }
-
-  async prefetch(hash: string, ctx?: CacheGetContext): Promise<boolean> {
-    return (await this.inner.prefetch(hash, ctx)) || this.inner.prefetch(this.own(hash), ctx)
-  }
-
-  loadOutputFilesBatch(hashes: readonly string[]): ReturnType<CacheLayer['loadOutputFilesBatch']> {
-    return this.batch(hashes, (keys) => this.inner.loadOutputFilesBatch(keys))
-  }
-
-  isOutputsCurrent(
-    ...args: Parameters<CacheLayer['isOutputsCurrent']>
-  ): ReturnType<CacheLayer['isOutputsCurrent']> {
-    return this.inner.isOutputsCurrent(...args)
-  }
-
-  async recordOutputDirs(
-    hash: string,
-    projectDir: string,
-    prefixes: readonly string[],
-    holds?: (files: readonly string[]) => boolean,
-  ): Promise<void> {
-    await this.inner.recordOutputDirs?.(this.keyOf(hash), projectDir, prefixes, holds)
-  }
-
-  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
-    this.inner.recordOutputStamps?.(this.keyOf(hash), projectDir, workspaceRoot)
-  }
-
-  loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
-    return this.batch(hashes, (keys) => this.inner.loadOutputDirsBatch?.(keys) ?? new Map())
-  }
-
-  async outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): Promise<boolean> {
-    return (await this.inner.outputDirsCurrent?.(projectDir, rows)) ?? false
-  }
-
-  restoreOutputs(
-    hash: string,
-    projectDir: string,
-    workspaceRoot?: string,
-    outputs?: DeclaredOutputs,
-  ): Promise<void> {
-    return this.inner.restoreOutputs(this.keyOf(hash), projectDir, workspaceRoot, outputs)
-  }
-
-  save(args: SaveArgs): Promise<void> {
-    const key = this.own(args.hash)
-    this.served.set(args.hash, key)
-    return this.inner.save({ ...args, hash: key })
-  }
-
-  ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void> {
-    const key = this.own(hash)
-    this.served.set(hash, key)
-    return this.inner.ingest(key, body, meta)
-  }
-
-  /** History names the key that answered, so `vx why` reads that entry's components. */
-  recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
-    this.inner.recordRunBundle({
-      ...bundle,
-      runs: bundle.runs.map((r) => (r.hash === undefined ? r : { ...r, hash: this.keyOf(r.hash) })),
-    })
-  }
-
-  stats(...args: Parameters<CacheLayer['stats']>): ReturnType<CacheLayer['stats']> {
-    return this.inner.stats(...args)
-  }
-
-  hashFile(filePath: string): Promise<string> {
-    return this.inner.hashFile(filePath)
-  }
-
-  outputsPath(hash: string): string {
-    return this.inner.outputsPath(this.keyOf(hash))
-  }
-
-  artifactSize(hash: string): number | undefined {
-    return this.inner.artifactSize?.(this.keyOf(hash))
-  }
-
-  prune(...args: Parameters<CacheLayer['prune']>): ReturnType<CacheLayer['prune']> {
-    return this.inner.prune(...args)
-  }
-
-  close(): void {
-    this.inner.close()
   }
 }