@vzn/vx 0.0.642 → 0.0.644

package/src/cache/file-hashes.ts

@@ -14,9 +14,6 @@ import { fileIdentity, repoFacts } from './git-inputs.js'
 import { FILE_HASH_RACY_MS, isIndexFull, racyWindowMs } from './layer.js'
 import { isPermissionError, UserError } from '../util/index.js'
 
-const FILE_HASHES_SWEPT_AT = 'file_hashes_swept_at'
-const DAY_MS = 24 * 60 * 60 * 1000
-
 export class FileHashStore {
   private readonly selectFileHash: ReturnType<Database['prepare']>
   private readonly upsertFileHash: ReturnType<Database['prepare']>
@@ -62,22 +59,13 @@ export class FileHashStore {
    * path) keeps its row forever otherwise, and `cache.db` grows with every
    * path ever hashed. A hit does not refresh `seen_at` (a write per file
    * per run), so a file unchanged for the window loses its row too and is
-   * read once more; a dropped row is only a memo miss. The scan costs
-   * 8 ms at 100,000 rows, so it runs once a day, on its own clock in
-   * `schema_meta` (item 1082).
+   * read once more; a dropped row is only a memo miss.
    */
-  pruneOlderThan(cutoff: number, now: number = Date.now()): void {
-    const last = this.db
-      .prepare('SELECT value FROM schema_meta WHERE key = ?')
-      .get(FILE_HASHES_SWEPT_AT) as { value: string } | null
-    if (last !== null && now - Number(last.value) < DAY_MS) return
+  pruneOlderThan(cutoff: number): void {
     this.db.transaction(() => {
       this.db.prepare('DELETE FROM file_hashes WHERE seen_at < ?').run(cutoff)
       this.db.prepare('DELETE FROM blob_sizes WHERE seen_at < ?').run(cutoff)
       this.db.prepare('DELETE FROM blob_verdicts WHERE seen_at < ?').run(cutoff)
-      this.db
-        .prepare('INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)')
-        .run(FILE_HASHES_SWEPT_AT, String(now))
     })()
   }
 

package/src/cache/fold-memo.ts

@@ -43,16 +43,20 @@ export class FoldMemo {
     if (this.write) this.dirty.set(taskId, { probe, key })
   }
 
-  /** Write the folds this run made; rows a run has not rewritten for `cutoff` go. */
-  flush(cutoff: number, now: number = Date.now()): void {
+  /** Write the folds this run made. */
+  flush(now: number = Date.now()): void {
     if (this.dirty.size === 0) return
     const upsert = this.db.prepare(
       'INSERT OR REPLACE INTO fold_memo(task_id, probe, key, seen_at) VALUES (?, ?, ?, ?)',
     )
     this.db.transaction(() => {
       for (const [taskId, r] of this.dirty) upsert.run(taskId, r.probe, r.key, now)
-      this.db.prepare('DELETE FROM fold_memo WHERE seen_at < ?').run(cutoff)
     })()
     this.dirty.clear()
   }
+
+  /** Rows no run has rewritten since `cutoff`. */
+  prune(cutoff: number): void {
+    this.db.prepare('DELETE FROM fold_memo WHERE seen_at < ?').run(cutoff)
+  }
 }

package/src/cache/index.ts

@@ -8,6 +8,8 @@ export {
   applyCacheFlags,
   ArtifactVanishedError,
   Cache,
+  DEFAULT_STORE,
+  type StoreOptions,
   type CacheFlags,
   type CacheEntry,
   type CacheKeyInput,
@@ -79,9 +81,15 @@ 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 { networkConcurrency } from './remote-lane.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/key-fold.ts

@@ -117,7 +117,10 @@ import type { CacheKeyInput } from './layer.js'
 // v46: vx's names are reserved only at the project root; a v45 artifact
 // left out a build's own `dist/.git/**`, `dist/.vx/**` and nested
 // `vx.lock.json` (Growth's parity, 2026-10-17).
-export const CACHE_VERSION = 'vx-cache-v46'
+// v47: the local store keeps plain files (`cache.store`).
+// v48: a task glob is standard again (M, 2026-10-18): `app/[id]/page.js` is
+// a class, and a v47 entry under its unchanged key holds the literal route.
+export const CACHE_VERSION = 'vx-cache-v48'
 
 /**
  * The digest a key folds for an input gone between its enumeration and its

package/src/cache/layer.ts

@@ -493,8 +493,8 @@ export class CorruptArtifactError extends Error {
 
 /**
  * `restoreOutputs` found no artifact where the probe found one: it was
- * removed in between — a `vx cache clean` in another shell, or the
- * `cacheRetention` of another workspace sharing the cache directory. The
+ * removed in between — a `vx cache clean` in another shell, or one for
+ * another workspace sharing the cache directory. The
  * bytes are not wrong, they are gone, so the entry is a MISS and the task
  * runs (execute-task.ts); nothing about the cache needs throwing away.
  * Also thrown, with its `reason`, for an artifact whose bytes ARE wrong
@@ -510,8 +510,7 @@ export class ArtifactVanishedError extends Error {
     cause?: unknown,
   ) {
     super(
-      reason ??
-        `its cache artifact ${hash} vanished before the restore (a prune or another run's retention)`,
+      reason ?? `its cache artifact ${hash} vanished before the restore (a vx cache clean)`,
       cause === undefined ? undefined : { cause },
     )
     this.name = 'ArtifactVanishedError'
@@ -576,6 +575,14 @@ export interface CacheLayer {
    * `hasRemote`.
    */
   probeBeforeUpload?(hashes: Promise<readonly string[]>): void
+  /**
+   * The run's batch probe starts when `started` settles: until then a pull
+   * waits, so a lookup that lands first does not GET a key the probe is
+   * about to call absent. Only meaningful with `hasRemote`.
+   */
+  probeFirst?(started: Promise<void>): 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 {
@@ -161,6 +175,17 @@ export class LayeredCache implements CacheLayer {
    */
   private readonly inflight = new Map<string, Promise<boolean>>()
 
+  /**
+   * Hashes a batch probe is asking about, each resolving whether a pull may
+   * still find it (false: no remote holds it). A `get` that lands while the
+   * probe is out waits for its answer instead of spending a GET on a key
+   * the probe is about to call absent.
+   */
+  private readonly probing = new Map<string, Promise<boolean>>()
+
+  /** Settles once the run's batch probe has started (`probeFirst`); a pull waits on it. */
+  private probeStarted: Promise<void> | null = null
+
   /**
    * Hashes whose local artifact was materialized FROM a remote this run
    * (by `prefetch` or `get`'s read-through). A later `get` finds them as
@@ -176,8 +201,18 @@ 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,
+    uploadConcurrency?: number,
   ) {
-    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, uploadConcurrency),
+    )
+  }
+
+  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.
@@ -216,6 +251,27 @@ export class LayeredCache implements CacheLayer {
    */
   async remoteHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
     if (this.readable.length === 0) return null
+    const answer = this.probeMany(hashes)
+    const waiting = hashes.filter((h) => !this.inflight.has(h) && !this.probing.has(h))
+    for (const h of waiting) {
+      this.probing.set(
+        h,
+        answer.then(
+          (found) => {
+            this.probing.delete(h)
+            return found === null || found.has(h)
+          },
+          () => {
+            this.probing.delete(h)
+            return true
+          },
+        ),
+      )
+    }
+    return answer
+  }
+
+  private async probeMany(hashes: readonly string[]): Promise<Set<string> | null> {
     let out: Set<string> | null = new Set()
     for (const lane of this.readable) {
       const found = await lane.hasMany(hashes)
@@ -239,6 +295,17 @@ export class LayeredCache implements CacheLayer {
     }
   }
 
+  probeFirst(started: Promise<void>): void {
+    const gate = started.then(
+      () => {},
+      () => {},
+    )
+    this.probeStarted = gate
+    void gate.then(() => {
+      if (this.probeStarted === gate) this.probeStarted = null
+    })
+  }
+
   probeBeforeUpload(hashes: Promise<readonly string[]>): void {
     for (const lane of this.lanes) lane.probeBeforeUpload(hashes)
   }
@@ -309,6 +376,11 @@ export class LayeredCache implements CacheLayer {
   private pullFromRemote(hash: string, ctx?: CacheGetContext): Promise<boolean> {
     const existing = this.inflight.get(hash)
     if (existing) return existing
+    const probed = this.probing.get(hash)
+    if (probed !== undefined)
+      return probed.then((found) => (found ? this.pullFromRemote(hash, ctx) : false))
+    if (this.probeStarted !== null)
+      return this.probeStarted.then(() => this.pullFromRemote(hash, ctx))
     const p = this.doPullFromRemote(hash, ctx)
     this.inflight.set(hash, p)
     return p
@@ -435,8 +507,10 @@ export class LayeredCache implements CacheLayer {
         return
       }
     }
-    const body = (): { body: Blob; release?: () => Promise<void> } =>
-      packed !== undefined ? { body: new Blob([packed]) } : this.local.pinArtifact(hash)
+    const body = (): Promise<{ body: Blob; release?: () => Promise<void> }> =>
+      packed !== undefined
+        ? Promise.resolve({ body: new Blob([packed]) })
+        : this.local.pinArtifact(hash)
     for (const lane of writable) lane.upload(hash, durationMs, body, this.local.uploads)
   }
 

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'
@@ -18,17 +19,21 @@ export const PLUGIN_ENTRY_MAX_BYTES = 1024 * 1024
 
 /** What a plugin's `ctx.cache` offers. Keys are the plugin's own names. */
 export interface PluginCache {
-  /** The bytes stored under `key`, from the first layer holding them; null when none does. */
-  get(key: string): Promise<Uint8Array | null>
+  /**
+   * The bytes stored under `key`, from the first layer holding them; null
+   * when none does. On a scoped run a remote is asked for the branch's
+   * entry, or with `scoped` false the base branch's: one request either way.
+   */
+  get(key: string, scoped?: boolean): Promise<Uint8Array | null>
   /** Store `bytes` under `key` in every layer the policy writes, where it is not already; empty bytes store nothing. */
   put(key: string, bytes: Uint8Array): Promise<void>
   /** Whether some layer holds `key`; null when no layer could answer. */
-  has(key: string): Promise<boolean | null>
+  has(key: string, scoped?: boolean): Promise<boolean | null>
   /**
    * The subset of `keys` some layer holds, in one probe per layer; null
    * when a readable remote has no batch probe: ask `get` one at a time.
    */
-  hasMany(keys: readonly string[]): Promise<Set<string> | null>
+  hasMany(keys: readonly string[], scoped?: boolean): Promise<Set<string> | null>
   /**
    * What core kept of a run under `name` (a `log` or `outputs` name its
    * `RunReport` hands `teardown`), from the first readable remote holding
@@ -85,16 +90,21 @@ 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 writes a remote only under the scope's key, and reads one key: the
+ * scope's, or with `scoped` false the default (M, 2026-10-18: no request
+ * twice).
  */
 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 reads = (name: string): string[] => {
+  const at: RemoteKey = scope === undefined ? {} : { scope }
+  const atOf = (key: string, name: string): RemoteKey => (key === entryKey(plugin, name) ? {} : at)
+  const readKey = (name: string, scoped: boolean): string => {
     const key = entryKey(plugin, name)
-    return scope === undefined ? [key] : [key, scopedKey(scope, key)]
+    return scope === undefined || !scoped ? key : scopedKey(scope, key)
   }
   const writeKey = (name: string): string => {
     const key = entryKey(plugin, name)
@@ -138,24 +148,21 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
   }
 
   return {
-    async get(name) {
-      const keys = reads(name)
-      for (const key of keys) {
-        const hit = localGet(key)
-        if (hit !== null) return hit
-      }
+    async get(name, scoped = true) {
+      const local = entryKey(plugin, name)
+      const hit = localGet(local)
+      if (hit !== null) return hit
+      const key = readKey(name, scoped)
       for (const { remote } of readers) {
-        for (const key of keys) {
-          try {
-            const got = await remote.get(key)
-            if (got === null) continue
-            const bytes = await capped(got.body)
-            if (bytes === null) continue
-            if (policy.localWrite) localPut(key, bytes)
-            return bytes
-          } catch {
-            // a failing remote is a miss there
-          }
+        try {
+          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(local, bytes)
+          return bytes
+        } catch {
+          // a failing remote is a miss there
         }
       }
       return null
@@ -164,45 +171,46 @@ 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
         }
       }
     },
 
-    async has(name) {
-      const keys = reads(name)
-      if (localHas(keys).size > 0) return true
+    async has(name, scoped = true) {
+      if (localHas([entryKey(plugin, name)]).size > 0) return true
+      const key = readKey(name, scoped)
       let answered = policy.localRead
       for (const { remote } of readers) {
-        for (const key of keys) {
-          try {
-            if (await remote.has(key)) return true
-            answered = true
-          } catch {
-            // no answer from this remote
-          }
+        try {
+          if (await remote.has(key, atOf(key, name))) return true
+          answered = true
+        } catch {
+          // no answer from this remote
         }
       }
       return answered ? false : null
     },
 
-    async hasMany(names) {
+    async hasMany(names, scoped = true) {
       const byKey = new Map<string, string>()
-      for (const name of names) for (const key of reads(name)) byKey.set(key, name)
+      for (const name of names) byKey.set(readKey(name, scoped), 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 +222,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

@@ -4,6 +4,7 @@
 // class with the endpoint named. The order across remotes, the local store
 // and provenance are `LayeredCache`'s; nothing here knows another remote.
 
+import { machineParallelism } from '../util/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
 import type { RemoteCacheLayer } from './layered-cache.js'
 
@@ -20,11 +21,13 @@ export interface ResolvedRemote {
 }
 
 /**
- * Cap on concurrent background PUTs per remote. Keeps a burst of cache
- * misses from opening one socket per task; excess uploads queue and drain
- * FIFO.
+ * Requests at once to a remote, by default: pnpm's network concurrency
+ * (Bun's is a fixed 64). A request waits on the network, not a core, so
+ * the cap follows cores only past 21 of them.
  */
-const UPLOAD_CONCURRENCY = 4
+export function networkConcurrency(): number {
+  return Math.min(96, Math.max(machineParallelism() * 3, 64))
+}
 
 /** The seam call a failure happened in, as the warning names it. */
 export type RemoteOp = 'probe' | 'download' | 'upload'
@@ -133,9 +136,13 @@ 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,
+    /** Background PUTs at once; excess uploads queue and drain FIFO. */
+    private readonly uploadConcurrency: number = networkConcurrency(),
   ) {
     this.resolved = resolved
-    this.remote = resolved.remote
+    this.remote = remote
     this.onError = resolved.onError
     this.endpoint = printableEndpoint(resolved.remote.endpoint)
   }
@@ -253,11 +260,10 @@ export class RemoteLane {
   upload(
     hash: string,
     durationMs: number,
-    body: () => { body: Blob; release?: () => Promise<void> },
+    body: () => Promise<{ body: Blob; release?: () => Promise<void> }>,
     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 () => {
@@ -267,7 +273,7 @@ export class RemoteLane {
         if (!this.read && (await this.holds(hash))) return
         if (this.stopped) return
         const start = performance.now()
-        const got = body()
+        const got = await body()
         release = got.release
         await this.remote.put(hash, got.body, { durationMs })
         tally.count++
@@ -284,7 +290,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,17 +365,16 @@ 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
   }
 
   private pump(): void {
-    while (this.activeUploads < UPLOAD_CONCURRENCY && this.uploadQueue.length > 0) {
+    while (this.activeUploads < this.uploadConcurrency && this.uploadQueue.length > 0) {
       const job = this.uploadQueue.shift()!
       this.activeUploads++
       // Jobs never reject (each wraps its PUT in the never-fail guard).

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