@sema-ai/core 1.275.1

package/dist/stores/file/workflow-journal-store.js

@@ -0,0 +1,157 @@
+/**
+ * SVC-2 / core [381] item ⑥ (onboarded from service per channel [375]) — FILE-backed durable
+ * {@link WorkflowJournalStore} for the LOCAL (DB-less, TOC) backend, so `resumeFromRunId` survives a PROCESS
+ * RESTART on a single-user deployment (the shell's monitor `r restart` path). Completes the backend triple:
+ * tidb/pg = SQL twins (cross-replica), local = THIS (one box, crash-safe), replacing core's InMemory store
+ * (which made a TOC restart silently resolve to an empty journal → full live re-run — safe, but the resume
+ * optimization the flywheel asked about never fired across restarts).
+ *
+ * Layout: ONE append-only JSONL ledger per RUN (`<root>/workflow-journal/<runId>.jsonl` — runId is engine-mint
+ * uuid, still passed through core's strict `sanitizePathComponent` backstop). One line = one
+ * `{scope, ordinal, callKey, result}` record; replay is last-writer-wins per ordinal (the InMemory
+ * `byOrdinal.set` semantics — a resumed run re-appends its replayed prefix verbatim, idempotent). A torn final
+ * line (crash mid-append) is dropped on replay, the same crash-safety contract as FileWorkflowRunStore.
+ *
+ * Contract parity with the twins:
+ *  - LOAD-BEARING: append/load throw on real I/O failure (a silently-dropped entry would silently re-run work) —
+ *    EXCEPT an oversize result, which is skip-journaled (shared `oversizeJournalResult` guard: that ordinal is
+ *    just not cached; the resume re-runs that one agent live).
+ *  - SCOPE-GUARDED (CORE-9 BLOCKER): `load(runId, scope)` returns [] unless the run's recorded scope matches —
+ *    an LLM-controlled cross-scope `resumeFromRunId` discloses nothing. A same-run append under a DIFFERENT
+ *    scope throws (identity bug — matches InMemory).
+ *  - `deleteByRun` (service GC extra): unlink the run's ledger; idempotent.
+ * Files are 0o600 in a 0o700 dir (a journaled TaskResult carries tool output — operator-only, matching the
+ * notify-journal posture). Lazily opened fds, closed + evicted on deleteByRun/dispose.
+ */
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, unlinkSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { callKeyOrdinal } from "../../core/workflow-journal-store.js";
+import { sanitizePathComponent } from "./fs-atomic.js";
+/**
+ * SVC-2 — the shared size bound for a journaled workflow-agent result, so ALL backends DEGRADE IDENTICALLY on
+ * an oversize TaskResult (no dialect divergence). Inlined from service's `workflow-journal-limits` on
+ * onboarding (channel [375]) — the 5 MiB figure aligns with TiDB's ~6 MiB per-row txn-entry-size-limit (a row
+ * over it is REJECTED with "entry too large"); a LOAD-BEARING `append` that hit that would THROW and kill the
+ * whole workflow. PostgreSQL TEXT has no such low limit, so without a shared guard the same large result would
+ * journal fine on PG but fail the workflow on TiDB. All backends instead skip-journal a result whose serialized
+ * size exceeds {@link MAX_JOURNAL_RESULT_BYTES} (a no-op, never an insert/throw): the agent's ordinal is simply
+ * not cached, so a resume re-runs that one agent live. Resume is an optimization — a too-big-to-cache result is
+ * a graceful degrade, not a failure. Measured in BYTES (UTF-8) — a multibyte result can be larger than its
+ * `.length` in chars.
+ */
+export const MAX_JOURNAL_RESULT_BYTES = 5 * 1024 * 1024;
+/** True when a serialized journal result is too large to store (UTF-8 byte length over {@link MAX_JOURNAL_RESULT_BYTES}). */
+export function oversizeJournalResult(serialized) {
+    return Buffer.byteLength(serialized, "utf8") > MAX_JOURNAL_RESULT_BYTES;
+}
+export class FileWorkflowJournalStore {
+    fsyncEnabled;
+    dir;
+    fds = new Map();
+    /** Per-run committed scope, cached at first touch — the append-path scope guard must NOT re-read the whole
+     *  ledger per append (a journaled result can be MBs; a many-agent workflow would go O(n²) on disk). One replay
+     *  discovers it; every later append compares against the cache. */
+    scopes = new Map();
+    constructor(root, fsyncEnabled = true) {
+        this.fsyncEnabled = fsyncEnabled;
+        this.dir = join(root, "workflow-journal");
+        mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+    }
+    pathFor(runId) {
+        return join(this.dir, `${sanitizePathComponent(runId)}.jsonl`);
+    }
+    /** Replay a run's ledger: last-writer-wins per ordinal; a torn/unparsable line is skipped (uncommitted). */
+    replay(runId) {
+        let path;
+        try {
+            path = this.pathFor(runId);
+        }
+        catch {
+            // `resumeFromRunId` is LLM-CONTROLLED on the load path — a traversal-shaped id (sanitizePathComponent
+            // throws) must degrade to "no journal" (the resume diverges to live), never crash the workflow start.
+            // (An engine-minted append id can't hit this; append's own throw discipline is unaffected.)
+            return undefined;
+        }
+        if (!existsSync(path))
+            return undefined;
+        let scope;
+        const byOrdinal = new Map();
+        for (const line of readFileSync(path, "utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch {
+                continue; // torn crash-tail — not yet committed state
+            }
+            if (typeof rec.callKey !== "string" || typeof rec.scope !== "string")
+                continue;
+            scope = scope ?? rec.scope; // first committed writer fixes the run's scope (fail-closed on later mismatch below)
+            if (rec.scope !== scope)
+                continue; // never mix scopes within one run's replay
+            byOrdinal.set(rec.ordinal, { callKey: rec.callKey, result: rec.result });
+        }
+        return scope === undefined ? undefined : { scope, byOrdinal };
+    }
+    async append(runId, scope, entry) {
+        const serialized = JSON.stringify(entry.result);
+        // Shared twin degrade ({@link oversizeJournalResult}): an oversize result is skip-journaled, never
+        // insert/throw — its ordinal isn't cached, so a resume re-runs that ONE agent live. Keeps all backends
+        // byte-matched.
+        if (oversizeJournalResult(serialized))
+            return;
+        const committed = this.scopes.get(runId) ?? this.replay(runId)?.scope; // cached, else one disk replay
+        if (committed !== undefined && committed !== scope) {
+            // runId is a fresh uuid per run; a scope collision is a programming/identity bug (matches InMemory's throw).
+            throw new Error(`workflow journal: runId ${runId} already recorded under a different scope`);
+        }
+        this.scopes.set(runId, committed ?? scope);
+        let fd = this.fds.get(runId);
+        if (fd === undefined) {
+            fd = openSync(this.pathFor(runId), "a", 0o600); // owner-only: a TaskResult carries tool output
+            this.fds.set(runId, fd);
+        }
+        // One record = one writeSync of `json + "\n"` (never split) → the only torn line possible is a crash tail,
+        // which replay drops. fsync per append: the journal is LOAD-BEARING (an acked-but-lost entry would replay wrong).
+        const line = { scope, ordinal: callKeyOrdinal(entry.callKey), callKey: entry.callKey, result: entry.result };
+        writeSync(fd, `${JSON.stringify(line)}\n`);
+        if (this.fsyncEnabled)
+            fsyncSync(fd);
+    }
+    async load(runId, scope) {
+        const rec = this.replay(runId);
+        if (!rec || rec.scope !== scope)
+            return []; // missing OR cross-scope → empty (the resume safely diverges to live)
+        return [...rec.byOrdinal.entries()].sort((a, b) => a[0] - b[0]).map(([, e]) => e);
+    }
+    /** GC (service extra, mirrors the SQL twins): drop the run's ledger once the run is terminal + retained. */
+    async deleteByRun(runId) {
+        const fd = this.fds.get(runId);
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* already closed */ }
+            this.fds.delete(runId);
+        }
+        this.scopes.delete(runId);
+        const path = this.pathFor(runId);
+        if (!existsSync(path))
+            return 0;
+        unlinkSync(path);
+        return 1;
+    }
+    /** Release ledger fds (graceful shutdown; parity with the other file stores' dispose). */
+    dispose() {
+        for (const fd of this.fds.values()) {
+            try {
+                closeSync(fd);
+            }
+            catch { /* best-effort */ }
+        }
+        this.fds.clear();
+    }
+}
+//# sourceMappingURL=workflow-journal-store.js.map

package/dist/stores/file/workflow-journal-store.js.map

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

package/dist/stores/file/workflow-run-store.d.ts

@@ -0,0 +1,58 @@
+import { type WorkflowRunStore, type WorkflowRunSummary } from "../../core/workflow-run-store.js";
+import type { WorkflowRun, WorkflowRunStatus } from "../../orchestration/workflow.js";
+export interface FileWorkflowRunStoreOptions {
+    /** When false, a ledger append is NOT fsync'd (the observability store is non-engine-critical). Default true. */
+    fsync?: boolean;
+    /** Compact the ledger into a snapshot once it exceeds this many events (then truncate). Default 1000. */
+    compactEvery?: number;
+}
+export declare class FileWorkflowRunStore implements WorkflowRunStore {
+    private readonly dir;
+    private readonly tmpDir;
+    private readonly ledgerPath;
+    private readonly snapshotPath;
+    private readonly fsyncEnabled;
+    private readonly compactEvery;
+    /** Authoritative in-memory state (replayed at boot). The CAS reads/writes THIS; disk is the durable log. */
+    private readonly runs;
+    /** Per-id async mutex chain (identical shape to `FileCheckpointStore.locks`). */
+    private readonly locks;
+    /** Number of events appended to the live ledger since the last compaction (drives auto-compaction). */
+    private ledgerEvents;
+    private log;
+    constructor(root: string, opts?: FileWorkflowRunStoreOptions);
+    /** Rebuild the authoritative map: snapshot first (the compacted base), then the live ledger's events. */
+    private replay;
+    /** Fold one ledger event into the authoritative map (last-writer-wins by event order). */
+    private applyEvent;
+    /**
+     * Serialize an op behind any in-flight op on the same id (the in-process per-id async mutex — the SAME
+     * `Map<id, Promise>` chain shape as `FileCheckpointStore.withLock`). A prior op's rejection never blocks
+     * the chain (awaited `.catch`-guarded). The chain entry is GC'd once it is the settled tail.
+     */
+    private withLock;
+    /** Commit one ledger event (append + fsync) THEN flip the in-memory map (crash-safe ordering). */
+    private commit;
+    put(id: string, run: WorkflowRun): Promise<void>;
+    get(id: string): Promise<WorkflowRun | null>;
+    update(id: string, scope: string, run: WorkflowRun, expect?: {
+        rev: number;
+    }): Promise<boolean>;
+    listByScope(scope: string, opts?: {
+        status?: WorkflowRunStatus;
+        limit?: number;
+    }): Promise<WorkflowRunSummary[]>;
+    reap(scope: string, now: number, opts?: {
+        maxAgeMs?: number;
+        keep?: number;
+    }): Promise<number>;
+    /** Rewrite the snapshot from the current authoritative map (atomic) and truncate the live ledger. */
+    private compact;
+    /** Force a compaction now (test/inspection). */
+    compactNow(): void;
+    /** Test/inspection helper: number of stored runs. */
+    get size(): number;
+    /** Release the append handle (best-effort). The boot LOCK is released by the backend factory. */
+    close(): void;
+}
+//# sourceMappingURL=workflow-run-store.d.ts.map

package/dist/stores/file/workflow-run-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-run-store.d.ts","sourceRoot":"","sources":["../../../src/stores/file/workflow-run-store.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACxB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AA6BtF,MAAM,WAAW,2BAA2B;IAC1C,iHAAiH;IACjH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,yGAAyG;IACzG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAU;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC,4GAA4G;IAC5G,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkC;IACvD,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuC;IAC7D,uGAAuG;IACvG,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,GAAG,CAAY;gBAEX,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,2BAAgC;IAahE,yGAAyG;IACzG,OAAO,CAAC,MAAM;IASd,0FAA0F;IAC1F,OAAO,CAAC,UAAU;IASlB;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAiBhB,kGAAkG;IAClG,OAAO,CAAC,MAAM;IAOR,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAahD,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAK5C,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB/F,WAAW,CACf,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,iBAAiB,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GACpD,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAU1B,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAuCpG,qGAAqG;IACrG,OAAO,CAAC,OAAO;IASf,gDAAgD;IAChD,UAAU,IAAI,IAAI;IAIlB,qDAAqD;IACrD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,iGAAiG;IACjG,KAAK,IAAI,IAAI;CAGd"}

package/dist/stores/file/workflow-run-store.js

@@ -0,0 +1,178 @@
+import { join } from "node:path";
+import { WorkflowRunStoreError, isTerminalWorkflowStatus, summarizeWorkflowRun, } from "../../core/workflow-run-store.js";
+import { AppendLog, atomicWriteFile, ensureDir, readJsonlRecords } from "./fs-atomic.js";
+export class FileWorkflowRunStore {
+    dir;
+    tmpDir;
+    ledgerPath;
+    snapshotPath;
+    fsyncEnabled;
+    compactEvery;
+    /** Authoritative in-memory state (replayed at boot). The CAS reads/writes THIS; disk is the durable log. */
+    runs = new Map();
+    /** Per-id async mutex chain (identical shape to `FileCheckpointStore.locks`). */
+    locks = new Map();
+    /** Number of events appended to the live ledger since the last compaction (drives auto-compaction). */
+    ledgerEvents = 0;
+    log;
+    constructor(root, opts = {}) {
+        this.dir = join(root, "workflow-runs");
+        this.tmpDir = join(root, "tmp");
+        this.ledgerPath = join(this.dir, "runs.jsonl");
+        this.snapshotPath = join(this.dir, "runs.snapshot.jsonl");
+        this.fsyncEnabled = opts.fsync !== false;
+        this.compactEvery = opts.compactEvery ?? 1000;
+        ensureDir(this.dir);
+        ensureDir(this.tmpDir);
+        this.replay();
+        this.log = new AppendLog(this.ledgerPath);
+    }
+    /** Rebuild the authoritative map: snapshot first (the compacted base), then the live ledger's events. */
+    replay() {
+        for (const snap of readJsonlRecords(this.snapshotPath)) {
+            this.runs.set(snap.id, snap);
+        }
+        const events = readJsonlRecords(this.ledgerPath);
+        this.ledgerEvents = events.length;
+        for (const ev of events)
+            this.applyEvent(ev);
+    }
+    /** Fold one ledger event into the authoritative map (last-writer-wins by event order). */
+    applyEvent(ev) {
+        if (ev.t === "delete") {
+            this.runs.delete(ev.id);
+            return;
+        }
+        // put / update both replace the row (update already carries the bumped rev in its persisted run).
+        this.runs.set(ev.id, ev.run);
+    }
+    /**
+     * Serialize an op behind any in-flight op on the same id (the in-process per-id async mutex — the SAME
+     * `Map<id, Promise>` chain shape as `FileCheckpointStore.withLock`). A prior op's rejection never blocks
+     * the chain (awaited `.catch`-guarded). The chain entry is GC'd once it is the settled tail.
+     */
+    withLock(id, fn) {
+        const prev = this.locks.get(id) ?? Promise.resolve();
+        const run = prev.then(() => fn(), () => fn());
+        const tail = run.then(() => { }, () => { });
+        this.locks.set(id, tail);
+        void tail.then(() => {
+            if (this.locks.get(id) === tail)
+                this.locks.delete(id);
+        });
+        return run;
+    }
+    /** Commit one ledger event (append + fsync) THEN flip the in-memory map (crash-safe ordering). */
+    commit(ev, fsync) {
+        this.log.append(ev, fsync); // durable FIRST
+        this.applyEvent(ev); // in-memory flip AFTER the fsync'd append
+        this.ledgerEvents++;
+        if (this.ledgerEvents >= this.compactEvery)
+            this.compact();
+    }
+    async put(id, run) {
+        return this.withLock(id, () => {
+            if (this.runs.has(id)) {
+                throw new WorkflowRunStoreError("workflow_run.already_exists", `workflow run id already exists`);
+            }
+            // Defensive deep copy + persist the observed rev (default 0) so `update`'s OCC has a base to bump from.
+            const stored = structuredClone(run);
+            stored.id = id; // the key is authoritative — a payload with a mismatched id must not poison the projection
+            stored.rev = run.rev ?? 0;
+            this.commit({ t: "put", id, run: stored }, this.fsyncEnabled);
+        });
+    }
+    async get(id) {
+        const run = this.runs.get(id);
+        return run ? structuredClone(run) : null;
+    }
+    async update(id, scope, run, expect) {
+        return this.withLock(id, () => {
+            const cur = this.runs.get(id);
+            // CAS predicate identical to InMemory: scope in the WHERE (multi-tenant isolation); row must exist.
+            if (!cur || cur.scope !== scope) {
+                return false;
+            }
+            // OCC guard, evaluated atomically with the CAS (the per-id mutex serializes it, as the DB serializes a
+            // conditional UPDATE): a stale-rev update loses (an intervening update bumped the live rev).
+            if (expect !== undefined && (cur.rev ?? 0) !== expect.rev) {
+                return false;
+            }
+            const next = structuredClone(run);
+            next.id = id; // the key is authoritative — a payload with a mismatched id must not poison the projection
+            next.scope = scope; // scope is immutable for a row — never let an update rewrite the partition key
+            next.rev = (cur.rev ?? 0) + 1; // monotonic bump — the OCC key for the next update
+            this.commit({ t: "update", id, run: next }, this.fsyncEnabled);
+            return true;
+        });
+    }
+    async listByScope(scope, opts) {
+        // READ-ONLY query over the authoritative replayed map (no per-id lock, no mutation, no commit/fsync).
+        const rows = [...this.runs.values()].filter((r) => r.scope === scope && (opts?.status === undefined || r.status === opts.status));
+        rows.sort((a, b) => b.createdAt - a.createdAt); // newest first
+        const limited = opts?.limit !== undefined ? rows.slice(0, Math.max(0, opts.limit)) : rows;
+        return limited.map(summarizeWorkflowRun); // shared projection — byte-identical to InMemory
+    }
+    async reap(scope, now, opts) {
+        if (opts?.maxAgeMs === undefined && opts?.keep === undefined)
+            return 0; // retention is always explicit
+        // Compute the doomed set from a snapshot of the terminal rows (a running run is NEVER reaped), then
+        // delete each under its own id lock (so the delete serializes against a concurrent put/update on that id).
+        const terminal = [...this.runs.values()].filter((r) => r.scope === scope && isTerminalWorkflowStatus(r.status));
+        terminal.sort((a, b) => b.createdAt - a.createdAt);
+        // Carry the doom REASON so the per-id lock can re-verify it against the live row (codex: a concurrent
+        // update could bump a doomed row's endedAt; without re-checking, File would delete a row InMemory's atomic
+        // reap would keep). `byAge` is re-checkable per-row; `byKeep` (newest-N) is set-relative, so the snapshot
+        // ordering decision stands (a soft retention bound, not a correctness invariant).
+        const doomed = [];
+        for (let i = 0; i < terminal.length; i++) {
+            const r = terminal[i];
+            const tooOld = opts.maxAgeMs !== undefined && (r.endedAt ?? r.createdAt) < now - opts.maxAgeMs;
+            const overKeep = opts.keep !== undefined && i >= opts.keep;
+            if (tooOld || overKeep)
+                doomed.push({ id: r.id, byAge: tooOld });
+        }
+        let n = 0;
+        for (const { id, byAge } of doomed) {
+            const deleted = await this.withLock(id, () => {
+                const live = this.runs.get(id);
+                // Re-check under the lock: only delete a still-present terminal row in this scope (a concurrent update
+                // may have flipped it back to running, or it was already removed).
+                if (!live || live.scope !== scope || !isTerminalWorkflowStatus(live.status))
+                    return false;
+                // If doomed by AGE, re-verify age against the LIVE row (its endedAt may have moved); if doomed by
+                // keep-newest-N, the snapshot decision stands (set-relative, can't re-check per-id).
+                if (byAge && opts.maxAgeMs !== undefined && (live.endedAt ?? live.createdAt) >= now - opts.maxAgeMs) {
+                    return false;
+                }
+                this.commit({ t: "delete", id }, this.fsyncEnabled);
+                return true;
+            });
+            if (deleted)
+                n++;
+        }
+        return n;
+    }
+    /** Rewrite the snapshot from the current authoritative map (atomic) and truncate the live ledger. */
+    compact() {
+        const lines = [...this.runs.values()].map((r) => JSON.stringify(r)).join("\n");
+        atomicWriteFile(this.tmpDir, this.snapshotPath, lines.length ? `${lines}\n` : "");
+        this.log.close();
+        atomicWriteFile(this.tmpDir, this.ledgerPath, ""); // atomic replace → empty ledger
+        this.log = new AppendLog(this.ledgerPath);
+        this.ledgerEvents = 0;
+    }
+    /** Force a compaction now (test/inspection). */
+    compactNow() {
+        this.compact();
+    }
+    /** Test/inspection helper: number of stored runs. */
+    get size() {
+        return this.runs.size;
+    }
+    /** Release the append handle (best-effort). The boot LOCK is released by the backend factory. */
+    close() {
+        this.log.close();
+    }
+}
+//# sourceMappingURL=workflow-run-store.js.map

package/dist/stores/file/workflow-run-store.js.map

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

package/dist/stores/pg.d.ts

@@ -0,0 +1,210 @@
+/**
+ * PostgreSQL **reference adapters** for the two durable seams a deployment must supply to make a
+ * stateless runner durable (the "session center" + design/45 durable-checkpoint):
+ *
+ *  - {@link PgSessionRepo} — a durable `SessionRepo` (append-only event log). Hand it to the built-in
+ *    `TtlSessionStore` (`new TtlSessionStore({ repo })`) and you get the full session center: wake on
+ *    `acquire`, idle-cache, cross-instance optimistic lock. This is the README §11 recipe, on Postgres.
+ *  - {@link PgCheckpointStore} — a durable `CheckpointStore` (design/45 F4/1C): atomic CAS `resolve`,
+ *    `expire` fence, deadline `reap`.
+ *
+ * **Driver-neutral**: this module depends on no Postgres client. Pass any `(text, params) => {rows}`
+ * function ({@link PgQueryFn}) — `node-postgres` (`(t, p) => pool.query(t, p)`), `pg-mem` in tests, or
+ * a thin wrapper over postgres.js. The SQL sticks to portable basics (text/bigint/jsonb columns,
+ * `ON CONFLICT`, conditional `UPDATE … RETURNING`).
+ *
+ * **Concurrency contract** (mirrors the TiDB backend, README §11 / design/10):
+ *  - Session appends are serialized by the `(session_id, seq)` primary key: two replicas that woke the
+ *    same session race their next `INSERT`; the loser hits a unique violation and gets
+ *    `SessionError("conflict")` (catch with `isSessionConflict`) — never a silent fork.
+ *  - `resolve`/`expire` are single-row conditional UPDATEs over the same `pending` row, so the DB
+ *    serializes them: exactly one wins (the once-only foundation, design/45 §2.1).
+ *
+ * Reference-grade scope (open-source profile): full-tree wake (no F3 bounded-tail query), no
+ * connection management (the caller owns the pool), no retention/GC worker (run `reap` + your own
+ * retention policy on a schedule).
+ */
+import { Session } from "../internal/harness.js";
+import type { SessionMetadata, SessionRepo } from "../internal/harness.js";
+import { type Checkpoint, type CheckpointStore, type CheckpointSummary, type CheckpointToken, type ReopenReason, type ResolveExpectation, type ResumeOutcome } from "../core/checkpoint-store.js";
+import { type MemoryNoteHeader, type MemoryNoteRecord, type MemoryStore, type MemoryVectorMode, type ScoredMemory, type StructuredNoteInput } from "../core/memory.js";
+import type { ToolResultSlice, ToolResultStore } from "../core/tool-result-store.js";
+/** The subset of a query result this module reads. `rowCount` is deliberately unused (drivers
+ *  disagree on it); statements that need a count use `RETURNING` and read `rows.length`. */
+export interface PgQueryResult {
+    rows: Array<Record<string, unknown>>;
+}
+/**
+ * The only thing the adapters need from your Postgres client: positional-parameter query.
+ * `node-postgres`: `const q: PgQueryFn = (text, params) => pool.query(text, params)`.
+ */
+export type PgQueryFn = (text: string, params?: unknown[]) => Promise<PgQueryResult>;
+/** Table names used by {@link ensurePgAgentSchema} and the adapters (single source of truth). */
+export declare const PG_AGENT_TABLES: {
+    readonly sessions: "agent_sessions";
+    readonly sessionEntries: "agent_session_entries";
+    readonly checkpoints: "agent_checkpoints";
+    readonly memory: "agent_memory";
+    /** design/84 Seam B: per-scope periodic-consolidation cursor (one row per writeScope). */
+    readonly memoryCursor: "agent_memory_cursor";
+    readonly toolResults: "agent_tool_results";
+};
+/** Options for {@link ensurePgAgentSchema}. */
+export interface PgAgentSchemaOptions {
+    /**
+     * Shape of the memory `embedding` column:
+     *  - omitted → `jsonb` (portable mode: vectors stored as JSON, cosine computed in process — works on
+     *    ANY Postgres, no extension);
+     *  - `{ dimensions, pgvector: true }` → `CREATE EXTENSION vector` + a `vector(d)` column, so
+     *    {@link PgMemoryStore} with `pgvectorSql: true` ranks by the native `<=>` cosine-distance operator
+     *    (index-accelerable with an HNSW/IVFFlat index you add per your scale).
+     * Pick once at schema time and keep {@link PgMemoryStoreOptions} consistent with it.
+     */
+    memoryVector?: {
+        dimensions: number;
+        pgvector?: boolean;
+    };
+}
+/**
+ * Create the three tables (idempotent, `IF NOT EXISTS`). Call once at startup, or run the same DDL
+ * through your own migration tool. JSON payloads are `jsonb`; values are always **passed as JSON
+ * strings** (every driver can bind a string; Postgres casts it into the column type).
+ */
+export declare function ensurePgAgentSchema(query: PgQueryFn, opts?: PgAgentSchemaOptions): Promise<void>;
+/** Postgres SQLSTATE 23505; fall back to message sniffing for emulators that don't set `code`.
+ *  Exported for `MemoryBackend` dialect implementations (the Pg reference implementation moved to
+ *  @sema-ai/server — see docs/MEMORY-BACKEND-DIALECT-NOTES.md); one sniffing rule, every consumer. */
+export declare function isUniqueViolation(err: unknown): boolean;
+/**
+ * Durable `SessionRepo` on Postgres. Plug into the built-in cache:
+ * ```ts
+ * const repo = new PgSessionRepo((t, p) => pool.query(t, p));
+ * const runner = new Runner({ brain, sessionStore: new TtlSessionStore({ repo }) });
+ * ```
+ * `TtlSessionStore` defaults to `evict: "forget"` for a custom repo, so idle eviction never deletes
+ * durable history; `open` of an unknown id throws `not_found` and the store falls back to `create`.
+ */
+export declare class PgSessionRepo implements SessionRepo {
+    private readonly query;
+    constructor(query: PgQueryFn);
+    private load;
+    create(options?: {
+        id?: string;
+    }): Promise<Session>;
+    open(metadata: SessionMetadata): Promise<Session>;
+    list(): Promise<SessionMetadata[]>;
+    delete(metadata: SessionMetadata): Promise<void>;
+    /** Fork caveats (1.94.0 review obs#1/#2): an EXPLICIT `options.id` must not be shared with a
+     *  concurrent `create` of the same id (create's orphan purge can race the in-flight entry batches —
+     *  unreachable under default uuidv7 ids; explicit-id reuse is a caller contract); and forking onto an
+     *  id holding orphan residue from a previously failed fork fails LOUD with a unique violation
+     *  (`create` purges such residue, `fork` deliberately does not — loud beats silently adopting). */
+    fork(sourceMetadata: SessionMetadata, options?: {
+        entryId?: string;
+        position?: "before" | "at";
+        id?: string;
+    }): Promise<Session>;
+}
+/**
+ * Durable `CheckpointStore` on Postgres (design/45 §2.1). The `status` **column** is authoritative
+ * (the CAS target); the `checkpoint` jsonb is the full payload, whose embedded `status` is overwritten
+ * from the column on `get`. `resolve` persists the outcome atomically with the status flip (the v2
+ * resumable-resume hook the interface reserves).
+ */
+export declare class PgCheckpointStore implements CheckpointStore {
+    private readonly query;
+    constructor(query: PgQueryFn);
+    put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
+    get(token: CheckpointToken): Promise<Checkpoint | null>;
+    resolve(token: CheckpointToken, scope: string, outcome: ResumeOutcome, expect?: ResolveExpectation): Promise<boolean>;
+    reopen(token: CheckpointToken, scope: string, reason: ReopenReason): Promise<boolean>;
+    setPendingSteer(token: CheckpointToken, scope: string, steer: {
+        text: string;
+        trusted: boolean;
+    }): Promise<boolean>;
+    expire(token: CheckpointToken, scope: string): Promise<boolean>;
+    reap(scope: string, cutoff: number): Promise<number>;
+    listByScope(scope: string): Promise<CheckpointSummary[]>;
+}
+/**
+ * Durable `ToolResultStore` on Postgres. Required for durable suspend (design/45): the runner refuses
+ * to suspend over the default `InMemoryToolResultStore` (its offload refs die with the process and a
+ * cross-replica resume could never read them back). Write-once per ref (`ON CONFLICT DO NOTHING`, the
+ * interface contract); slicing matches the in-memory store exactly (JS `slice` semantics).
+ */
+export declare class PgToolResultStore implements ToolResultStore {
+    private readonly query;
+    constructor(query: PgQueryFn);
+    put(ref: string, content: string): Promise<void>;
+    get(ref: string, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<ToolResultSlice | undefined>;
+}
+/** Produces an embedding for one note/query. `dimensions` must match the schema's `memoryVector`. */
+export interface PgEmbedder {
+    embed(text: string): Promise<number[]>;
+    dimensions: number;
+}
+/** Options for {@link PgMemoryStore} — pick the recall mode (all three honor the same cosine-distance
+ *  contract `score ∈ [0,2], 0 = identical`, so the consolidation band needs no recalibration). */
+export interface PgMemoryStoreOptions {
+    /**
+     * When set, notes are embedded on `append`/`update` and `searchScored` ranks by cosine distance.
+     * Without it, `searchScored` falls back to the same lexical (Jaccard) distance as the in-memory
+     * reference store — fine for dev, weaker recall.
+     */
+    embedder?: PgEmbedder;
+    /**
+     * `true` → rank in SQL with pgvector's `<=>` operator (schema must have been created with
+     * `memoryVector: { pgvector: true }`). `false`/omitted → embeddings live in `jsonb` and cosine is
+     * computed in process after fetching the scope (portable: any Postgres, no extension; right up until
+     * a scope is huge — then switch pgvector on). Requires `embedder`.
+     *
+     * Migration note (1.94.0 review obs#3): the SQL path EXCLUDES rows without an embedding
+     * (`WHERE embedding IS NOT NULL`) — unlike the in-process path, which keeps such legacy rows as
+     * lexical-fallback candidates. **Backfill embeddings before enabling `pgvectorSql`**, or pre-embedder
+     * notes silently drop out of consolidation/recall. Conversely, REMOVING the embedder later is a
+     * downgrade (obs#4): a subsequent `update` stores `embedding = null` for that note.
+     */
+    pgvectorSql?: boolean;
+}
+/**
+ * Durable `MemoryStore` on Postgres — the full surface (L2 read/append, L3 `search`, consolidation
+ * trio `searchScored`/`update`/`delete`, design/65 structured notes + manifest), with **switchable
+ * recall** (see {@link PgMemoryStoreOptions}): lexical → in-process cosine over `jsonb` embeddings →
+ * native pgvector `<=>`. All three return the same cosine-distance scale, so upgrading recall is a
+ * config change, not a recalibration.
+ *
+ * Insertion order is the uuidv7 id order (time-sortable), matching the in-memory store's append order
+ * for `read`/`search` output. Concurrency: same-scope writes from different sessions follow the
+ * MemoryStore contract's eventual-consistency allowance (at worst a near-duplicate survives one extra
+ * consolidation pass); `update` is a single-row UPDATE, never a read-modify-write of the whole scope.
+ */
+export declare class PgMemoryStore implements MemoryStore {
+    private readonly query;
+    private readonly embedder?;
+    private readonly pgvectorSql;
+    /** design/81 Slice 5 rung: native when the pgvector `<=>` SQL path is on, portable when an embedder ranks
+     *  in-process over the jsonb column, lexical when no embedder. */
+    get vectorMode(): MemoryVectorMode;
+    constructor(query: PgQueryFn, opts?: PgMemoryStoreOptions);
+    private embeddingParam;
+    read(scope: string): Promise<string | null>;
+    append(scope: string, note: string): Promise<string | void>;
+    appendStructured(scope: string, note: StructuredNoteInput): Promise<string>;
+    private insert;
+    clear(scope: string): Promise<void>;
+    /** design/84 Seam B: read the per-scope periodic-consolidation cursor (the opaque note-id high-water mark). */
+    getConsolidationCursor(scope: string): Promise<string | undefined>;
+    /** design/84 Seam B: upsert the per-scope periodic-consolidation cursor (last-writer-wins). */
+    setConsolidationCursor(scope: string, cursor: string): Promise<void>;
+    search(scope: string, query: string, limit?: number): Promise<string[]>;
+    searchScored(scope: string, query: string, limit?: number): Promise<ScoredMemory[]>;
+    update(scope: string, id: string, text: string): Promise<void>;
+    delete(scope: string, id: string): Promise<void>;
+    listStructuredNotes(scope: string): Promise<MemoryNoteHeader[]>;
+    getByIds(scope: string, ids: string[]): Promise<MemoryNoteRecord[]>;
+    private toHeader;
+}
+//# sourceMappingURL=pg.d.ts.map

package/dist/stores/pg.d.ts.map

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