@vzn/vx 0.0.21 → 0.0.23

package/src/cache/layered-cache.ts

@@ -1,7 +1,7 @@
 // LayeredCache — composes the local cache with a remote HTTP cache.
 //
-// Read path:  try local. On miss, try remote; on remote hit, ingest
-// the artifact bytes into local so the next read is a local hit.
+// Read path:  try local. On miss, try remote; on remote hit, stream
+// the artifact body into local so the next read is a local hit.
 //
 // Write path: write to local synchronously. Upload the local artifact
 // to remote as a fire-and-forget background task; failures log a
@@ -45,8 +45,20 @@ import { FULL_CACHE_POLICY, type OutputDirRow } from './cache.js'
  * local `<hash>.tar.zst` verbatim. The wires live in plugin packages
  * (`@vzn/vx-migrate`'s `turboCache()` and `nxCache()`, `@vzn/vx-reapi`); see
  * docs/modules/layered-cache.md.
+ *
+ * Core awaits every call and bounds none: a `get` that never settles
+ * holds its task and a `put` the run's upload drain, so each request
+ * carries the layer's own deadline (every first-party layer has one; the
+ * plugin guide's example shows it).
  */
 export interface RemoteCacheLayer {
+  /**
+   * Where the layer's artifacts live, named in every degrade warning
+   * (`upload <hash> to <endpoint> failed: …`): a base URL or `host:port`.
+   * Never a credential: a URL's `user:pass@`, query and fragment are
+   * dropped before it is printed.
+   */
+  readonly endpoint?: string
   /** Existence probe (drives the plan path's `--dry` remote prediction). */
   has(hash: string): Promise<boolean>
   /**
@@ -58,11 +70,47 @@ export interface RemoteCacheLayer {
    * info; use per-hash".
    */
   hasMany?(hashes: readonly string[]): Promise<Set<string> | null>
-  /** Fetch an artifact's bytes; `null` = miss. `durationMs` is the
-   *  producing task's duration when the wire carries it. */
-  get(hash: string): Promise<{ body: ArrayBuffer; durationMs: number | undefined } | null>
-  /** Store an artifact (fire-and-forget from LayeredCache's perspective). */
-  put(hash: string, body: ArrayBuffer | Uint8Array, meta: { durationMs: number }): Promise<void>
+  /**
+   * Fetch an artifact; `null` = miss. `body` is read once, by core,
+   * straight into the local cache — an HTTP wire returns its `fetch`
+   * `Response`, a chunked wire `new Response(stream)`, bytes in hand
+   * `new Blob([bytes])`. `durationMs` is the producing task's duration
+   * when the wire carries it.
+   */
+  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
+   * artifact, so a plugin that streams it never holds it whole.
+   */
+  put(hash: string, body: Blob, meta: { durationMs: number }): Promise<void>
+}
+
+/**
+ * What a remote layer resolves is a plugin's, so its shape is a boundary
+ * (item 252): a `get` that resolved `{ body: 'abc' }` was reported as
+ * "corrupt artifact … not a readable archive" — the bytes blamed for the
+ * plugin's shape — and a `hasMany` that resolved an array reached the
+ * prefetch pass's `.has()`. Named here and degraded to a miss, like every
+ * other remote failure.
+ */
+function invalidRemoteResult(what: string): Error {
+  return new Error(
+    `remote cache layer returned an invalid result: ${what} — a plugin bug, degraded to a miss`,
+  )
+}
+
+function isBody(value: unknown): value is Blob | Response {
+  return value instanceof Blob || value instanceof Response
+}
+
+function describeValue(value: unknown): string {
+  if (value === null) return 'null'
+  if (Array.isArray(value)) return 'an array'
+  // The pre-stream contract's shape, named so an unported layer reads its fix.
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value))
+    return `a ${value.constructor.name}`
+  return typeof value === 'object' ? 'an object' : typeof value
 }
 
 /**
@@ -71,8 +119,51 @@ export interface RemoteCacheLayer {
  */
 const UPLOAD_CONCURRENCY = 4
 
+/** The seam call a failure happened in, as the warning names it. */
+type RemoteOp = 'probe' | 'download' | 'upload'
+
+const PREPOSITION: Record<RemoteOp, string> = { probe: 'at', download: 'from', upload: 'to' }
+
+/** The layer's `endpoint` as it may be printed: no userinfo, query or fragment. */
+function printableEndpoint(endpoint: unknown): string | undefined {
+  if (typeof endpoint !== 'string' || endpoint === '') return undefined
+  if (!URL.canParse(endpoint)) return endpoint
+  const u = new URL(endpoint)
+  if (u.username === '' && u.password === '' && u.search === '' && u.hash === '') return endpoint
+  u.username = ''
+  u.password = ''
+  u.search = ''
+  u.hash = ''
+  return u.toString()
+}
+
+/**
+ * What makes two failures "the same way": the error's `code` when it
+ * carries one (a gRPC status, an errno, Bun's `ConnectionRefused`), 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
+ * it: an unreachable server fails the probe, the download and the upload
+ * alike, and that is one fact.
+ */
+function failureClass(err: Error, hash: string | undefined): string {
+  const code = (err as { code?: unknown }).code
+  if (typeof code === 'string' || typeof code === 'number') return `${err.name}\0${code}`
+  return hash === undefined ? err.message : err.message.replaceAll(hash, '\0')
+}
+
+/** A batch probe names no one hash, so its line counts them. */
+function batchOf(hashes: readonly string[]): { batch: string } {
+  return { batch: `of ${hashes.length} artifact${hashes.length === 1 ? '' : 's'}` }
+}
+
 export interface LayeredCacheOptions {
-  /** Called for remote-related errors that the layer suppresses. */
+  /**
+   * Called for the remote failures the layer degrades to a miss, once per
+   * failure class per layer (`upload <hash> to <endpoint> failed: <cause>`,
+   * with the original error as `cause`); the repeats are counted and said
+   * once more at `close()` (`<n> more requests failed the same way: <cause>`).
+   */
   onRemoteError?: (err: Error) => void
   /**
    * The 4-axis read/write policy. The local slice (read/write) is
@@ -121,6 +212,15 @@ export class LayeredCache implements CacheLayer {
   private drainWaiters: Array<() => void> = []
 
   private readonly policy: CachePolicy
+  private readonly endpoint: string | undefined
+
+  /**
+   * One entry per failure class said: its first line went out, `repeats`
+   * counts the ones held back. A run's requests are concurrent, so an
+   * unreachable server otherwise printed its bare runtime message once per
+   * request (three lines for one task over the Turbo wire, item 749).
+   */
+  private readonly reported = new Map<string, { cause: string; repeats: number }>()
 
   constructor(
     readonly local: Cache,
@@ -128,6 +228,7 @@ export class LayeredCache implements CacheLayer {
     private readonly options: LayeredCacheOptions = {},
   ) {
     this.policy = options.policy ?? FULL_CACHE_POLICY
+    this.endpoint = printableEndpoint(remote.endpoint)
   }
 
   key(input: CacheKeyInput): Promise<string> {
@@ -157,9 +258,20 @@ export class LayeredCache implements CacheLayer {
     try {
       // `return await`, deliberately: the catch below is the never-fail
       // contract, and a returned promise's rejection would sail past it.
-      return await this.remote.hasMany(hashes)
+      const found: unknown = await this.remote.hasMany(hashes)
+      if (found !== null && found !== undefined && !(found instanceof Set)) {
+        this.reportRemoteError(
+          'probe',
+          batchOf(hashes),
+          invalidRemoteResult(
+            `hasMany() resolved ${describeValue(found)} (expected a Set of the hashes present, or null)`,
+          ),
+        )
+        return null
+      }
+      return found ?? null
     } catch (err) {
-      this.reportRemoteError(err)
+      this.reportRemoteError('probe', batchOf(hashes), err)
       return null
     }
   }
@@ -227,7 +339,7 @@ export class LayeredCache implements CacheLayer {
     try {
       return (await this.remote.has(hash)) ? 'remote' : null
     } catch (err) {
-      this.reportRemoteError(err)
+      this.reportRemoteError('probe', hash, err)
       return null
     }
   }
@@ -259,16 +371,31 @@ export class LayeredCache implements CacheLayer {
     // or remote if a concurrent prefetch set it).
     if ((await this.local.has(hash)) === 'local') return true
 
-    let remoteResult
+    let remoteResult: unknown
     try {
       remoteResult = await this.remote.get(hash)
     } catch (err) {
-      this.reportRemoteError(err)
+      this.reportRemoteError('download', hash, err)
       return false
     }
     if (!remoteResult) return false
+    if (typeof remoteResult !== 'object' || !isBody((remoteResult as { body?: unknown }).body)) {
+      const shape =
+        typeof remoteResult !== 'object'
+          ? describeValue(remoteResult)
+          : `body is ${describeValue((remoteResult as { body?: unknown }).body)}`
+      this.reportRemoteError(
+        'download',
+        hash,
+        invalidRemoteResult(
+          `get() resolved ${shape} (expected { body: Blob | Response, durationMs } or null)`,
+        ),
+      )
+      return false
+    }
+    const remoteBody = remoteResult as { body: Blob | Response; durationMs?: number }
 
-    // Ingest the remote bytes into local using the caller-supplied
+    // Ingest the remote body into local using the caller-supplied
     // taskId/command plus the remote-reported durationMs. The remote
     // layer carries durationMs as an HTTP header (x-artifact-duration);
     // taskId + command come from the orchestrator's TaskNode in scope.
@@ -278,16 +405,21 @@ export class LayeredCache implements CacheLayer {
     const meta: IngestMeta = {
       taskId: ctx?.taskId ?? `${hash}#unknown`,
       command: ctx?.command ?? '',
-      durationMs: remoteResult.durationMs ?? 0,
+      // A layer's number is taken only as a finite non-negative one: a NaN
+      // failed the entry row's NOT NULL after the artifact was renamed into
+      // place, which threw a valid hit away and orphaned its bytes, and a
+      // negative or infinite one was stored and replayed (item 944).
+      durationMs: durationOf(remoteBody.durationMs),
+      ...(ctx?.outputs !== undefined ? { outputs: ctx.outputs } : {}),
     }
     try {
-      await this.local.ingest(hash, new Uint8Array(remoteResult.body), meta)
+      await this.local.ingest(hash, remoteBody.body, meta)
     } catch (err) {
       // The bytes came off the network — a corrupt/truncated remote
       // artifact must degrade to a cache miss (task re-executes), not
       // crash the run. Local-layer reads outside this block still
       // propagate: local corruption is a real fault, not a network one.
-      this.reportRemoteError(err)
+      this.reportRemoteError('download', hash, err)
       return false
     }
     this.remoteSourced.add(hash)
@@ -318,16 +450,13 @@ export class LayeredCache implements CacheLayer {
     // cache. Errors are logged, not propagated: the task already
     // succeeded; we don't fail it on cache-server issues.
     //
-    // The artifact bytes are read INSIDE the job, not here.
-    // UPLOAD_CONCURRENCY bounds sockets, not memory: a queued closure
-    // holding its own artifact keeps the WHOLE backlog resident, so peak
-    // RSS scaled with a run's total miss artifact bytes rather than with
-    // the pool — any cold monorepo run whose remote uploads slower than the
-    // build produces artifacts held every pending one at once. Reading in
-    // the job caps resident artifact bytes at UPLOAD_CONCURRENCY. The
+    // The job hands the plugin a file-backed Blob over the local artifact,
+    // opened when the plugin reads it: a queued job holds a path, not a
+    // buffer, and a plugin that streams the Blob never holds it whole. The
     // artifact is content-addressed and immutable, so a deferred read sees
     // the same bytes; if a concurrent `vx cache prune` removed it first the
-    // read throws and this upload is skipped — the never-fail contract.
+    // plugin's read throws and this upload is skipped — the never-fail
+    // contract.
     const hash = args.hash
     const durationMs = args.entry.durationMs
     // Local writes disabled (`--cache=local:,remote:rw`): there is no
@@ -341,16 +470,17 @@ export class LayeredCache implements CacheLayer {
       try {
         packed = await this.local.packArtifactBytes(args)
       } catch (err) {
-        this.reportRemoteError(err)
+        this.reportRemoteError('upload', hash, err)
         return
       }
     }
     this.enqueueUpload(async () => {
       try {
-        const bytes = packed ?? (await Bun.file(this.local.outputsPath(hash)).bytes())
-        await this.remote.put(hash, bytes, { durationMs })
+        const body =
+          packed !== undefined ? new Blob([packed]) : Bun.file(this.local.outputsPath(hash))
+        await this.remote.put(hash, body, { durationMs })
       } catch (err) {
-        this.reportRemoteError(err)
+        this.reportRemoteError('upload', hash, err)
       }
     })
   }
@@ -387,8 +517,8 @@ export class LayeredCache implements CacheLayer {
     }
   }
 
-  async ingest(hash: string, compressed: Uint8Array, meta: IngestMeta): Promise<void> {
-    await this.local.ingest(hash, compressed, meta)
+  async ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void> {
+    await this.local.ingest(hash, body, meta)
   }
 
   loadOutputFilesBatch(hashes: readonly string[]): Map<string, OutputFileRow[]> {
@@ -404,6 +534,9 @@ export class LayeredCache implements CacheLayer {
   recordOutputDirs(hash: string, projectDir: string, prefixes: readonly string[]): Promise<void> {
     return this.local.recordOutputDirs(hash, projectDir, prefixes)
   }
+  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
+    this.local.recordOutputStamps(hash, projectDir, workspaceRoot)
+  }
 
   loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
     return this.local.loadOutputDirsBatch(hashes)
@@ -425,12 +558,42 @@ export class LayeredCache implements CacheLayer {
     return this.local.prune(options)
   }
 
+  /** `run()` drains the uploads and prefetches first, so the repeat counts are final here. */
   close(): void {
+    for (const { cause, repeats } of this.reported.values()) {
+      if (repeats === 0) continue
+      this.emit(
+        new Error(
+          `${repeats} more request${repeats === 1 ? '' : 's'} failed the same way: ${cause}`,
+        ),
+      )
+    }
+    this.reported.clear()
     this.local.close()
   }
 
-  private reportRemoteError(err: unknown): void {
+  /**
+   * `subject` is the artifact's hash, or the batch for a `hasMany`. The
+   * wire's own message says what went wrong but not on what or where: an
+   * upload deadline read `The operation timed out.` with no upload, hash or
+   * server in it (item 749).
+   */
+  private reportRemoteError(op: RemoteOp, subject: string | { batch: string }, err: unknown): void {
     const e = err instanceof Error ? err : new Error(String(err))
+    const hash = typeof subject === 'string' ? subject : undefined
+    const cls = failureClass(e, hash)
+    const seen = this.reported.get(cls)
+    if (seen !== undefined) {
+      seen.repeats++
+      return
+    }
+    this.reported.set(cls, { cause: e.message, repeats: 0 })
+    const what = typeof subject === 'string' ? subject : subject.batch
+    const where = this.endpoint === undefined ? '' : ` ${PREPOSITION[op]} ${this.endpoint}`
+    this.emit(new Error(`${op} ${what}${where} failed: ${e.message}`, { cause: e }))
+  }
+
+  private emit(e: Error): void {
     // The remote cache is fully optional: NO remote failure — a 500, a
     // network drop, a corrupt artifact, even a throwing onRemoteError
     // callback — may ever fail the run. We report and degrade to a
@@ -447,3 +610,7 @@ export class LayeredCache implements CacheLayer {
     }
   }
 }
+
+function durationOf(ms: unknown): number {
+  return typeof ms === 'number' && ms >= 0 && ms <= Number.MAX_SAFE_INTEGER ? Math.round(ms) : 0
+}

package/src/cache/output-index.ts

@@ -17,6 +17,7 @@ import {
   OUTPUT_DIRS_RACY_MS,
   type OutputDirRow,
   type OutputFileRow,
+  WORKSPACE_OUTPUT_PREFIX,
 } from './layer.js'
 
 export class OutputIndex {
@@ -24,6 +25,19 @@ export class OutputIndex {
   private readonly deleteOutputFiles: ReturnType<Database['prepare']>
   private readonly insertOutputDir: ReturnType<Database['prepare']>
   private readonly deleteOutputDirs: ReturnType<Database['prepare']>
+  private readonly entryExists: ReturnType<Database['prepare']>
+  private readonly stampOutputFile: ReturnType<Database['prepare']>
+  /**
+   * Snapshots taken and not yet written, the last per hash. A snapshot is
+   * read by the NEXT run's hit check, never by the task that took it, so
+   * the rows land in one transaction at the first read, at prune, at
+   * stats or at close — the way `accessed_at` bumps do — instead of one
+   * commit per task: 1,000 of them were the whole `output dir snapshots`
+   * stage, 47–72 ms at run end (item 622).
+   */
+  private readonly pendingDirs = new Map<string, Array<[string, number]> | null>()
+  /** Stamps taken and not yet written, flushed with the directory snapshots. */
+  private readonly pendingStamps = new Map<string, Array<[string, number, number]>>()
 
   constructor(private readonly db: Database) {
     this.insertOutputFile = this.db.prepare(`
@@ -39,6 +53,10 @@ export class OutputIndex {
       'INSERT INTO output_dirs(entry_hash, path, mtime_ms) VALUES (?, ?, ?)',
     )
     this.deleteOutputDirs = this.db.prepare('DELETE FROM output_dirs WHERE entry_hash = ?')
+    this.entryExists = this.db.prepare('SELECT 1 FROM entries WHERE hash = ?')
+    this.stampOutputFile = this.db.prepare(
+      'UPDATE output_files SET ino = ?, ctime_ms = ? WHERE entry_hash = ? AND path = ?',
+    )
   }
 
   /**
@@ -62,9 +80,12 @@ export class OutputIndex {
     // compiled statement keyed by the SQL text — so the dominant single-hash
     // warm-hit path (called up to 3× per hit) reuses one statement instead of
     // recompiling on every call.
+    // A reader in the same process (`vx watch`'s next cycle, a test) sees
+    // the stamps taken, not only the ones flushed.
+    this.flushOutputDirs()
     const placeholders = hashes.map(() => '?').join(',')
     const stmt = this.db.query(
-      `SELECT entry_hash, path, size_bytes, mode, mtime_ms FROM output_files WHERE entry_hash IN (${placeholders})`,
+      `SELECT entry_hash, path, size_bytes, mode, mtime_ms, ino, ctime_ms FROM output_files WHERE entry_hash IN (${placeholders})`,
     )
     const rows = stmt.all(...(hashes as readonly SQLQueryBindings[])) as Array<{
       entry_hash: string
@@ -72,6 +93,8 @@ export class OutputIndex {
       size_bytes: number
       mode: number
       mtime_ms: number
+      ino: number | null
+      ctime_ms: number | null
     }>
     for (const r of rows) {
       let list = out.get(r.entry_hash)
@@ -79,7 +102,17 @@ export class OutputIndex {
         list = []
         out.set(r.entry_hash, list)
       }
-      list.push({ path: r.path, size: r.size_bytes, mode: r.mode, mtimeMs: r.mtime_ms })
+      const row: OutputFileRow = {
+        path: r.path,
+        size: r.size_bytes,
+        mode: r.mode,
+        mtimeMs: r.mtime_ms,
+      }
+      if (r.ino !== null && r.ctime_ms !== null) {
+        row.ino = r.ino
+        row.ctimeMs = r.ctime_ms
+      }
+      list.push(row)
     }
     return out
   }
@@ -107,11 +140,21 @@ export class OutputIndex {
           // restoreOutputs re-syncs restored files to the row value,
           // so equality holds exactly in steady state; legacy
           // second-precision rows converge on their first restore.
-          // Residual blind spot: a same-size edit landing in the SAME
-          // millisecond as the recorded write, or a deliberately
-          // forged mtime (touch -r) — the trade every mtime-based
-          // skip check accepts.
-          Math.abs(s.mtimeMs - e.mtimeMs) < 1
+          Math.abs(s.mtimeMs - e.mtimeMs) < 1 &&
+          // And the file is the one THIS machine last saw under this
+          // entry: two entries whose outputs carry one fixed mtime (a
+          // `tar -x`, `cp -p`, SOURCE_DATE_EPOCH) and one size matched
+          // each other's rows, and a hit left the other entry's bytes in
+          // place under a green run (item 886). No task sets a ctime; the
+          // inode is weaker than it looks, since ext4 gives a restore's new
+          // file the inode the clean freed (item 941). A row without a stamp
+          // (an ingest, a changed file at stamping) is never current. The
+          // residual: a same-size rewrite, in place or as a new file on the
+          // same inode, inside the coarse clock tick of the stamp, with the
+          // mtime forged back.
+          e.ino !== undefined &&
+          s.ino === e.ino &&
+          Math.floor(s.ctimeMs) === e.ctimeMs
         )
       } catch {
         return false
@@ -177,16 +220,72 @@ export class OutputIndex {
     // parent trusted while an addition inside it bumps only the dropped one.
     const youngest = Date.now() - OUTPUT_DIRS_RACY_MS
     if (rows.some(([, mtime]) => mtime > youngest)) ok = false
+    this.pendingDirs.set(hash, ok ? rows : null)
+  }
+
+  /**
+   * Stamp `hash`'s rows with each file's inode and ctime, once a save or
+   * a restore has left the tree equal to the entry. A file whose size,
+   * mode or mtime no longer matches its row is left unstamped, so a
+   * write that landed since is never vouched for; the next hit restores.
+   * Written with the directory snapshots, in one transaction.
+   */
+  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
+    const rows = this.loadOutputFilesBatch([hash]).get(hash) ?? []
+    const stamps: Array<[string, number, number]> = []
+    for (const e of rows) {
+      const ws = e.path.startsWith(WORKSPACE_OUTPUT_PREFIX)
+      const abs = ws
+        ? path.join(workspaceRoot, e.path.slice(WORKSPACE_OUTPUT_PREFIX.length))
+        : path.join(projectDir, e.path)
+      try {
+        const s = statSync(abs)
+        if (
+          s.size === e.size &&
+          (s.mode & 0o777) === (e.mode & 0o777) &&
+          Math.abs(s.mtimeMs - e.mtimeMs) < 1
+        ) {
+          stamps.push([e.path, s.ino, Math.floor(s.ctimeMs)])
+        }
+      } catch {
+        // gone: left unstamped
+      }
+    }
+    if (stamps.length > 0) this.pendingStamps.set(hash, stamps)
+  }
+
+  /** Land every pending stamp and snapshot in one transaction each; a null snapshot clears its rows. */
+  flushOutputDirs(): void {
+    if (this.pendingStamps.size > 0) {
+      const stamps = [...this.pendingStamps]
+      this.pendingStamps.clear()
+      this.db.transaction(() => {
+        for (const [hash, rows] of stamps) {
+          for (const [rel, ino, ctime] of rows) this.stampOutputFile.run(ino, ctime, hash, rel)
+        }
+      })()
+    }
+    if (this.pendingDirs.size === 0) return
+    const pending = [...this.pendingDirs]
+    this.pendingDirs.clear()
     this.db.transaction(() => {
-      this.deleteOutputDirs.run(hash)
-      if (!ok) return
-      for (const [rel, mtime] of rows) this.insertOutputDir.run(hash, rel, mtime)
+      for (const [hash, rows] of pending) {
+        this.deleteOutputDirs.run(hash)
+        // The rows reference the entry: one pruned by another process
+        // between the snapshot and this flush has nothing to describe,
+        // and its insert would fail the whole transaction on the FK.
+        if (rows === null || this.entryExists.get(hash) === null) continue
+        for (const [rel, mtime] of rows) this.insertOutputDir.run(hash, rel, mtime)
+      }
     })()
   }
 
   loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
     const out = new Map<string, OutputDirRow[]>()
     if (hashes.length === 0) return out
+    // A reader in the same process (`vx watch`'s next cycle, a test) sees
+    // what was snapshotted, not what was flushed.
+    this.flushOutputDirs()
     const placeholders = hashes.map(() => '?').join(',')
     const rows = this.db
       .query(

package/src/cache/run-history.ts

@@ -16,9 +16,10 @@ export class RunHistory {
         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
+        cache_hit, attempts, cached,
+        blocked_by, timed_out, sandbox_violations, not_ready
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,  ?, ?, ?, ?, ?,  ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,  ?, ?, ?, ?, ?,  ?, ?, ?,  ?, ?, ?, ?)
     `)
     this.insertInvocation = this.db.prepare(`
       INSERT INTO invocations(
@@ -84,7 +85,7 @@ export class RunHistory {
 
 /**
  * Bind a RunRecord to the positional parameters expected by the
- * `insertRun` prepared statement (17 columns). Shared between the
+ * `insertRun` prepared statement (21 columns). Shared between the
  * single and batched record paths.
  */
 function bindRun(run: RunRecord): SQLQueryBindings[] {
@@ -108,6 +109,10 @@ function bindRun(run: RunRecord): SQLQueryBindings[] {
     run.cacheHit === undefined ? null : run.cacheHit ? 1 : 0,
     run.attempts ?? null,
     run.cached === undefined ? null : run.cached ? 1 : 0,
+    run.blockedBy ?? null,
+    run.timedOut === true ? 1 : null,
+    run.sandboxViolations ?? null,
+    run.notReady ?? null,
   ]
 }