@vzn/vx 0.0.645 → 0.0.648

package/src/cache/output-index.ts

@@ -18,11 +18,11 @@ const FILE_PREFIX_MTIME = -2
 import type { Database } from 'bun:sqlite'
 import { inHashes, lazyStatement } from './schema.js'
 import { modeMatches } from './umask.js'
-import { lstatSync, readlinkSync, statSync } from 'node:fs'
-import { lstat, readdir } from 'node:fs/promises'
+import { lstatSync, readdirSync, readlinkSync, statSync } from 'node:fs'
 import path from 'node:path'
 import {
   OUTPUT_DIRS_CAP,
+  OUTPUT_DIRS_OVER_CAP,
   OUTPUT_DIRS_RACY_MS,
   type OutputDirRow,
   isIndexFull,
@@ -37,6 +37,12 @@ import {
  */
 export const LINK_MODE = 0o120000
 
+/**
+ * The type bits a directory row carries beside a mode the restore applies
+ * (`MetaFile.dirModes`); an empty directory's row without one is mode 0.
+ */
+export const DIR_MODE = 0o040000
+
 /** A link row is current while a link with that target stands there; never followed. */
 function linkCurrent(abs: string, e: { size: number; mtimeMs: number }): boolean {
   if (!lstatSync(abs).isSymbolicLink()) return false
@@ -75,7 +81,15 @@ export class OutputIndex {
    */
   private readonly held = new Map<string, readonly OutputFileRow[]>()
 
-  constructor(private readonly db: Database) {
+  /**
+   * `memo` false: a cache directory this run cannot write. A restore still
+   * serves the hit, but its stamps and directory snapshots are not queued:
+   * the next lookup flushed them and failed its task (SQLITE_READONLY).
+   */
+  constructor(
+    private readonly db: Database,
+    private readonly memo = true,
+  ) {
     this.insertOutputFile = lazyStatement(
       this.db,
       `
@@ -206,7 +220,7 @@ export class OutputIndex {
     return out
   }
 
-  async isOutputsCurrent(projectDir: string, expected: readonly OutputFileRow[]): Promise<boolean> {
+  isOutputsCurrent(projectDir: string, expected: readonly OutputFileRow[]): boolean {
     // Empty manifest case (a task produced no outputs) → trivially
     // current; the on-disk tree under projectDir is whatever it was,
     // and nothing was supposed to land there.
@@ -262,8 +276,8 @@ export class OutputIndex {
    * process may have written into them: `holds` is asked with the files
    * the walk saw, and a tree it refuses records nothing (item 1087).
    * Symlinked directories are not descended (the output walk refuses them
-   * too). Over `OUTPUT_DIRS_CAP` directories, or on any error, the rows
-   * are cleared and the next hit keeps the walk.
+   * too). Over `OUTPUT_DIRS_CAP` directories the one row left says so; on
+   * any error the rows are cleared. Either way the next hit keeps the walk.
    */
   async recordOutputDirs(
     hash: string,
@@ -271,13 +285,19 @@ export class OutputIndex {
     prefixes: readonly string[],
     holds?: (files: readonly string[]) => boolean,
   ): Promise<void> {
+    if (!this.memo) return
     const rows: Array<[string, number]> = []
     const files: string[] = []
-    const walk = async (rel: string, isPrefix = false): Promise<boolean> => {
+    let overCap = false
+    // Synchronous, like the stats of `isOutputsCurrent`: an async lstat and
+    // readdir per directory are two thread-pool round trips, and a
+    // root-anchored glob's snapshot of solid's 47 directories took 4 ms of
+    // the run's end that way (2026-10-22).
+    const walk = (rel: string, isPrefix = false): boolean => {
       const abs = path.join(projectDir, rel)
       let st
       try {
-        st = await lstat(abs)
+        st = lstatSync(abs)
       } catch {
         // A declared prefix the task never produced (`build/**` beside
         // `dist/**`, medusa's `.medusa/**`) is recorded ABSENT: the check
@@ -299,29 +319,38 @@ export class OutputIndex {
         return true
       }
       rows.push([rel, st.mtimeMs])
-      if (rows.length > OUTPUT_DIRS_CAP) return false
+      if (rows.length > OUTPUT_DIRS_CAP) {
+        overCap = true
+        return false
+      }
       let entries
       try {
-        entries = await readdir(abs, { withFileTypes: true })
+        entries = readdirSync(abs, { withFileTypes: true })
       } catch {
         return false
       }
       for (const e of entries) {
+        // The project itself is the prefix `''` of a root-anchored glob.
+        const child = rel === '' ? e.name : `${rel}/${e.name}`
         if (e.isDirectory() && !e.isSymbolicLink()) {
-          if (!(await walk(`${rel}/${e.name}`))) return false
+          if (!walk(child)) return false
         } else {
-          files.push(`${rel}/${e.name}`)
+          files.push(child)
         }
       }
       return true
     }
     let ok = true
     for (const prefix of prefixes) {
-      if (!(await walk(prefix, true))) {
+      if (!walk(prefix, true)) {
         ok = false
         break
       }
     }
+    if (overCap) {
+      this.pendingDirs.set(hash, [[prefixes[0]!, OUTPUT_DIRS_OVER_CAP]])
+      return
+    }
     // All or nothing: a racy directory dropped alone would leave its
     // parent trusted while an addition inside it bumps only the dropped one.
     const now = Date.now()
@@ -338,6 +367,7 @@ export class OutputIndex {
    * Written with the directory snapshots, in one transaction.
    */
   recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
+    if (!this.memo) return
     const rows = this.rowsOf(hash)
     const stamps: Array<[string, number, number]> = []
     for (const e of rows) {
@@ -428,7 +458,7 @@ export class OutputIndex {
   }
 
   /** True iff every recorded directory exists with its recorded mtime (ms). Same forged-mtime trade as the file check. */
-  async outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): Promise<boolean> {
+  outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): boolean {
     if (rows.length === 0) return false
     const results = rows.map((r) => {
       let st

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
@@ -228,17 +243,63 @@ export class RemoteLane {
     return out
   }
 
-  /** The artifact's body, or null on a miss, a known absence, a failure or a malformed answer. */
-  async get(hash: string): Promise<{ body: Blob | Response; durationMs?: number } | null> {
-    if (this.absent.has(hash)) return null
+  /**
+   * `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 | 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'
@@ -251,9 +312,17 @@ export class RemoteLane {
           `get() resolved ${shape} (expected { body: Blob | Response, durationMs } or null)`,
         ),
       )
-      return null
+      return undefined
     }
-    return result as { body: Blob | Response; durationMs?: number }
+    // It holds the key: a save of it after this restore uploads nothing.
+    const got = result as { body: Blob | Response; durationMs?: number }
+    this.held.set(hash, got.durationMs === undefined ? {} : { durationMs: got.durationMs })
+    return got
+  }
+
+  /** `hash`'s bytes here are unreadable: a save of it uploads, held or not. */
+  distrust(hash: string): void {
+    this.distrusted.add(hash)
   }
 
   /**
@@ -284,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)
@@ -320,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. */
@@ -372,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.
@@ -426,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
     }