@vzn/vx 0.0.636 → 0.0.638

package/src/cache/schema.ts

@@ -1,7 +1,7 @@
 // The index's tables, one concern: what a cache.db holds. `Cache` opens the
 // file, checks `SCHEMA_VERSION` and creates these; every statement against
-// them lives in the store that owns the table (file-hashes, config-evals,
-// output-index, history) or in cache.ts for `entries`, `entry_inputs` and
+// them lives in the store that owns the table (file-hashes, output-index,
+// history) or in cache.ts for `entries`, `entry_inputs` and
 // `artifacts`.
 
 import type { Database, SQLQueryBindings } from 'bun:sqlite'
@@ -22,7 +22,9 @@ export function lazyStatement(db: Database, sql: string): ReturnType<Database['p
 
 /**
  * Create every table. `store` names the schema holding the ENTRY tables
- * (`entries`, `entry_stdout`, `output_files`, `entry_inputs`, `store_meta`):
+ * (`entries`, `entry_stdout`, `output_files`, `entry_inputs`, `store_meta`)
+ * the task timings (`task_durations`), the flaky record (`task_outcomes`),
+ * the blob sizes (`blob_sizes`) and the plugins' blobs (`plugin_blobs`):
  * `main` when one `cache.db` holds everything (a `cacheDir`), `store` when
  * they live in the shared store attached beside it (v32). The rest is the
  * workspace's own: its history, its memos, and what its disk looked like
@@ -30,17 +32,6 @@ export function lazyStatement(db: Database, sql: string): ReturnType<Database['p
  * a statement; SQLite finds it in `main` or in `store`, whichever has it.
  */
 export function createTables(db: Database, store: 'main' | 'store' = 'main'): void {
-  // Cached config evaluations (workspace/config-cache.ts): the validated
-  // config as JSON, keyed by everything the evaluation could observe. A
-  // separate exec so the artifact schema stays byte-identical.
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS main.config_evals (
-      key        TEXT PRIMARY KEY,
-      json       TEXT NOT NULL,
-      created_at INTEGER NOT NULL
-    );
-  `)
-
   db.exec(`
     -- The queryable index: command, exit_code, duration, size and
     -- timestamps; stdout in entry_stdout below.
@@ -124,17 +115,14 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
     --   runs_ended (2026-09-09) served only the retention DELETE, which
     --     prunes on started_at now (a row ends after it starts, so the
     --     30-day window moves by at most one task's duration).
+    --   runs_failed (v38) served the flakiness probe, which reads the
+    --     store's task_outcomes now.
     DROP INDEX IF EXISTS main.runs_hash;
     DROP INDEX IF EXISTS main.runs_project;
     DROP INDEX IF EXISTS main.runs_ended;
+    DROP INDEX IF EXISTS main.runs_failed;
     CREATE INDEX IF NOT EXISTS main.runs_started_at ON runs(started_at);
     CREATE INDEX IF NOT EXISTS main.runs_run_id     ON runs(run_id);
-    -- The one keyed index, PARTIAL over failed rows: a green run's
-    -- inserts only evaluate its predicate, so the append-only cost above
-    -- holds, and the flakiness probe after a miss (failure-mode.ts,
-    -- "did this key ever fail?") reads a handful of leaves instead of
-    -- scanning the table (2026-09-10: 10–95 ms at 170k rows without it).
-    CREATE INDEX IF NOT EXISTS main.runs_failed ON runs(hash) WHERE status = 'failed';
     -- Per-file (mtime, size, content_hash) cache. Lets Cache.key()
     -- skip the content-hash on inputs whose stat hasn't changed
     -- since the last run. Pure performance optimization; the stored
@@ -152,8 +140,9 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
     -- The size of each index blob the enumeration checked against the
     -- worktree size git recorded (A-60). Fixed for its OID, so a warm
     -- run asks git for none; swept with file_hashes by seen_at, the
-    -- time the row was written.
-    CREATE TABLE IF NOT EXISTS main.blob_sizes (
+    -- time the row was written. v38: in the store, so a worktree reads
+    -- what another learned (owner, 2026-10-14).
+    CREATE TABLE IF NOT EXISTS ${store}.blob_sizes (
       oid     TEXT PRIMARY KEY,
       size    INTEGER NOT NULL,
       seen_at INTEGER NOT NULL
@@ -197,15 +186,6 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       ctime_ms    INTEGER NOT NULL,
       PRIMARY KEY (entry_hash, path)
     );
-    -- Each config's ORDERED import closure (the config first), so a warm
-    -- load keys it by stat-hashing the list (the file_hashes memo) instead
-    -- of reading and scanning every file. Machine-local; pruned with
-    -- config_evals (2026-09-03).
-    CREATE TABLE IF NOT EXISTS main.config_closures (
-      config_path TEXT PRIMARY KEY,
-      files_json  TEXT NOT NULL,
-      created_at  INTEGER NOT NULL
-    );
     -- Every directory under a whole-subtree output glob, with its mtime
     -- as of the last save/restore on THIS machine (2026-09-03). On a warm
     -- hit, unchanged mtimes prove the output SET is unchanged, replacing
@@ -277,6 +257,53 @@ export function createTables(db: Database, store: 'main' | 'store' = 'main'): vo
       key   TEXT PRIMARY KEY,
       value TEXT NOT NULL
     );
+    -- What a duration forecast reads (orchestrator/history.ts), one row per
+    -- executed success, shared by every worktree of the repo so a new one
+    -- forecasts on its first run (owner, 2026-10-14). Append-only: never
+    -- updated, pruned by age with the run history. \`source\` tags a local
+    -- run 'branch:<name>' ('branch:' detached or outside git); \`sha\` is its
+    -- commit. A forecast reads a task's newest rows of one source.
+    CREATE TABLE IF NOT EXISTS ${store}.task_durations (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      project     TEXT NOT NULL,
+      task        TEXT NOT NULL,
+      source      TEXT NOT NULL,
+      sha         TEXT,
+      duration_ms INTEGER NOT NULL,
+      recorded_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS ${store}.task_durations_task
+      ON task_durations(project, task, source, id);
+    -- v37: a 'remote' row is a default-branch commit's timing a plugin
+    -- imported (\`sha\` that commit): one per task, so a repeat import is a
+    -- no-op under INSERT OR IGNORE.
+    CREATE UNIQUE INDEX IF NOT EXISTS ${store}.task_durations_remote
+      ON task_durations(sha, project, task) WHERE source = 'remote';
+    -- v38: the flaky record (orchestrator/failure-mode.ts): each keyed,
+    -- cached, unblocked outcome that observed its key, shared by every
+    -- worktree so a key that passed in one and failed in another is flaky
+    -- in both (owner, 2026-10-14). Every executed success or failure, and
+    -- a key's first hit (run-history.ts): a later hit replays a pass the
+    -- record holds, so a warm run on keys that passed writes no row.
+    -- Append-only, ordered by id, pruned by age with the run history.
+    CREATE TABLE IF NOT EXISTS ${store}.task_outcomes (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      project     TEXT NOT NULL,
+      task        TEXT NOT NULL,
+      hash        TEXT NOT NULL,
+      status      TEXT NOT NULL,
+      attempts    INTEGER,
+      recorded_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS ${store}.task_outcomes_hash ON task_outcomes(hash, status);
+    -- v37: what a plugin keeps through \`ctx.cache\` (plugin-cache.ts), by
+    -- its namespaced key. Written once, never updated; pruned by age with
+    -- the run history.
+    CREATE TABLE IF NOT EXISTS ${store}.plugin_blobs (
+      key   TEXT PRIMARY KEY,
+      bytes BLOB NOT NULL,
+      at    INTEGER NOT NULL
+    );
     ${artifactTables(store)}
   `)
 }

package/src/cache/scoped-cache.ts

@@ -0,0 +1,237 @@
+// The run's `cache.scope` over every layer at once (owner, 2026-10-14): a
+// scoped run reads the default key, then the scope's, and writes only the
+// scope's, in the local store and every remote alike. Below this wrapper no
+// layer knows a scope exists: the scope's key is a key like any other.
+
+import { xxh3hex } from '../util/index.js'
+import type {
+  CacheEntry,
+  CacheGetContext,
+  CacheLayer,
+  IngestMeta,
+  InvocationRecord,
+  OutputDirRow,
+  RunRecord,
+  SaveArgs,
+} from './layer.js'
+
+/** The key a scope stores `hash` under: task-key shaped, 16 hex, so every wire stores it unchanged. */
+export function scopedKey(scope: string, hash: string): string {
+  return xxh3hex(`vx-cache-scope\0${scope}\0${hash}`)
+}
+
+/**
+ * A layer as a scoped run sees it. Callers speak task keys; each answer is
+ * remembered under the key that served it (the default key on a default hit,
+ * the scope's on a scope hit or a save), so the restore, the output index and
+ * the run's history all reach the entry that answered. An artifact records
+ * the key it was packed under and ingest refuses another, so a derived-key
+ * collision degrades to a miss. A default artifact a remote ingest refuses is
+ * a miss there, and the scope's key is asked next (Security F6).
+ */
+export class ScopedCache implements CacheLayer {
+  readonly local?: CacheLayer['local']
+  readonly hasRemote?: boolean
+  readonly drainUploads?: () => Promise<void>
+  readonly remoteHasMany?: (hashes: readonly string[]) => Promise<Set<string> | null>
+  readonly getMany?: (
+    hashes: readonly string[],
+    ctx?: (hash: string) => CacheGetContext,
+  ) => Promise<Map<string, CacheEntry>>
+  /** Task key → the key that answers for it this run. */
+  private readonly served = new Map<string, string>()
+
+  constructor(
+    private readonly inner: CacheLayer,
+    private readonly scope: string,
+  ) {
+    if (inner.local !== undefined) this.local = inner.local
+    if (inner.hasRemote !== undefined) this.hasRemote = inner.hasRemote
+    if (inner.drainUploads !== undefined) this.drainUploads = () => inner.drainUploads!()
+    if (inner.remoteHasMany !== undefined) this.remoteHasMany = (h) => this.scopedHasMany(h)
+    if (inner.getMany !== undefined) this.getMany = (h, ctx) => this.scopedGetMany(h, ctx)
+  }
+
+  private own(hash: string): string {
+    return scopedKey(this.scope, hash)
+  }
+
+  private keyOf(hash: string): string {
+    return this.served.get(hash) ?? hash
+  }
+
+  /** A batch keyed by served keys, keyed back by task key. */
+  private batch<T>(
+    hashes: readonly string[],
+    read: (keys: string[]) => Map<string, T>,
+  ): Map<string, T> {
+    const keys = hashes.map((h) => this.keyOf(h))
+    const found = read(keys)
+    const out = new Map<string, T>()
+    for (let i = 0; i < hashes.length; i++) {
+      const v = found.get(keys[i]!)
+      if (v !== undefined) out.set(hashes[i]!, v)
+    }
+    return out
+  }
+
+  /** A task key the store holds under the default key or the scope's. */
+  async localHasMany(hashes: readonly string[]): Promise<Set<string>> {
+    const held = await this.inner.localHasMany?.([...hashes, ...hashes.map((h) => this.own(h))])
+    if (held === undefined) return new Set()
+    return new Set(hashes.filter((h) => held.has(h) || held.has(this.own(h))))
+  }
+
+  private async scopedHasMany(hashes: readonly string[]): Promise<Set<string> | null> {
+    const scoped = hashes.map((h) => this.own(h))
+    const [plain, own] = await Promise.all([
+      this.inner.remoteHasMany!(hashes),
+      this.inner.remoteHasMany!(scoped),
+    ])
+    if (plain == null || own == null) return null
+    const found = new Set(plain)
+    const scopeOnly: string[] = []
+    for (let i = 0; i < hashes.length; i++) {
+      if (plain.has(hashes[i]!) || !own.has(scoped[i]!)) continue
+      found.add(hashes[i]!)
+      scopeOnly.push(hashes[i]!)
+    }
+    // Their default key is known absent: its GET is skipped.
+    this.inner.markRemoteAbsent?.(scopeOnly)
+    return found
+  }
+
+  markRemoteAbsent(hashes: Iterable<string>): void {
+    const all: string[] = []
+    for (const h of hashes) all.push(h, this.own(h))
+    this.inner.markRemoteAbsent?.(all)
+  }
+
+  key(input: Parameters<CacheLayer['key']>[0]): Promise<string> {
+    return this.inner.key(input)
+  }
+
+  async get(hash: string, ctx?: CacheGetContext): Promise<CacheEntry | null> {
+    // The scope's key first when only it is local: the default key's
+    // remote GET would cost a round-trip for the same inputs.
+    const own = this.own(hash)
+    const keys = (await this.inner.localHasMany?.([hash, own]))?.has(own)
+      ? [own, hash]
+      : [hash, own]
+    for (const key of keys) {
+      const entry = await this.inner.get(key, ctx)
+      if (entry === null) continue
+      this.served.set(hash, key)
+      return key === hash ? entry : { ...entry, hash }
+    }
+    return null
+  }
+
+  private async scopedGetMany(
+    hashes: readonly string[],
+    ctx?: (hash: string) => CacheGetContext,
+  ): Promise<Map<string, CacheEntry>> {
+    const out = await this.inner.getMany!(hashes, ctx)
+    for (const h of out.keys()) this.served.set(h, h)
+    const rest = hashes.filter((h) => !out.has(h))
+    if (rest.length === 0) return out
+    const byOwn = new Map(rest.map((h) => [this.own(h), h]))
+    const scoped = await this.inner.getMany!(
+      [...byOwn.keys()],
+      ctx === undefined ? undefined : (key) => ctx(byOwn.get(key)!),
+    )
+    for (const [key, entry] of scoped) {
+      const hash = byOwn.get(key)!
+      this.served.set(hash, key)
+      out.set(hash, { ...entry, hash })
+    }
+    return out
+  }
+
+  async has(hash: string): Promise<'local' | 'remote' | null> {
+    return (await this.inner.has(hash)) ?? (await this.inner.has(this.own(hash)))
+  }
+
+  async prefetch(hash: string, ctx?: CacheGetContext): Promise<boolean> {
+    return (await this.inner.prefetch(hash, ctx)) || this.inner.prefetch(this.own(hash), ctx)
+  }
+
+  loadOutputFilesBatch(hashes: readonly string[]): ReturnType<CacheLayer['loadOutputFilesBatch']> {
+    return this.batch(hashes, (keys) => this.inner.loadOutputFilesBatch(keys))
+  }
+
+  isOutputsCurrent(
+    ...args: Parameters<CacheLayer['isOutputsCurrent']>
+  ): ReturnType<CacheLayer['isOutputsCurrent']> {
+    return this.inner.isOutputsCurrent(...args)
+  }
+
+  async recordOutputDirs(
+    hash: string,
+    projectDir: string,
+    prefixes: readonly string[],
+    holds?: (files: readonly string[]) => boolean,
+  ): Promise<void> {
+    await this.inner.recordOutputDirs?.(this.keyOf(hash), projectDir, prefixes, holds)
+  }
+
+  recordOutputStamps(hash: string, projectDir: string, workspaceRoot: string): void {
+    this.inner.recordOutputStamps?.(this.keyOf(hash), projectDir, workspaceRoot)
+  }
+
+  loadOutputDirsBatch(hashes: readonly string[]): Map<string, OutputDirRow[]> {
+    return this.batch(hashes, (keys) => this.inner.loadOutputDirsBatch?.(keys) ?? new Map())
+  }
+
+  async outputDirsCurrent(projectDir: string, rows: readonly OutputDirRow[]): Promise<boolean> {
+    return (await this.inner.outputDirsCurrent?.(projectDir, rows)) ?? false
+  }
+
+  restoreOutputs(hash: string, projectDir: string, workspaceRoot?: string): Promise<void> {
+    return this.inner.restoreOutputs(this.keyOf(hash), projectDir, workspaceRoot)
+  }
+
+  save(args: SaveArgs): Promise<void> {
+    const key = this.own(args.hash)
+    this.served.set(args.hash, key)
+    return this.inner.save({ ...args, hash: key })
+  }
+
+  ingest(hash: string, body: Blob | Response, meta: IngestMeta): Promise<void> {
+    const key = this.own(hash)
+    this.served.set(hash, key)
+    return this.inner.ingest(key, body, meta)
+  }
+
+  /** History names the key that answered, so `vx why` reads that entry's components. */
+  recordRunBundle(bundle: { runs: readonly RunRecord[]; invocation: InvocationRecord }): void {
+    this.inner.recordRunBundle({
+      ...bundle,
+      runs: bundle.runs.map((r) => (r.hash === undefined ? r : { ...r, hash: this.keyOf(r.hash) })),
+    })
+  }
+
+  stats(...args: Parameters<CacheLayer['stats']>): ReturnType<CacheLayer['stats']> {
+    return this.inner.stats(...args)
+  }
+
+  hashFile(filePath: string): Promise<string> {
+    return this.inner.hashFile(filePath)
+  }
+
+  outputsPath(hash: string): string {
+    return this.inner.outputsPath(this.keyOf(hash))
+  }
+
+  artifactSize(hash: string): number | undefined {
+    return this.inner.artifactSize?.(this.keyOf(hash))
+  }
+
+  prune(...args: Parameters<CacheLayer['prune']>): ReturnType<CacheLayer['prune']> {
+    return this.inner.prune(...args)
+  }
+
+  close(): void {
+    this.inner.close()
+  }
+}