@vzn/vx 0.0.646 → 0.0.649

package/src/cache/plugin-cache.ts

@@ -1,5 +1,5 @@
 // A plugin's own entries in the cache the workspace declares (`ctx.cache`,
-// owner 2026-10-14): the local store first, then each remote in declared
+// 2026-10-14): the local store first, then each remote in declared
 // order, under the run's policy and scope. The plugin speaks names; core
 // derives the key, so no plugin reaches another's entries or a task's. An
 // entry is written once and never replaced (the cache is immutable). Every
@@ -7,9 +7,9 @@
 // warnings): what a plugin keeps here is a hint.
 
 import type { Database } from 'bun:sqlite'
-import { xxh3hex } from '../util/index.js'
+import { thrownMessage, xxh3hex } from '../util/index.js'
 import type { CachePolicy } from './policy.js'
-import type { ResolvedRemote } from './remote-lane.js'
+import { sayRemoteFault, type ResolvedRemote } from './remote-lane.js'
 import { scopedKey } from './scoped-cache.js'
 import { runReadKeys } from './run-store.js'
 
@@ -73,6 +73,7 @@ async function capped(body: unknown, max = PLUGIN_ENTRY_MAX_BYTES): Promise<Uint
     if (done) break
     size += value.byteLength
     if (size > max) {
+      // quiet: the body is refused for its size, said by the miss; its cancel adds nothing
       await reader.cancel().catch(() => {})
       return null
     }
@@ -90,15 +91,30 @@ 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
+ * (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
+ * scope's, or with `scoped` false the default (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)
+  // A plugin's entries are not task artifacts: a policy that reads no
+  // remote artifact (a cold run, `--force`) still reads them, so the run is
+  // planned on the default branch's timings. A cold CI run asked workers
+  // for 128 tasks with 0 measured, at 25% of their cores (2026-10-23).
+  const readers = host.remotes.filter((r) => r.read || r.write)
   const writers = host.remotes.filter((r) => r.write)
+  // Each remote's fault said once per kind: unsaid, a remote down left DTE
+  // planning on no timings and no line said why.
+  const said = new Map<ResolvedRemote, Set<string>>()
+  const fault = (r: ResolvedRemote, op: string, what: string, err: unknown): void => {
+    const message = thrownMessage(err)
+    const seen = said.get(r) ?? new Set<string>()
+    said.set(r, seen)
+    if (seen.has(`${op}\0${message}`)) return
+    seen.add(`${op}\0${message}`)
+    sayRemoteFault(r, new Error(`${op} of ${plugin}'s ${what} failed: ${message}`, { cause: err }))
+  }
   const readKey = (name: string, scoped: boolean): string => {
     const key = entryKey(plugin, name)
     return scope === undefined || !scoped ? key : scopedKey(scope, key)
@@ -115,6 +131,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         bytes: Uint8Array
       } | null
       return row === null ? null : new Uint8Array(row.bytes)
+      // quiet: the local index, not a remote: an unreadable one holds nothing
     } catch {
       return null
     }
@@ -127,6 +144,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         .query(`SELECT key FROM plugin_blobs WHERE key IN (${keys.map(() => '?').join(', ')})`)
         .all(...keys) as Array<{ key: string }>
       for (const r of rows) found.add(r.key)
+      // quiet: the local index, not a remote
     } catch {
       // an unreadable index holds nothing
     }
@@ -139,6 +157,7 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
         bytes,
         Date.now(),
       )
+      // quiet: the local index, not a remote
     } catch {
       // a read-only or busy index keeps nothing
     }
@@ -150,16 +169,17 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       const hit = localGet(local)
       if (hit !== null) return hit
       const key = readKey(name, scoped)
-      for (const { remote } of readers) {
+      for (const r of readers) {
         try {
-          const got = await remote.get(key)
+          const got = await r.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 {
+        } catch (err) {
           // a failing remote is a miss there
+          fault(r, 'get', name, err)
         }
       }
       return null
@@ -169,11 +189,12 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       if (bytes.byteLength === 0 || bytes.byteLength > PLUGIN_ENTRY_MAX_BYTES) return
       const key = writeKey(name)
       if (policy.localWrite) localPut(entryKey(plugin, name), bytes)
-      for (const { remote } of writers) {
+      for (const r of writers) {
         try {
-          await remote.put(key, new Blob([bytes]), { durationMs: 0 })
-        } catch {
+          await r.remote.put(key, new Blob([bytes]), { durationMs: 0 })
+        } catch (err) {
           // the other layers still keep it
+          fault(r, 'put', name, err)
         }
       }
     },
@@ -182,12 +203,13 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       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 r of readers) {
         try {
-          if (await remote.has(key)) return true
+          if (await r.remote.has(key)) return true
           answered = true
-        } catch {
+        } catch (err) {
           // no answer from this remote
+          fault(r, 'has', name, err)
         }
       }
       return answered ? false : null
@@ -198,17 +220,20 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
       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)!)
-      for (const { remote } of readers) {
+      // The local store keys entries unscoped (`entryKey`), not by `readKey`.
+      const byLocal = new Map(names.map((n) => [entryKey(plugin, n), n]))
+      for (const key of localHas([...byLocal.keys()])) found.add(byLocal.get(key)!)
+      for (const r of readers) {
         const ask = keys.filter((k) => !found.has(byKey.get(k)!))
         if (ask.length === 0) break
-        if (remote.hasMany === undefined) return null
+        if (r.remote.hasMany === undefined) return null
         try {
-          const got: unknown = await remote.hasMany(ask)
+          const got: unknown = await r.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 {
+        } catch (err) {
+          fault(r, 'hasMany', `${ask.length} entries`, err)
           return null
         }
       }
@@ -216,15 +241,16 @@ export function pluginCache(plugin: string, host: PluginCacheHost): PluginCache
     },
 
     async getRun(name) {
-      for (const { remote } of readers) {
+      for (const r of readers) {
         for (const key of runReadKeys(name, scope)) {
           try {
-            const got = await remote.get(key)
+            const got = await r.remote.get(key)
             if (got === null) continue
             const bytes = await capped(got.body, Infinity)
             if (bytes !== null) return bytes
-          } catch {
+          } catch (err) {
             // a failing remote is a miss there
+            fault(r, 'get', name, err)
           }
         }
       }

package/src/cache/remote-hits.ts

@@ -0,0 +1,72 @@
+// What the remotes said they hold, kept across runs and processes: `vx dte
+// plan` and `vx run` are separate commands on GitLab, and a run trusts this
+// at once instead of waiting on a has-many (2026-10-23). Only hits are
+// kept: a key not here is a miss. Every has-many that answers rewrites the
+// keys it asked, and a GET that finds nothing forgets its key.
+
+import type { Database } from 'bun:sqlite'
+import { inHashes } from './schema.js'
+
+export interface RemoteHit {
+  readonly size?: number
+  readonly durationMs?: number
+}
+
+export class RemoteHits {
+  constructor(
+    private readonly db: Database,
+    /** Off for a reading verb or an index this user cannot write. */
+    private readonly write: boolean,
+  ) {}
+
+  /** The keys of `hashes` a remote last said it holds. */
+  get(hashes: readonly string[]): Map<string, RemoteHit> {
+    const out = new Map<string, RemoteHit>()
+    if (hashes.length === 0) return out
+    const { test, params } = inHashes(hashes)
+    try {
+      const rows = this.db
+        .query(`SELECT hash, size, duration_ms FROM remote_hits WHERE hash ${test}`)
+        .all(...params) as Array<{ hash: string; size: number | null; duration_ms: number | null }>
+      for (const r of rows)
+        out.set(r.hash, {
+          ...(r.size === null ? {} : { size: r.size }),
+          ...(r.duration_ms === null ? {} : { durationMs: r.duration_ms }),
+        })
+    } catch {
+      // An unreadable or busy index knows no hit.
+    }
+    return out
+  }
+
+  /** A has-many's whole answer: `found` are hits, the rest of `asked` no longer are. */
+  record(asked: readonly string[], found: ReadonlyMap<string, RemoteHit>, now = Date.now()): void {
+    if (!this.write || asked.length === 0) return
+    try {
+      const upsert = this.db.query(
+        'INSERT OR REPLACE INTO remote_hits(hash, size, duration_ms, seen_at) VALUES (?, ?, ?, ?)',
+      )
+      const gone = asked.filter((h) => !found.has(h))
+      this.db.transaction(() => {
+        for (const [hash, info] of found)
+          upsert.run(hash, info.size ?? null, info.durationMs ?? null, now)
+        if (gone.length > 0) {
+          const { test, params } = inHashes(gone)
+          this.db.query(`DELETE FROM remote_hits WHERE hash ${test}`).run(...params)
+        }
+      })()
+    } catch {
+      // A busy index keeps nothing: the next run asks again.
+    }
+  }
+
+  /** No remote served `hash`: a miss from now on. */
+  forget(hash: string): void {
+    if (!this.write) return
+    try {
+      this.db.query('DELETE FROM remote_hits WHERE hash = ?').run(hash)
+    } catch {
+      // A busy index keeps the row: its next GET forgets it.
+    }
+  }
+}

package/src/cache/remote-lane.ts

@@ -4,7 +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 { machineParallelism, thrownMessage, ui } from '../util/index.js'
 import type { RemoteKeyTraffic, RemoteTraffic } from './cache.js'
 import type { ArtifactInfo, RemoteCacheLayer } from './layered-cache.js'
 
@@ -20,6 +20,19 @@ export interface ResolvedRemote {
   readonly onError?: (err: Error) => void
 }
 
+/**
+ * A fault of `r` that a caller outside its lane degrades to a miss, said as
+ * the lane says its own: to its `onError`, else stderr. Reporting never
+ * escalates.
+ */
+export function sayRemoteFault(r: ResolvedRemote, e: Error): void {
+  try {
+    if (r.onError) r.onError(e)
+    else ui.say('warn', `[vx] remote cache: ${e.message}\n`)
+    // quiet: a throwing reporter must never fail the run
+  } catch {}
+}
+
 /**
  * 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
@@ -84,7 +97,7 @@ function printableEndpoint(endpoint: unknown): string | undefined {
 
 /**
  * What makes two failures "the same way": the error's `code` when it
- * carries one (a gRPC status, an errno, Bun's `ConnectionRefused`), because
+ * carries one (a gRPC status, an errno, Bun's `ECONNREFUSED`), because
  * gRPC writes the elapsed time into its message and no two deadline messages
  * match; else the message with the artifact's hash taken out, so a 500 on
  * one hash and a 500 on the next are one class. The operation is not part of
@@ -115,6 +128,8 @@ export class RemoteLane {
   private readonly absent = new Set<string>()
   /** What a `hasMany` said this remote holds, as `absent` records the rest. */
   private readonly held = new Map<string, ArtifactInfo>()
+  /** Keys whose bytes here did not read back (`distrust`). */
+  private readonly distrusted = new Set<string>()
 
   /**
    * A remote the run writes but does not read (`--force`): which of the
@@ -229,22 +244,62 @@ export class RemoteLane {
   }
 
   /**
-   * The artifact's body, or null on a miss, a known absence (unless
-   * `fresh`: saved since the probe), a failure or a malformed answer.
+   * `hashes` asked one by one (`has`), `concurrency` at a time: what a
+   * remote that answered no batch query holds, recording the rest as
+   * absent. Null when any probe failed: then the answer is not complete.
+   */
+  async hasEach(
+    hashes: readonly string[],
+    concurrency: number,
+  ): Promise<Map<string, ArtifactInfo> | null> {
+    const out = new Map<string, ArtifactInfo>()
+    const absent: string[] = []
+    let failed = false
+    let next = 0
+    const one = async (): Promise<void> => {
+      while (!failed && next < hashes.length) {
+        const h = hashes[next++]!
+        let found: unknown
+        try {
+          found = this.held.get(h) ?? (this.absent.has(h) ? null : await this.remote.has(h))
+        } catch (err) {
+          this.report('probe', h, err)
+          failed = true
+          return
+        }
+        if (found === null || found === undefined) absent.push(h)
+        else out.set(h, artifactInfo(found) ?? {})
+      }
+    }
+    await Promise.all(Array.from({ length: Math.max(1, concurrency) }, one))
+    if (failed) return null
+    for (const h of absent) this.absent.add(h)
+    for (const [h, info] of out) this.held.set(h, info)
+    return out
+  }
+
+  /**
+   * The artifact's body, null on a miss or a known absence (unless
+   * `fresh`: saved since the probe), undefined on a failure or a
+   * malformed answer: the key may still be there.
    */
   async get(
     hash: string,
     fresh = false,
-  ): Promise<{ body: Blob | Response; durationMs?: number } | null> {
+  ): Promise<{ body: Blob | Response; durationMs?: number } | null | undefined> {
     if (!fresh && this.absent.has(hash)) return null
     let result: unknown
     try {
       result = await this.remote.get(hash)
     } catch (err) {
       this.report('download', hash, err)
+      return undefined
+    }
+    if (!result) {
+      // Gone, whatever a probe said: the re-run's save uploads it.
+      this.held.delete(hash)
       return null
     }
-    if (!result) return null
     if (typeof result !== 'object' || !isBody((result as { body?: unknown }).body)) {
       const shape =
         typeof result !== 'object'
@@ -257,7 +312,7 @@ export class RemoteLane {
           `get() resolved ${shape} (expected { body: Blob | Response, durationMs } or null)`,
         ),
       )
-      return null
+      return undefined
     }
     // It holds the key: a save of it after this restore uploads nothing.
     const got = result as { body: Blob | Response; durationMs?: number }
@@ -265,6 +320,11 @@ export class RemoteLane {
     return got
   }
 
+  /** `hash`'s bytes here are unreadable: a save of it uploads, held or not. */
+  distrust(hash: string): void {
+    this.distrusted.add(hash)
+  }
+
   /**
    * Start the batch probe `presence` reads. A lane that reads, never
    * writes, or cannot batch (no `hasMany`) ignores it: each upload then
@@ -293,27 +353,41 @@ export class RemoteLane {
     return (await this.has(hash)) !== null
   }
 
-  /** Queue a PUT in this remote's bounded pool; `body` is asked for when the job starts. */
+  /**
+   * Queue a PUT in this remote's bounded pool; `body` is asked for when the
+   * job starts. Resolves true once this remote holds `hash`: put now, or held already.
+   * `absent`: no remote held it when the run asked, so none is asked again.
+   */
   upload(
     hash: string,
     durationMs: number,
     body: () => Promise<{ body: Blob; release?: () => Promise<void> }>,
     tally: { count: number; bytes: number; ms: number; failed: number },
-  ): void {
+    absent = false,
+  ): Promise<boolean> {
     const key = this.trafficOf(hash)
     key.uploading++
     this.traffic.inFlight++
+    const { promise, resolve } = Promise.withResolvers<boolean>()
     this.uploadQueue.push(async () => {
       let release: (() => Promise<void>) | undefined
+      let holds = false
       try {
         if (this.stopped) return
-        if (this.held.has(hash)) return
-        if (!this.read && (await this.holds(hash))) return
+        // A key whose bytes here did not read back is sent over them.
+        const distrusted = this.distrusted.has(hash)
+        const known = !distrusted && (absent || this.absent.has(hash))
+        if (!distrusted) {
+          if (this.held.has(hash)) return void (holds = true)
+          if (!known && !this.read && (await this.holds(hash))) return void (holds = true)
+        }
         if (this.stopped) return
         const start = performance.now()
         const got = await body()
         release = got.release
-        await this.remote.put(hash, got.body, { durationMs })
+        if (known) this.remote.missing?.(hash)
+        if ((await this.remote.put(hash, got.body, { durationMs })) === false) return
+        holds = true
         tally.count++
         tally.bytes += got.body.size
         tally.ms += Math.round(performance.now() - start)
@@ -329,9 +403,11 @@ export class RemoteLane {
         // stopped first): no traffic, so the footer counts no upload.
         if (key.uploading === 0 && !key.landed && key.failures.length === 0)
           this.traffic.keys.delete(hash)
+        resolve(holds)
       }
     })
     this.pump()
+    return promise
   }
 
   /** Settles when the run is stopped. */
@@ -381,7 +457,7 @@ export class RemoteLane {
    * server in it (item 749).
    */
   report(op: RemoteOp, subject: string | { batch: string }, err: unknown): void {
-    const e = err instanceof Error ? err : new Error(String(err))
+    const e = err instanceof Error ? err : new Error(thrownMessage(err))
     const hash = typeof subject === 'string' ? subject : undefined
     // A batch probe's failure is no one task's: each of its hashes is asked
     // again on its own, and that ask is the one counted.
@@ -435,7 +511,7 @@ export class RemoteLane {
     // hiccup into a run failure.
     try {
       if (this.onError) this.onError(e)
-      else process.stderr.write(`[vx] remote cache: ${e.message}\n`)
+      else ui.say('warn', `[vx] remote cache: ${e.message}\n`)
     } catch {
       // swallow — reporting must never escalate
     }

package/src/cache/run-history.ts

@@ -6,19 +6,45 @@
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
 import { lazyStatement } from './schema.js'
 import type { InvocationRecord, RunRecord } from './layer.js'
+import { isMeasure } from '../util/index.js'
 
-const INSERT_RUNS = `
-      INSERT INTO runs(
-        hash, project, task, status, exit_code, duration_ms, forward_args,
-        started_at, ended_at,
-        run_id, cpu_ms, peak_rss_bytes, wallclock_start_ns, wallclock_end_ns,
-        cache_hit, attempts, cached,
-        blocked_by, timed_out, sandbox_violations, not_ready, restored, remote_error,
-        peak_cores, avg_rss_bytes, placement, placement_cores, placement_memory, keyless_by
-      )
-      VALUES `
-/** One `runs` row's placeholders: the 29 columns `bindRun` fills. */
-const RUN_TUPLE = `(${Array(29).fill('?').join(', ')})`
+/** The `runs` columns `bindRun` fills, in its order. */
+const RUN_COLUMNS = [
+  'hash',
+  'project',
+  'task',
+  'status',
+  'exit_code',
+  'duration_ms',
+  'forward_args',
+  'started_at',
+  'ended_at',
+  'run_id',
+  'cpu_ms',
+  'peak_rss_bytes',
+  'wallclock_start_ns',
+  'wallclock_end_ns',
+  'cache_hit',
+  'attempts',
+  'cached',
+  'blocked_by',
+  'timed_out',
+  'sandbox_violations',
+  'not_ready',
+  'restored',
+  'remote_error',
+  'peak_cores',
+  'avg_rss_bytes',
+  'placement',
+  'placement_cores',
+  'placement_memory',
+  'keyless_by',
+  'def',
+  'cpu_share',
+]
+
+const INSERT_RUNS = `INSERT INTO runs(${RUN_COLUMNS.join(', ')}) VALUES `
+const RUN_TUPLE = `(${RUN_COLUMNS.map(() => '?').join(', ')})`
 
 /** An INSERT of `n` `runs` rows. */
 function insertRunsSql(n: number): string {
@@ -26,14 +52,15 @@ function insertRunsSql(n: number): string {
 }
 
 /**
- * Rows per INSERT: 34 × 29 variables stays under 999, the oldest default
- * ceiling. A statement per row was 8.7 ms of 1,000 rows, 40 at a time 6.4
- * (2026-10-03).
+ * Rows per INSERT: as many as stay within 999 bound variables, the oldest
+ * default ceiling, read off the column count (33 rows were sized for 30
+ * columns and bound 1,023 at 31). A statement per row was 8.7 ms of 1,000
+ * rows, 40 at a time 6.4 (2026-10-03).
  */
-const RUNS_PER_INSERT = 34
+const RUNS_PER_INSERT = Math.floor(999 / RUN_COLUMNS.length)
 
-/** Rows per `task_durations` INSERT: 6 variables each, under 999. */
-const DURATIONS_PER_INSERT = 160
+/** Rows per `task_durations` INSERT: 7 variables each, under 999. */
+const DURATIONS_PER_INSERT = 140
 
 /** Rows per `task_outcomes` INSERT: 6 variables each, under 999. */
 const OUTCOMES_PER_INSERT = 160
@@ -63,6 +90,20 @@ const PASSED_HASHES = `
 /** A local run's `task_durations.source`: its branch, `''` when it had none. */
 export const branchSource = (branch: string | null): string => `branch:${branch ?? ''}`
 
+/**
+ * How long a run would have taken alone: on a crowded worker
+ * (`cpuShare` < 1) each runnable thread waited for a core. A task that
+ * kept `n` cores busy lost its CPU's wait spread over them, under one
+ * core all of it. vx-dte#test (20 s CPU in 75 s) took 81-102 s beside
+ * test shards and the plan, reading those, said 118 s for a 92 s run
+ * (main fd5c72e, 2026-10-23).
+ */
+function aloneMs(r: Pick<RunRecord, 'durationMs' | 'cpuMs' | 'cpuShare'>): number {
+  const { durationMs: d, cpuMs: c, cpuShare: s } = r
+  if (c === undefined || s === undefined || !(s > 0 && s < 1) || !(d > 0)) return d
+  return Math.round(d - (c / s - c) / Math.max(1, c / (d * s)))
+}
+
 export class RunHistory {
   private readonly insertInvocation: ReturnType<Database['prepare']>
 
@@ -106,16 +147,19 @@ export class RunHistory {
       .immediate()
   }
 
-  /** One `task_durations` row per executed success: what a forecast reads. */
+  /** One `task_durations` row per executed success, as if run alone: what a forecast reads. */
   private insertDurations(runs: readonly RunRecord[], source: string, sha: string | null): void {
-    const done = runs.filter((r) => r.status === 'success' && r.cacheHit !== true)
+    const done = runs.filter(
+      (r) => r.status === 'success' && r.cacheHit !== true && isMeasure(aloneMs(r)),
+    )
     for (let i = 0; i < done.length; i += DURATIONS_PER_INSERT) {
       const block = done.slice(i, i + DURATIONS_PER_INSERT)
       const params: SQLQueryBindings[] = []
-      for (const r of block) params.push(r.project, r.task, source, sha, r.durationMs, r.endedAt)
+      for (const r of block)
+        params.push(r.project, r.task, source, sha, aloneMs(r), r.endedAt, r.def ?? null)
       this.db
         .query(
-          `INSERT INTO task_durations(project, task, source, sha, duration_ms, recorded_at) VALUES ${Array(block.length).fill('(?, ?, ?, ?, ?, ?)').join(', ')}`,
+          `INSERT INTO task_durations(project, task, source, sha, duration_ms, recorded_at, def) VALUES ${Array(block.length).fill('(?, ?, ?, ?, ?, ?, ?)').join(', ')}`,
         )
         .run(...params)
     }
@@ -171,7 +215,7 @@ export class RunHistory {
     for (let i = 0; i < runs.length; i += RUNS_PER_INSERT) {
       const block = runs.slice(i, i + RUNS_PER_INSERT)
       const params: SQLQueryBindings[] = []
-      for (const r of block) params.push(...bindRun(r, digest))
+      for (const r of block) for (const v of bindRun(r, digest)) params.push(v)
       // `query` caches by text: one statement for every full block.
       this.db.query(insertRunsSql(block.length)).run(...params)
     }
@@ -234,6 +278,7 @@ export class RunHistory {
     this.db.prepare('DELETE FROM task_durations WHERE recorded_at < ?').run(cutoff)
     this.db.prepare('DELETE FROM task_outcomes WHERE recorded_at < ?').run(cutoff)
     this.db.prepare('DELETE FROM plugin_blobs WHERE at < ?').run(cutoff)
+    this.db.prepare('DELETE FROM remote_hits WHERE seen_at < ?').run(cutoff)
   }
 }
 
@@ -274,6 +319,8 @@ function bindRun(run: RunRecord, digestValue: (v: string) => string): SQLQueryBi
     run.placementCores ?? null,
     run.placementMemoryBytes ?? null,
     run.keylessBy ?? null,
+    run.def ?? null,
+    run.cpuShare ?? null,
   ]
 }
 

package/src/cache/run-store.ts

@@ -1,4 +1,4 @@
-// What core keeps of a run that writes a remote (owner 2026-10-15): a failed
+// What core keeps of a run that writes a remote (2026-10-15): a failed
 // task's log and the files its outputs left, an uncached task's log. Names
 // come from the run id and task (`run/<id>/<task>/log`); each key is derived
 // in a namespace no task key or plugin entry shares. Remote only: locally
@@ -6,7 +6,7 @@
 // the cache is free). Plugins read them by name (`ctx.cache.getRun`).
 
 import { xxh3hex } from '../util/index.js'
-import type { ResolvedRemote } from './remote-lane.js'
+import { sayRemoteFault, type ResolvedRemote } from './remote-lane.js'
 import { scopedKey } from './scoped-cache.js'
 import { tarPackInto, tarSize } from './tar-stream.js'
 
@@ -30,8 +30,8 @@ export function writesRunStore(remotes: readonly ResolvedRemote[]): boolean {
 
 /**
  * Store `bytes` under `name` in every remote the policy writes. An entry is
- * written once; a remote's failure leaves the others theirs, silently: what
- * a run keeps here is a record, never its verdict.
+ * written once; a remote's failure is said and leaves the others theirs:
+ * what a run keeps here is a record, never its verdict.
  */
 export async function putRunEntry(
   remotes: readonly ResolvedRemote[],
@@ -41,16 +41,17 @@ export async function putRunEntry(
 ): Promise<boolean> {
   const key = scope === undefined ? runKey(name) : scopedKey(scope, runKey(name))
   let kept = false
-  for (const { remote, write } of remotes) {
-    if (!write) continue
+  for (const r of remotes) {
+    if (!r.write) continue
     try {
-      await remote.put(key, new Blob([bytes]), {
+      const put = await r.remote.put(key, new Blob([bytes]), {
         durationMs: 0,
         ...(scope === undefined ? {} : { scope }),
       })
-      kept = true
-    } catch {
-      // the other remotes still keep it
+      // `false`: the remote sent nothing, so nothing is kept there.
+      if (put !== false) kept = true
+    } catch (err) {
+      sayRemoteFault(r, err instanceof Error ? err : new Error(String(err)))
     }
   }
   return kept