@vzn/vx 0.0.643 → 0.0.645

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,
@@ -80,13 +82,13 @@ export {
   type BlobSizeMemo,
 } from './git-inputs.js'
 export {
+  type ArtifactInfo,
   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 { 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

@@ -5,6 +5,7 @@
 // reference to `Cache` below is a type (the local handle a layer may wrap).
 
 import type { Cache } from './cache.js'
+import type { ArtifactInfo } from './layered-cache.js'
 import { fsClockLag, stampGrainMs } from './fs-clock.js'
 
 export interface CacheKeyInput {
@@ -493,8 +494,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 +511,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'
@@ -551,12 +551,12 @@ export interface CacheLayer {
    */
   readonly hasRemote?: boolean
   /**
-   * Batch existence probe over the remote — the subset of `hashes` stored
-   * remotely, in ONE round-trip, or `null` for "no batch info; use
-   * per-hash". Only meaningful with `hasRemote`; a remote layer that can't
+   * Batch existence probe over the remote — the `hashes` stored remotely
+   * and what the first remote holding each knows of it (`ArtifactInfo`), in
+   * ONE round-trip, or `null` for "no batch info; use per-hash". Only meaningful with `hasRemote`; a remote layer that can't
    * batch omits it and the prefetch pass falls back to per-hash GETs.
    */
-  remoteHasMany?(hashes: readonly string[]): Promise<Set<string> | null>
+  remoteHasMany?(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null>
   /**
    * The subset of `hashes` the local store already holds. The prefetch
    * pass probes the remote only for the rest, so a run the local cache
@@ -576,8 +576,12 @@ 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
+  /**
+   * 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
   /**
    * 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,7 +36,6 @@ 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')
@@ -46,7 +45,11 @@ const STOPPED: unique symbol = Symbol('stopped')
  * fails at once, removes its temp, and releases the connection; the cache
  * then closes under no write.
  */
-function endsOnStop(body: Blob | Response, stopped: Promise<typeof STOPPED>): Blob | Response {
+function endsOnStop(
+  body: Blob | Response,
+  stopped: Promise<typeof STOPPED>,
+  onChunk: (bytes: number) => void = () => {},
+): Blob | Response {
   if (body instanceof Blob || body.body === null) return body
   const reader = body.body.getReader()
   let stop = false
@@ -61,13 +64,28 @@ function endsOnStop(body: Blob | Response, stopped: Promise<typeof STOPPED>): Bl
       const next = await reader.read()
       if (stop) controller.error(new Error('the run was stopped'))
       else if (next.done) controller.close()
-      else controller.enqueue(next.value)
+      else {
+        onChunk(next.value.byteLength)
+        controller.enqueue(next.value)
+      }
     },
     cancel: (reason) => reader.cancel(reason),
   })
   return new Response(stream, { headers: body.headers })
 }
 
+const judged = (i: ArtifactInfo): i is { size: number; durationMs: number } =>
+  i.size !== undefined && i.durationMs !== undefined
+
+/** How often a task waiting on its download weighs running instead. */
+const JUDGE_EVERY_MS = 25
+
+interface Download {
+  readonly start: number
+  received: number
+  abandon(): void
+}
+
 /** What a remote's `open` is handed: the run's CI verdict and its plugin's keychain. */
 export interface RemoteOpenContext extends PluginSecrets {
   /** The run is on CI: nobody may be asked. */
@@ -77,13 +95,13 @@ export interface RemoteOpenContext extends PluginSecrets {
 }
 
 /**
- * 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.
+ * What a remote knows of an artifact it holds, before it is downloaded:
+ * the body's size in bytes and the producing task's duration, each when
+ * the wire carries it (Turbo's batch query and `HEAD` do).
  */
-export interface RemoteKey {
-  readonly scope?: string
+export interface ArtifactInfo {
+  readonly size?: number
+  readonly durationMs?: number
 }
 
 /**
@@ -122,17 +140,21 @@ export interface RemoteCacheLayer {
    * plugin's keychain and may ask on the terminal.
    */
   open?(ctx: RemoteOpenContext): Promise<void>
-  /** Existence probe: `--dry` and `--force` ask it per key when the remote cannot batch. */
-  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". `at[i]` is `hashes[i]`'s.
+   * Existence probe: what the remote knows of the stored artifact, or null
+   * when it holds none. `--dry` and `--force` ask it per key when the
+   * remote cannot batch.
+   */
+  has(hash: string): Promise<ArtifactInfo | null>
+  /**
+   * Optional batch existence probe: given N hashes, the stored ones and what
+   * the remote knows of each, 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".
    */
-  hasMany?(hashes: readonly string[], at?: readonly RemoteKey[]): Promise<Set<string> | null>
+  hasMany?(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null>
   /**
    * Fetch an artifact; `null` = miss. `body` is read once, by core,
    * straight into the local cache — an HTTP wire returns its `fetch`
@@ -142,10 +164,7 @@ 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,
-    at?: RemoteKey,
-  ): Promise<{ body: Blob | Response; durationMs: number | undefined } | null>
+  get(hash: string): 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
@@ -154,7 +173,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 } & RemoteKey): Promise<void>
+  put(hash: string, body: Blob, meta: { durationMs: number }): Promise<void>
 }
 
 export class LayeredCache implements CacheLayer {
@@ -175,6 +194,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
@@ -185,21 +215,18 @@ export class LayeredCache implements CacheLayer {
    * its download and ingest took.
    */
   private readonly remoteSourced = new Map<string, number>()
+  /** What the batch probe said of each held key: its size and stored duration. */
+  private readonly infos = new Map<string, ArtifactInfo>()
+  /** Bodies being read now, by key: how far along, and how to give one up. */
+  private readonly downloads = new Map<string, Download>()
 
   /** Remotes in declared order: the first readable one holding a hash answers it. */
   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, branch?.remote(r.remote) ?? r.remote),
-    )
-  }
-
-  noteKey(taskId: string, hash: string): void {
-    this.branch?.noteKey(taskId, hash)
+    this.lanes = remotes.map((r) => new RemoteLane(r, local.traffic, uploadConcurrency))
   }
 
   // Asked, not kept: a remote whose `open` failed leaves the run after this is built.
@@ -236,13 +263,37 @@ export class LayeredCache implements CacheLayer {
    * absences either way, so a hash only a sibling holds costs it no GET.
    * Never throws.
    */
-  async remoteHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
+  async remoteHasMany(hashes: readonly string[]): Promise<Map<string, ArtifactInfo> | null> {
     if (this.readable.length === 0) return null
-    let out: Set<string> | null = new Set()
+    const answer = this.probeMany(hashes).then((found) => {
+      if (found !== null) for (const [h, info] of found) this.infos.set(h, info)
+      return found
+    })
+    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<Map<string, ArtifactInfo> | null> {
+    let out: Map<string, ArtifactInfo> | null = new Map()
     for (const lane of this.readable) {
       const found = await lane.hasMany(hashes)
       if (found === null) out = null
-      else if (out !== null) for (const h of found) out.add(h)
+      else if (out !== null) for (const [h, info] of found) if (!out.has(h)) out.set(h, info)
     }
     return out
   }
@@ -261,6 +312,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)
   }
@@ -283,7 +345,7 @@ export class LayeredCache implements CacheLayer {
     // remote walk per key: a settled `false` means no remote had it
     // (no second probe), and a settled/in-flight `true` means the
     // artifact was/will-be ingested locally — re-read below.
-    const ingested = await this.pullFromRemote(hash, ctx)
+    const ingested = await this.awaitOrRun(hash, this.pullFromRemote(hash, ctx))
     if (!ingested) return null
 
     // Read past the local READ gate: `ingest` is deliberately ungated, so
@@ -305,6 +367,39 @@ export class LayeredCache implements CacheLayer {
     return this.asRemote(hash, materialized)
   }
 
+  /**
+   * A pull the task now waits on, given up when the rest of its body would
+   * take longer than running the task (its stored duration, doubled for
+   * the save a run adds): the task then runs here, a miss. Only a key the
+   * batch probe sized and timed is judged, from its own body's pace so far.
+   * The facts are read each tick: the probe can answer after the task asks.
+   */
+  private async awaitOrRun(hash: string, pull: Promise<boolean>): Promise<boolean> {
+    if (this.infos.has(hash) && !judged(this.infos.get(hash)!)) return pull
+    for (;;) {
+      const done = await Promise.race([pull, Bun.sleep(JUDGE_EVERY_MS).then(() => undefined)])
+      if (done !== undefined) return done
+      const info = this.infos.get(hash)
+      if (info === undefined) continue
+      if (!judged(info)) return pull
+      const budget = info.durationMs * 2
+      const dl = this.downloads.get(hash)
+      if (dl === undefined) continue
+      const elapsed = performance.now() - dl.start
+      const left =
+        dl.received === 0
+          ? elapsed > budget
+            ? Infinity
+            : 0
+          : ((info.size - dl.received) * elapsed) / dl.received
+      if (left > budget) {
+        dl.abandon()
+        await pull
+        return false
+      }
+    }
+  }
+
   private asRemote(hash: string, entry: CacheEntry): CacheEntry {
     const fetchMs = this.remoteSourced.get(hash)
     return fetchMs === undefined ? entry : { ...entry, source: 'remote', fetchMs }
@@ -315,7 +410,7 @@ export class LayeredCache implements CacheLayer {
   // a remote cache. Remote errors degrade to a miss (never throw).
   async has(hash: string): Promise<'local' | 'remote' | null> {
     if ((await this.local.has(hash)) === 'local') return 'local'
-    for (const lane of this.readable) if (await lane.has(hash)) return 'remote'
+    for (const lane of this.readable) if ((await lane.has(hash)) !== null) return 'remote'
     return null
   }
 
@@ -331,6 +426,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
@@ -384,10 +484,19 @@ export class LayeredCache implements CacheLayer {
       durationMs: durationOf(remoteBody.durationMs),
       ...(ctx?.outputs !== undefined ? { outputs: ctx.outputs } : {}),
     }
+    let abandon = (): void => {}
+    const abandoned = new Promise<typeof STOPPED>((resolve) => (abandon = () => resolve(STOPPED)))
+    const dl: Download = { start: performance.now(), received: 0, abandon }
+    this.downloads.set(hash, dl)
+    const ends = Promise.race([stopped, abandoned])
     try {
-      const ingest = this.local.ingest(hash, endsOnStop(remoteBody.body, stopped), meta)
+      const ingest = this.local.ingest(
+        hash,
+        endsOnStop(remoteBody.body, ends, (n) => (dl.received += n)),
+        meta,
+      )
       ingest.catch(() => undefined)
-      if ((await Promise.race([ingest, stopped])) === STOPPED) return false
+      if ((await Promise.race([ingest, ends])) === STOPPED) return false
     } catch (err) {
       // The bytes came off the network — a corrupt/truncated remote
       // artifact must degrade to a cache miss (task re-executes), not
@@ -395,8 +504,13 @@ export class LayeredCache implements CacheLayer {
       // down: `Cache.restoreOutputs` drops it (A-52).
       lane.report('download', hash, err)
       return false
+    } finally {
+      this.downloads.delete(hash)
     }
     this.remoteSourced.set(hash, Math.round(performance.now() - fetchStart))
+    this.local.downloads.count++
+    this.local.downloads.bytes +=
+      remoteBody.body instanceof Blob ? remoteBody.body.size : dl.received
     return true
   }
 
@@ -457,8 +571,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,7 +8,6 @@
 
 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'
@@ -19,17 +18,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
@@ -88,18 +91,17 @@ async function capped(body: unknown, max = PLUGIN_ENTRY_MAX_BYTES): Promise<Uint
 /**
  * `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.
+ * 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 at: RemoteKey = scope === undefined ? {} : { scope }
-  const atOf = (key: string, name: string): RemoteKey => (key === entryKey(plugin, name) ? {} : at)
-  const reads = (name: string): string[] => {
+  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)
@@ -143,23 +145,21 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
   }
 
   return {
-    async get(name) {
+    async get(name, scoped = true) {
       const local = entryKey(plugin, name)
       const hit = localGet(local)
       if (hit !== null) return hit
-      const keys = reads(name)
+      const key = readKey(name, scoped)
       for (const { remote } of readers) {
-        for (const key of keys) {
-          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
-          }
+        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(local, bytes)
+          return bytes
+        } catch {
+          // a failing remote is a miss there
         }
       }
       return null
@@ -171,33 +171,31 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       if (policy.localWrite) localPut(entryKey(plugin, name), bytes)
       for (const { remote } of writers) {
         try {
-          await remote.put(key, new Blob([bytes]), { durationMs: 0, ...at })
+          await remote.put(key, new Blob([bytes]), { durationMs: 0 })
         } catch {
           // the other layers still keep it
         }
       }
     },
 
-    async has(name) {
+    async has(name, scoped = true) {
       if (localHas([entryKey(plugin, name)]).size > 0) return true
-      const keys = reads(name)
+      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, atOf(key, name))) return true
-            answered = true
-          } catch {
-            // no answer from this remote
-          }
+        try {
+          if (await remote.has(key)) 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(names.map((n) => entryKey(plugin, n)))) found.add(byKey.get(key)!)
@@ -206,12 +204,10 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         if (ask.length === 0) break
         if (remote.hasMany === undefined) return null
         try {
-          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)!)
+          const got: unknown = await remote.hasMany(ask)
+          if (!(got instanceof Map)) return null
+          for (const key of got.keys())
+            if (byKey.has(key as string)) found.add(byKey.get(key as string)!)
         } catch {
           return null
         }
@@ -221,9 +217,9 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
 
     async getRun(name) {
       for (const { remote } of readers) {
-        for (const [i, key] of runReadKeys(name, scope).entries()) {
+        for (const key of runReadKeys(name, scope)) {
           try {
-            const got = await remote.get(key, i === 0 ? {} : at)
+            const got = await remote.get(key)
             if (got === null) continue
             const bytes = await capped(got.body, Infinity)
             if (bytes !== null) return bytes