opensquid 0.5.395

package/dist/runtime/durable/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Durable execution module barrel (DURABLE.1 + DURABLE.2 + DURABLE.3 + DURABLE.4).
+ *
+ * Public surface:
+ *
+ *   CheckpointStore        — libsql-backed per-primitive checkpoint persistence
+ *                            + run-manifest + terminal-marker tables (DURABLE.4)
+ *   CheckpointWrite        — append() arg shape
+ *   CheckpointRow          — row read back from the store
+ *   RunManifest            — manifest written by the rule dispatcher at run-start
+ *   InterruptedSummary     — scanInterrupted() row (one per resumable run)
+ *   runIdFor               — deterministic SHA-256 over run identity
+ *   RunIdInput             — runIdFor input shape
+ *   canonicalJsonStringify — sorted-key JSON with Date/Buffer envelopes
+ *   canonicalJsonParse     — inverse, rehydrates base64 envelopes to Buffers
+ *   MemoCache              — two-tier (LRU + libsql) memoization with singleflight
+ *   MemoHit                — wrapper that disambiguates cached `null` from miss
+ *   MemoStats              — per-primitive hit / size rows
+ *   MemoCacheOpts          — construction options (memoryMax, nowMs)
+ *   Resumer                — scans interrupted runs + resumes from last completed step
+ *   InterruptedRun         — Resumer's per-run input shape (joined manifest + summary)
+ *   RuleResolver           — callback that resolves (packId, skill, ruleId) → process steps
+ *   RunEvaluator           — callback that runs the evaluator for a resume pass
+ *   ResumeAuditSink        — audit log surface for resume decisions
+ *
+ * DURABLE.1 ships storage; DURABLE.2 wires the evaluator wrap; DURABLE.3
+ * adds memoization on identical primitive inputs; DURABLE.4 adds the
+ * Resumer + restart-safe daemon hook so interrupted runs replay from
+ * their last completed step on the next daemon boot.
+ */
+export { CheckpointStore, type CheckpointRow, type CheckpointWrite, type InterruptedSummary, type RunManifest, } from './checkpoint_store.js';
+export { runIdFor, sha256Hex, type RunIdInput } from './run_id.js';
+export { canonicalJsonStringify, canonicalJsonParse } from './canonical_json.js';
+export { MemoCache, type MemoHit, type MemoStats, type MemoCacheOpts } from './memo_cache.js';
+export { Resumer, DEFAULT_RESUME_WINDOW_MS, type AuditEntry as ResumeAuditEntry, type AuditSink as ResumeAuditSink, type InterruptedRun, type ResolvedRule, type ResumeOpts, type ResumeResult, type ResumeStartupResult, type RuleResolver, type RunEvaluator, type RunEvaluatorInput, type SkipReason as ResumeSkipReason, } from './resumer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/durable/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/durable/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,WAAW,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,KAAK,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EACL,OAAO,EACP,wBAAwB,EACxB,KAAK,UAAU,IAAI,gBAAgB,EACnC,KAAK,SAAS,IAAI,eAAe,EACjC,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,UAAU,IAAI,gBAAgB,GACpC,MAAM,cAAc,CAAC"}

package/dist/runtime/durable/index.js

@@ -0,0 +1,36 @@
+/**
+ * Durable execution module barrel (DURABLE.1 + DURABLE.2 + DURABLE.3 + DURABLE.4).
+ *
+ * Public surface:
+ *
+ *   CheckpointStore        — libsql-backed per-primitive checkpoint persistence
+ *                            + run-manifest + terminal-marker tables (DURABLE.4)
+ *   CheckpointWrite        — append() arg shape
+ *   CheckpointRow          — row read back from the store
+ *   RunManifest            — manifest written by the rule dispatcher at run-start
+ *   InterruptedSummary     — scanInterrupted() row (one per resumable run)
+ *   runIdFor               — deterministic SHA-256 over run identity
+ *   RunIdInput             — runIdFor input shape
+ *   canonicalJsonStringify — sorted-key JSON with Date/Buffer envelopes
+ *   canonicalJsonParse     — inverse, rehydrates base64 envelopes to Buffers
+ *   MemoCache              — two-tier (LRU + libsql) memoization with singleflight
+ *   MemoHit                — wrapper that disambiguates cached `null` from miss
+ *   MemoStats              — per-primitive hit / size rows
+ *   MemoCacheOpts          — construction options (memoryMax, nowMs)
+ *   Resumer                — scans interrupted runs + resumes from last completed step
+ *   InterruptedRun         — Resumer's per-run input shape (joined manifest + summary)
+ *   RuleResolver           — callback that resolves (packId, skill, ruleId) → process steps
+ *   RunEvaluator           — callback that runs the evaluator for a resume pass
+ *   ResumeAuditSink        — audit log surface for resume decisions
+ *
+ * DURABLE.1 ships storage; DURABLE.2 wires the evaluator wrap; DURABLE.3
+ * adds memoization on identical primitive inputs; DURABLE.4 adds the
+ * Resumer + restart-safe daemon hook so interrupted runs replay from
+ * their last completed step on the next daemon boot.
+ */
+export { CheckpointStore, } from './checkpoint_store.js';
+export { runIdFor, sha256Hex } from './run_id.js';
+export { canonicalJsonStringify, canonicalJsonParse } from './canonical_json.js';
+export { MemoCache } from './memo_cache.js';
+export { Resumer, DEFAULT_RESUME_WINDOW_MS, } from './resumer.js';
+//# sourceMappingURL=index.js.map

package/dist/runtime/durable/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/durable/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EACL,eAAe,GAKhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAmB,MAAM,aAAa,CAAC;AACnE,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAAE,SAAS,EAAoD,MAAM,iBAAiB,CAAC;AAC9F,OAAO,EACL,OAAO,EACP,wBAAwB,GAYzB,MAAM,cAAc,CAAC"}

package/dist/runtime/durable/memo_cache.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Memoization cache for primitive outputs (DURABLE.3).
+ *
+ * Primitives that declare `memoizable: true` (DURABLE.2) cache outputs keyed
+ * by `(fn, inputs_hash)`. Identical inputs → cached output, primitive not
+ * invoked. The evaluator wraps the cache check around `invokeDurable`'s
+ * checkpoint-restore branch: a checkpoint hit (same run, same step) still
+ * wins; a memo hit serves cross-run replays of identical-input calls.
+ *
+ * Two-tier design:
+ *
+ *   Memory tier (`LRUCache<string, MemoryEntry>`): hot, ~1000 entries cap,
+ *   per-entry TTL via the entry's `expiresAtMs`. Sub-millisecond hit; rebuilt
+ *   on demand from the persistent tier after a daemon restart.
+ *
+ *   libsql tier (`memo_cache` table): persistent across daemon restarts.
+ *   `idx_memo_cached_at` indexes age for the prune verb. Outputs round-trip
+ *   through `canonical_json` so Date/Buffer survive (same envelope rules as
+ *   DURABLE.1's checkpoint store).
+ *
+ * Singleflight (in-flight Promise dedup):
+ *
+ *   A cache stampede — 100 concurrent calls for the same miss → 100 primitive
+ *   invocations — defeats the whole point. `get()` keeps an `inflight` map
+ *   keyed by the same `${fn}::${inputsHash}` string. When N callers race on a
+ *   miss, the FIRST caller's `set()` writes the entry and clears the inflight
+ *   record; the remaining N-1 callers await the same Promise and read from
+ *   the cache once it settles. The runtime caller pattern is:
+ *
+ *     const cached = await cache.get(fn, hash, ttl);
+ *     if (cached !== null) return cached.value;
+ *     return cache.singleflight(fn, hash, async () => {
+ *       const fresh = await invokePrimitive();
+ *       await cache.set(fn, hash, fresh, ttl);
+ *       return fresh;
+ *     });
+ *
+ *   That keeps singleflight orthogonal to the cache lookup: a clean caller
+ *   can opt out (e.g. tests verifying miss-path semantics) by skipping
+ *   `singleflight()` and calling the primitive directly.
+ *
+ * TTL policy:
+ *
+ *   Caller provides a `ttlMs?: number` to both `get()` and `set()`. When
+ *   omitted, the entry has NO TTL (lives until evicted by LRU or cleared by
+ *   `clear({fn,olderThanMs})`). The runtime wrap (evaluator) uses the
+ *   per-primitive class defaults below; the cache itself is policy-free.
+ *
+ *     LLM (llm_classify):        3_600_000  ( 1h)
+ *     RAG (recall, embed):         300_000  ( 5m)
+ *     http_request:                 30_000  (30s)
+ *     check_destination:          3_600_000  ( 1h)
+ *
+ *   These match the spec's risk-callout for stale outputs in state-sensitive
+ *   primitives and are tuned to be conservative (RAG indexes change often;
+ *   HTTP responses are the most volatile; LLM classifications on the same
+ *   prompt+model+temperature are stable enough for an hour).
+ *
+ * Privacy / PII:
+ *
+ *   Cached prompts MAY contain PII — `llm_classify` args carry whatever the
+ *   pack passes in, which can include user emails, file contents, names.
+ *   Two mitigations:
+ *
+ *     1. The persistent tier stores `outputs_json` AND `inputs_hash` (the
+ *        hash of inputs, not the raw inputs themselves). Inputs are never
+ *        persisted in this module. The hash is sha256, non-reversible.
+ *
+ *     2. Pack authors who handle sensitive payloads should set
+ *        `cached_at_ms TTL ≤ pack sensitivity threshold` — the cache
+ *        enforces TTL, the pack chooses the threshold. The pack-declared
+ *        sensitivity threshold work lives in a later track (privacy.md is
+ *        not in scope for DURABLE.3); until then, callers pass conservative
+ *        TTLs and rely on `clear()` for explicit purges.
+ *
+ * Imports from: @libsql/client, lru-cache, ./canonical_json.js.
+ * Imported by: evaluator (DURABLE.3 wrap), future `opensquid cache` CLI.
+ */
+import type { Client } from '@libsql/client';
+export interface MemoStats {
+    fn: string;
+    hits: number;
+    size: number;
+}
+export interface MemoCacheOpts {
+    /** Max entries in the memory tier. Default 1000. */
+    memoryMax?: number;
+    /** Injected clock; defaults to `Date.now`. */
+    nowMs?: () => number;
+}
+export declare class MemoCache {
+    private readonly db;
+    private readonly memory;
+    private readonly inflight;
+    private readonly nowMs;
+    private initialized;
+    constructor(db: Client, opts?: MemoCacheOpts);
+    /**
+     * Idempotent DDL. Safe to call repeatedly; only the first call hits
+     * libsql. Same posture as `CheckpointStore.init` and `RateLimiter.init`.
+     */
+    init(): Promise<void>;
+    /**
+     * Two-tier lookup.
+     *
+     *   1. Memory hit + not expired → return value.
+     *   2. Memory miss → libsql lookup.
+     *   3. Libsql hit + not expired → bump hit_count, restore to memory tier,
+     *      return value.
+     *   4. Otherwise → null (miss).
+     *
+     * `ttlMs` is the CALLER's TTL contract. When the persistent row has its
+     * OWN `ttl_ms` set, that value is authoritative — the row's TTL was the
+     * one in effect at `set()` time, and re-interpreting it under a different
+     * TTL at read time would silently extend or shrink the entry's lifetime.
+     * The `ttlMs` parameter on `get()` is only used when the row has a NULL
+     * `ttl_ms` AND the caller wants to retroactively bound an indefinite
+     * entry (rare; supplied for symmetry with `set()`).
+     *
+     * Returns the cached value (which may be `null`-as-cached-output — the
+     * spec stores the primitive's return value verbatim, so a primitive that
+     * legitimately returned `null` would store `null`; we wrap the hit/miss
+     * signal in the return type's nullability convention by distinguishing
+     * `null` (miss) from a wrapped value (hit).
+     *
+     * Convention: callers should check `=== null` for miss. A primitive that
+     * really returned `null` ends up encoded as the JSON `null` string in the
+     * persistent tier, and on read we return a wrapper to disambiguate — see
+     * the `MemoHit` type below.
+     */
+    get(fn: string, inputsHash: string, ttlMs?: number): Promise<MemoHit | null>;
+    /**
+     * Write both tiers. Memory first (cheap, in-process), then libsql (the
+     * source of truth across restarts). `INSERT OR REPLACE` keeps the write
+     * idempotent: the same `(fn, inputs_hash)` written twice in a row
+     * preserves the latest output and resets `cached_at_ms` to the new write
+     * time. `hit_count` is reset to 0 because the entry is logically new.
+     *
+     * When `ttlMs` is omitted (or explicitly `undefined`), the persistent row
+     * stores `NULL` — no expiry; the entry lives until evicted by LRU
+     * pressure or removed by `clear()`.
+     */
+    set(fn: string, inputsHash: string, outputs: unknown, ttlMs?: number): Promise<void>;
+    /**
+     * Singleflight: dedup concurrent misses on the same key. The first caller
+     * runs `compute()`; subsequent callers await the same Promise. The
+     * inflight record is removed in `finally` so a failure on the first
+     * caller doesn't poison the key forever.
+     *
+     * Important: this method does NOT itself cache the result — `compute()`
+     * is expected to call `set()` after the primitive returns. The wrap
+     * pattern is documented in the file header.
+     *
+     * Returning `unknown` keeps the API substrate-shaped: the runtime caller
+     * casts to the primitive's return type once the FunctionRegistry has
+     * confirmed args + output handling.
+     */
+    singleflight<T>(fn: string, inputsHash: string, compute: () => Promise<T>): Promise<T>;
+    /**
+     * Invalidate cache entries. Both tiers honored.
+     *
+     *   - `{}`                       → wipe everything.
+     *   - `{ fn: 'llm_classify' }`   → wipe all llm_classify entries.
+     *   - `{ olderThanMs: 7 * 86_400_000 }` → wipe entries cached more than
+     *      7 days ago.
+     *   - `{ fn, olderThanMs }`      → AND of both predicates.
+     *
+     * Returns the number of persistent-tier rows removed. The memory tier's
+     * affected-count is not surfaced (the LRU might have already evicted the
+     * row, in which case "removed" is undefined; callers care about durable
+     * cleanup).
+     */
+    clear(opts?: {
+        fn?: string;
+        olderThanMs?: number;
+    }): Promise<number>;
+    /**
+     * Per-primitive stats: hit_count totals + live row counts. Powers the
+     * future `opensquid cache stats` CLI verb.
+     *
+     * Expired rows are excluded from `size` — the count reflects rows that
+     * would actually serve traffic today. The persistent table is NOT
+     * compacted as a side effect of this call; the GC verb is `clear()` with
+     * an `olderThanMs` argument.
+     */
+    stats(): Promise<MemoStats[]>;
+}
+/**
+ * Hit envelope. Distinguishes a real cached `null` (a primitive that
+ * returned null and stored it) from a miss (`get` returns `null` itself).
+ */
+export interface MemoHit {
+    value: unknown;
+}
+//# sourceMappingURL=memo_cache.d.ts.map

package/dist/runtime/durable/memo_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo_cache.d.ts","sourceRoot":"","sources":["../../../src/runtime/durable/memo_cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AA8B7C,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAsCD,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,KAAK,CAAC,EAAE,MAAM,MAAM,CAAC;CACtB;AAED,qBAAa,SAAS;IAOlB,OAAO,CAAC,QAAQ,CAAC,EAAE;IANrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuC;IAChE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,WAAW,CAAS;gBAGT,EAAE,EAAE,MAAM,EAC3B,IAAI,GAAE,aAAkB;IAQ1B;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IA2DlF;;;;;;;;;;OAUG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB1F;;;;;;;;;;;;;OAaG;IACG,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAa5F;;;;;;;;;;;;;OAaG;IACG,KAAK,CAAC,IAAI,GAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IA2C9E;;;;;;;;OAQG;IACG,KAAK,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;CAsBpC;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,OAAO,CAAC;CAChB"}

package/dist/runtime/durable/memo_cache.js

@@ -0,0 +1,364 @@
+/**
+ * Memoization cache for primitive outputs (DURABLE.3).
+ *
+ * Primitives that declare `memoizable: true` (DURABLE.2) cache outputs keyed
+ * by `(fn, inputs_hash)`. Identical inputs → cached output, primitive not
+ * invoked. The evaluator wraps the cache check around `invokeDurable`'s
+ * checkpoint-restore branch: a checkpoint hit (same run, same step) still
+ * wins; a memo hit serves cross-run replays of identical-input calls.
+ *
+ * Two-tier design:
+ *
+ *   Memory tier (`LRUCache<string, MemoryEntry>`): hot, ~1000 entries cap,
+ *   per-entry TTL via the entry's `expiresAtMs`. Sub-millisecond hit; rebuilt
+ *   on demand from the persistent tier after a daemon restart.
+ *
+ *   libsql tier (`memo_cache` table): persistent across daemon restarts.
+ *   `idx_memo_cached_at` indexes age for the prune verb. Outputs round-trip
+ *   through `canonical_json` so Date/Buffer survive (same envelope rules as
+ *   DURABLE.1's checkpoint store).
+ *
+ * Singleflight (in-flight Promise dedup):
+ *
+ *   A cache stampede — 100 concurrent calls for the same miss → 100 primitive
+ *   invocations — defeats the whole point. `get()` keeps an `inflight` map
+ *   keyed by the same `${fn}::${inputsHash}` string. When N callers race on a
+ *   miss, the FIRST caller's `set()` writes the entry and clears the inflight
+ *   record; the remaining N-1 callers await the same Promise and read from
+ *   the cache once it settles. The runtime caller pattern is:
+ *
+ *     const cached = await cache.get(fn, hash, ttl);
+ *     if (cached !== null) return cached.value;
+ *     return cache.singleflight(fn, hash, async () => {
+ *       const fresh = await invokePrimitive();
+ *       await cache.set(fn, hash, fresh, ttl);
+ *       return fresh;
+ *     });
+ *
+ *   That keeps singleflight orthogonal to the cache lookup: a clean caller
+ *   can opt out (e.g. tests verifying miss-path semantics) by skipping
+ *   `singleflight()` and calling the primitive directly.
+ *
+ * TTL policy:
+ *
+ *   Caller provides a `ttlMs?: number` to both `get()` and `set()`. When
+ *   omitted, the entry has NO TTL (lives until evicted by LRU or cleared by
+ *   `clear({fn,olderThanMs})`). The runtime wrap (evaluator) uses the
+ *   per-primitive class defaults below; the cache itself is policy-free.
+ *
+ *     LLM (llm_classify):        3_600_000  ( 1h)
+ *     RAG (recall, embed):         300_000  ( 5m)
+ *     http_request:                 30_000  (30s)
+ *     check_destination:          3_600_000  ( 1h)
+ *
+ *   These match the spec's risk-callout for stale outputs in state-sensitive
+ *   primitives and are tuned to be conservative (RAG indexes change often;
+ *   HTTP responses are the most volatile; LLM classifications on the same
+ *   prompt+model+temperature are stable enough for an hour).
+ *
+ * Privacy / PII:
+ *
+ *   Cached prompts MAY contain PII — `llm_classify` args carry whatever the
+ *   pack passes in, which can include user emails, file contents, names.
+ *   Two mitigations:
+ *
+ *     1. The persistent tier stores `outputs_json` AND `inputs_hash` (the
+ *        hash of inputs, not the raw inputs themselves). Inputs are never
+ *        persisted in this module. The hash is sha256, non-reversible.
+ *
+ *     2. Pack authors who handle sensitive payloads should set
+ *        `cached_at_ms TTL ≤ pack sensitivity threshold` — the cache
+ *        enforces TTL, the pack chooses the threshold. The pack-declared
+ *        sensitivity threshold work lives in a later track (privacy.md is
+ *        not in scope for DURABLE.3); until then, callers pass conservative
+ *        TTLs and rely on `clear()` for explicit purges.
+ *
+ * Imports from: @libsql/client, lru-cache, ./canonical_json.js.
+ * Imported by: evaluator (DURABLE.3 wrap), future `opensquid cache` CLI.
+ */
+import { LRUCache } from 'lru-cache';
+import { canonicalJsonParse, canonicalJsonStringify } from './canonical_json.js';
+// ---------------------------------------------------------------------------
+// Schema — `memo_cache` table + `idx_memo_cached_at` index.
+//
+// `CREATE TABLE IF NOT EXISTS` matches the AUTO.2 RateLimiter migration
+// pattern: idempotent DDL, applied at first call to `init()`. No versioned
+// migration framework in opensquid yet.
+//
+// `outputs_json TEXT NOT NULL` — `canonical_json` produces a deterministic
+// string; we never store NULL outputs (a primitive that succeeded with
+// `null` serializes to the JSON string `'null'`, which is fine).
+//
+// `ttl_ms INTEGER` is nullable: NULL means "no TTL, lives until clear()".
+// ---------------------------------------------------------------------------
+const CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS memo_cache (
+    fn TEXT NOT NULL,
+    inputs_hash TEXT NOT NULL,
+    outputs_json TEXT NOT NULL,
+    cached_at_ms INTEGER NOT NULL,
+    ttl_ms INTEGER,
+    hit_count INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (fn, inputs_hash)
+  );
+`;
+const CREATE_INDEX_CACHED_AT_SQL = `
+  CREATE INDEX IF NOT EXISTS idx_memo_cached_at ON memo_cache(cached_at_ms);
+`;
+export class MemoCache {
+    db;
+    memory;
+    inflight = new Map();
+    nowMs;
+    initialized = false;
+    constructor(db, opts = {}) {
+        this.db = db;
+        this.memory = new LRUCache({
+            max: opts.memoryMax ?? 1000,
+        });
+        this.nowMs = opts.nowMs ?? Date.now;
+    }
+    /**
+     * Idempotent DDL. Safe to call repeatedly; only the first call hits
+     * libsql. Same posture as `CheckpointStore.init` and `RateLimiter.init`.
+     */
+    async init() {
+        if (this.initialized)
+            return;
+        await this.db.execute(CREATE_TABLE_SQL);
+        await this.db.execute(CREATE_INDEX_CACHED_AT_SQL);
+        this.initialized = true;
+    }
+    /**
+     * Two-tier lookup.
+     *
+     *   1. Memory hit + not expired → return value.
+     *   2. Memory miss → libsql lookup.
+     *   3. Libsql hit + not expired → bump hit_count, restore to memory tier,
+     *      return value.
+     *   4. Otherwise → null (miss).
+     *
+     * `ttlMs` is the CALLER's TTL contract. When the persistent row has its
+     * OWN `ttl_ms` set, that value is authoritative — the row's TTL was the
+     * one in effect at `set()` time, and re-interpreting it under a different
+     * TTL at read time would silently extend or shrink the entry's lifetime.
+     * The `ttlMs` parameter on `get()` is only used when the row has a NULL
+     * `ttl_ms` AND the caller wants to retroactively bound an indefinite
+     * entry (rare; supplied for symmetry with `set()`).
+     *
+     * Returns the cached value (which may be `null`-as-cached-output — the
+     * spec stores the primitive's return value verbatim, so a primitive that
+     * legitimately returned `null` would store `null`; we wrap the hit/miss
+     * signal in the return type's nullability convention by distinguishing
+     * `null` (miss) from a wrapped value (hit).
+     *
+     * Convention: callers should check `=== null` for miss. A primitive that
+     * really returned `null` ends up encoded as the JSON `null` string in the
+     * persistent tier, and on read we return a wrapper to disambiguate — see
+     * the `MemoHit` type below.
+     */
+    async get(fn, inputsHash, ttlMs) {
+        const key = cacheKey(fn, inputsHash);
+        const now = this.nowMs();
+        // 1. Memory tier.
+        const mem = this.memory.get(key);
+        if (mem !== undefined) {
+            if (mem.expiresAtMs === null || mem.expiresAtMs > now) {
+                return { value: mem.value };
+            }
+            // Stale memory entry — drop it; fall through to libsql in case the
+            // persistent tier has been refreshed by another process.
+            this.memory.delete(key);
+        }
+        // 2. libsql tier.
+        await this.init();
+        const rs = await this.db.execute({
+            sql: `SELECT outputs_json, cached_at_ms, ttl_ms
+            FROM memo_cache
+            WHERE fn = ? AND inputs_hash = ?`,
+            args: [fn, inputsHash],
+        });
+        const row = rs.rows[0];
+        if (!row)
+            return null;
+        const cachedAtMs = Number(row.cached_at_ms);
+        const rowTtlRaw = row.ttl_ms;
+        const rowTtlMs = rowTtlRaw === null || rowTtlRaw === undefined ? null : Number(rowTtlRaw);
+        // When the row has its own TTL, that's authoritative. Otherwise fall
+        // back to the caller's optional `ttlMs`.
+        const effectiveTtlMs = rowTtlMs ?? ttlMs ?? null;
+        const expiresAtMs = effectiveTtlMs === null ? null : cachedAtMs + effectiveTtlMs;
+        if (expiresAtMs !== null && expiresAtMs <= now) {
+            // Expired in libsql tier — delete it so we don't carry a tombstone.
+            await this.db.execute({
+                sql: `DELETE FROM memo_cache WHERE fn = ? AND inputs_hash = ?`,
+                args: [fn, inputsHash],
+            });
+            return null;
+        }
+        // 3. Libsql hit — bump hit_count + restore memory. libsql columns can
+        // round-trip as `string | number | ArrayBuffer | bigint | null`; the
+        // `TEXT NOT NULL` constraint pins this one to string but the driver's
+        // type union is wider, so we narrow explicitly rather than coerce.
+        const outputsJsonRaw = row.outputs_json;
+        if (typeof outputsJsonRaw !== 'string')
+            return null;
+        const value = canonicalJsonParse(outputsJsonRaw);
+        await this.db.execute({
+            sql: `UPDATE memo_cache SET hit_count = hit_count + 1
+            WHERE fn = ? AND inputs_hash = ?`,
+            args: [fn, inputsHash],
+        });
+        this.memory.set(key, { value, expiresAtMs });
+        return { value };
+    }
+    /**
+     * Write both tiers. Memory first (cheap, in-process), then libsql (the
+     * source of truth across restarts). `INSERT OR REPLACE` keeps the write
+     * idempotent: the same `(fn, inputs_hash)` written twice in a row
+     * preserves the latest output and resets `cached_at_ms` to the new write
+     * time. `hit_count` is reset to 0 because the entry is logically new.
+     *
+     * When `ttlMs` is omitted (or explicitly `undefined`), the persistent row
+     * stores `NULL` — no expiry; the entry lives until evicted by LRU
+     * pressure or removed by `clear()`.
+     */
+    async set(fn, inputsHash, outputs, ttlMs) {
+        await this.init();
+        const key = cacheKey(fn, inputsHash);
+        const now = this.nowMs();
+        const expiresAtMs = ttlMs === undefined ? null : now + ttlMs;
+        this.memory.set(key, { value: outputs, expiresAtMs });
+        const outputsJson = canonicalJsonStringify(outputs);
+        await this.db.execute({
+            sql: `INSERT OR REPLACE INTO memo_cache
+              (fn, inputs_hash, outputs_json, cached_at_ms, ttl_ms, hit_count)
+            VALUES (?, ?, ?, ?, ?, 0)`,
+            args: [fn, inputsHash, outputsJson, now, ttlMs ?? null],
+        });
+    }
+    /**
+     * Singleflight: dedup concurrent misses on the same key. The first caller
+     * runs `compute()`; subsequent callers await the same Promise. The
+     * inflight record is removed in `finally` so a failure on the first
+     * caller doesn't poison the key forever.
+     *
+     * Important: this method does NOT itself cache the result — `compute()`
+     * is expected to call `set()` after the primitive returns. The wrap
+     * pattern is documented in the file header.
+     *
+     * Returning `unknown` keeps the API substrate-shaped: the runtime caller
+     * casts to the primitive's return type once the FunctionRegistry has
+     * confirmed args + output handling.
+     */
+    async singleflight(fn, inputsHash, compute) {
+        const key = cacheKey(fn, inputsHash);
+        const existing = this.inflight.get(key);
+        if (existing) {
+            return existing;
+        }
+        const p = compute().finally(() => {
+            this.inflight.delete(key);
+        });
+        this.inflight.set(key, p);
+        return p;
+    }
+    /**
+     * Invalidate cache entries. Both tiers honored.
+     *
+     *   - `{}`                       → wipe everything.
+     *   - `{ fn: 'llm_classify' }`   → wipe all llm_classify entries.
+     *   - `{ olderThanMs: 7 * 86_400_000 }` → wipe entries cached more than
+     *      7 days ago.
+     *   - `{ fn, olderThanMs }`      → AND of both predicates.
+     *
+     * Returns the number of persistent-tier rows removed. The memory tier's
+     * affected-count is not surfaced (the LRU might have already evicted the
+     * row, in which case "removed" is undefined; callers care about durable
+     * cleanup).
+     */
+    async clear(opts = {}) {
+        await this.init();
+        // Memory tier — scan once. The LRU has no native predicate filter, so
+        // we collect candidate keys and delete by key.
+        const now = this.nowMs();
+        const memCutoff = opts.olderThanMs !== undefined ? now - opts.olderThanMs : null;
+        if (opts.fn !== undefined || memCutoff !== null) {
+            const toDelete = [];
+            for (const [k] of this.memory.entries()) {
+                const fnFromKey = parseCacheKey(k)?.fn;
+                if (opts.fn !== undefined && fnFromKey !== opts.fn)
+                    continue;
+                // Memory-tier rows don't carry a cached_at_ms separately — but
+                // expiresAtMs encodes the upper bound. For olderThanMs filtering
+                // we can only purge memory by fn; the cached_at_ms cutoff applies
+                // strictly to the libsql tier where the field is persisted. This
+                // is intentional — memory entries are ephemeral by definition.
+                toDelete.push(k);
+            }
+            for (const k of toDelete)
+                this.memory.delete(k);
+        }
+        else {
+            this.memory.clear();
+        }
+        // libsql tier — build a parameterized DELETE.
+        const wheres = [];
+        const args = [];
+        if (opts.fn !== undefined) {
+            wheres.push('fn = ?');
+            args.push(opts.fn);
+        }
+        if (opts.olderThanMs !== undefined) {
+            wheres.push('cached_at_ms < ?');
+            args.push(now - opts.olderThanMs);
+        }
+        const where = wheres.length > 0 ? ` WHERE ${wheres.join(' AND ')}` : '';
+        const rs = await this.db.execute({
+            sql: `DELETE FROM memo_cache${where}`,
+            args: args,
+        });
+        return Number(rs.rowsAffected);
+    }
+    /**
+     * Per-primitive stats: hit_count totals + live row counts. Powers the
+     * future `opensquid cache stats` CLI verb.
+     *
+     * Expired rows are excluded from `size` — the count reflects rows that
+     * would actually serve traffic today. The persistent table is NOT
+     * compacted as a side effect of this call; the GC verb is `clear()` with
+     * an `olderThanMs` argument.
+     */
+    async stats() {
+        await this.init();
+        const now = this.nowMs();
+        const rs = await this.db.execute({
+            sql: `SELECT
+              fn,
+              SUM(hit_count) AS hits,
+              SUM(
+                CASE WHEN ttl_ms IS NULL OR cached_at_ms + ttl_ms > ?
+                     THEN 1 ELSE 0 END
+              ) AS size
+            FROM memo_cache
+            GROUP BY fn
+            ORDER BY fn ASC`,
+            args: [now],
+        });
+        return rs.rows.map((row) => ({
+            fn: typeof row.fn === 'string' ? row.fn : '',
+            hits: Number(row.hits ?? 0),
+            size: Number(row.size ?? 0),
+        }));
+    }
+}
+function cacheKey(fn, inputsHash) {
+    return `${fn}::${inputsHash}`;
+}
+function parseCacheKey(key) {
+    const idx = key.indexOf('::');
+    if (idx < 0)
+        return null;
+    return { fn: key.slice(0, idx), inputsHash: key.slice(idx + 2) };
+}
+//# sourceMappingURL=memo_cache.js.map

package/dist/runtime/durable/memo_cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memo_cache.js","sourceRoot":"","sources":["../../../src/runtime/durable/memo_cache.ts"],"names":[],"mappings":"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"}