okengine 0.22.0 → 0.23.1

package/src/drivers/journal-postgres.ts

@@ -3,8 +3,9 @@
  *
  * Same concurrency physics as Signal's `once` delivery and Clock's postgres
  * CronStore: claim with `FOR UPDATE SKIP LOCKED`; a crashed holder's lease is
- * reclaimed lazily on the next claim attempt (no sweeper, no fencing token —
- * completed journal steps replay instead of re-running).
+ * reclaimed lazily on the next claim attempt (no sweeper). Each acquire bumps
+ * a fencing token; writes from a previous holder are rejected. Entries are
+ * append-only rows, not a rewritten JSON blob.
  */
 
 import {
@@ -20,12 +21,17 @@ import {
   IDEM_RENEW_SQL,
   IDEM_SELECT_SQL,
 } from "../kernel/idempotency-store.ts";
+import type { DecisionLabelStore } from "../kernel/decision-label-store.ts";
+import type { AgentEventStore } from "../kernel/agent-event-store.ts";
+import { throwOke } from "../kernel/errors.ts";
+import { lazyRequire } from "../kernel/lazy-require.ts";
 import {
   JOURNAL_DEFAULT_LEASE_MS,
   type JournalEntry,
   type JournalLeaseStore,
   type JournalRun,
   type JournalStore,
+  type JournalWriteFence,
 } from "../kernel/journal.ts";
 import {
   resolvePostgresUrl,
@@ -50,6 +56,19 @@ interface JournalDbRow {
   created_at: number;
   updated_at: number;
   tenant: string | null;
+  lease_token: number | null;
+  code_version: string | null;
+}
+
+/** One append-only journal entry row. */
+interface JournalEntryDbRow {
+  run_id: string;
+  seq: number;
+  kind: string;
+  name: string | null;
+  resource: string | null;
+  value: string | null;
+  at: number;
 }
 
 /** Minimal SQL + transaction surface for the postgres journal store. */
@@ -82,7 +101,11 @@ const CLAIM_DUE_SQL = `SELECT * FROM oke_journal_runs WHERE status='sleeping' AN
 /** Boot-time orphan discovery: running/sleeping runs with no live lease. */
 const ORPHANS_SQL = `SELECT * FROM oke_journal_runs WHERE (status='running' OR status='sleeping' OR status='compensating') AND ((locked_by IS NULL) OR (lease_expires_at IS NOT NULL AND lease_expires_at<=?))`;
 
-const UPDATE_LEASE_SQL = `UPDATE oke_journal_runs SET locked_by = ?, lease_expires_at = ? WHERE id = ?`;
+const UPDATE_LEASE_SQL = `UPDATE oke_journal_runs SET locked_by = ?, lease_expires_at = ?, lease_token = COALESCE(lease_token, 0) + 1 WHERE id = ?`;
+
+const INSERT_ENTRY_SQL = `INSERT INTO oke_journal_entries (run_id, seq, kind, name, resource, value, at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT (run_id, seq) DO UPDATE SET kind = EXCLUDED.kind, name = EXCLUDED.name, resource = EXCLUDED.resource, value = EXCLUDED.value, at = EXCLUDED.at`;
+
+const SELECT_ENTRIES_SQL = `SELECT * FROM oke_journal_entries WHERE run_id = ? ORDER BY seq ASC`;
 
 /** Guarded release — never clears another holder's lease. */
 const RELEASE_LEASE_SQL = `UPDATE oke_journal_runs SET locked_by = NULL, lease_expires_at = NULL WHERE id = ? AND locked_by = ?`;
@@ -168,9 +191,70 @@ function rowToRun(row: Record<string, unknown>): JournalRun {
   if (r.tenant !== null && r.tenant !== undefined && String(r.tenant).length > 0) {
     run.tenant = String(r.tenant);
   }
+  const leaseToken = numOrNull(r.lease_token);
+  if (leaseToken !== null) run.leaseToken = leaseToken;
+  if (
+    r.code_version !== null &&
+    r.code_version !== undefined &&
+    String(r.code_version).length > 0
+  ) {
+    run.codeVersion = String(r.code_version);
+  }
   return run;
 }
 
+function entryToParams(runId: string, seq: number, entry: JournalEntry): unknown[] {
+  if (entry.kind === "step") {
+    return [runId, seq, "step", entry.name, null, JSON.stringify(entry.value ?? null), entry.at];
+  }
+  if (entry.kind === "sleep") {
+    return [
+      runId,
+      seq,
+      "sleep",
+      entry.label,
+      entry.duration,
+      JSON.stringify(entry.wakeAt),
+      entry.at,
+    ];
+  }
+  return [
+    runId,
+    seq,
+    "effect",
+    entry.effectKind,
+    entry.resource,
+    JSON.stringify(entry.value ?? null),
+    entry.at,
+  ];
+}
+
+function entryFromRow(row: Record<string, unknown>): JournalEntry {
+  const kind = String(row.kind);
+  const at = Number(row.at);
+  const value =
+    row.value === null || row.value === undefined ? null : JSON.parse(String(row.value));
+  if (kind === "step") {
+    return { kind: "step", name: String(row.name ?? ""), value, at };
+  }
+  if (kind === "sleep") {
+    return {
+      kind: "sleep",
+      label: String(row.name ?? ""),
+      duration: String(row.resource ?? ""),
+      wakeAt: Number(value),
+      at,
+    };
+  }
+  return {
+    kind: "effect",
+    effectKind: String(row.name ?? ""),
+    resource: String(row.resource ?? ""),
+    value,
+    at,
+  };
+}
+
 function runToParams(run: JournalRun): unknown[] {
   return [
     run.id,
@@ -186,6 +270,8 @@ function runToParams(run: JournalRun): unknown[] {
     run.createdAt,
     run.updatedAt,
     run.tenant ?? null,
+    run.leaseToken ?? null,
+    run.codeVersion ?? null,
   ];
 }
 
@@ -206,6 +292,18 @@ async function ensureSchema(sql: PostgresJournalSql): Promise<void> {
     tenant TEXT
   )`);
   await sql.exec(`ALTER TABLE oke_journal_runs ADD COLUMN IF NOT EXISTS tenant TEXT`);
+  await sql.exec(`ALTER TABLE oke_journal_runs ADD COLUMN IF NOT EXISTS lease_token BIGINT`);
+  await sql.exec(`ALTER TABLE oke_journal_runs ADD COLUMN IF NOT EXISTS code_version TEXT`);
+  await sql.exec(`CREATE TABLE IF NOT EXISTS oke_journal_entries (
+    run_id TEXT NOT NULL,
+    seq BIGINT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT,
+    resource TEXT,
+    value TEXT,
+    at BIGINT NOT NULL,
+    PRIMARY KEY (run_id, seq)
+  )`);
   await sql.exec(
     `CREATE INDEX IF NOT EXISTS oke_journal_runs_wake ON oke_journal_runs (status, wake_at)`,
   );
@@ -257,9 +355,49 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
     created_at: number;
     expires_at: number;
   };
-  type State = { rows: JournalDbRow[]; idem: IdemDbRow[] };
+  type LabelDbRow = {
+    decision_id: string;
+    question: string;
+    value: string;
+    propensity: number;
+    reviewer: string;
+    locale: string | null;
+    model: string | null;
+    tenant: string | null;
+    score: number | null;
+    loss: number | null;
+    raw: string | null;
+    at: number;
+    input: string | null;
+    review_id?: string | null;
+  };
+  type State = {
+    rows: JournalDbRow[];
+    idem: IdemDbRow[];
+    labels: LabelDbRow[];
+    drift: { decision_id: string; suspended: number; certified_at: number }[];
+    candidates: { decision_id: string; body: string }[];
+    agentRuns: { run_id: string; header: string; sweep_claim_at: number | null }[];
+    agentEvents: {
+      run_id: string;
+      seq: number;
+      event: string;
+      event_type: string | null;
+      event_name: string | null;
+    }[];
+    entries: JournalEntryDbRow[];
+  };
 
-  let committed: State = { rows: [], idem: [] };
+  let committed: State = {
+    rows: [],
+    idem: [],
+    labels: [],
+    drift: [],
+    candidates: [],
+    agentRuns: [],
+    agentEvents: [],
+    entries: [],
+  };
   let active: { state: State; locked: Set<string>; done: boolean } | null = null;
   /** Run ids held by other active transactions (SKIP LOCKED). */
   const heldByTxn = new Set<string>();
@@ -274,6 +412,12 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
     return {
       rows: s.rows.map((r) => ({ ...r })),
       idem: s.idem.map((r) => ({ ...r })),
+      labels: s.labels.map((r) => ({ ...r })),
+      drift: s.drift.map((r) => ({ ...r })),
+      candidates: s.candidates.map((r) => ({ ...r })),
+      agentRuns: s.agentRuns.map((r) => ({ ...r })),
+      agentEvents: s.agentEvents.map((r) => ({ ...r })),
+      entries: s.entries.map((r) => ({ ...r })),
     };
   }
 
@@ -376,6 +520,73 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
           .map((row) => ({ ...row }) as Record<string, unknown>);
       }
 
+      if (/FROM\s+oke_decision_labels/i.test(text)) {
+        let labels = state.labels;
+        let arg = 0;
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[arg++] ?? "");
+          labels = labels.filter((row) => row.decision_id === id);
+        }
+        if (/tenant\s+IS\s+NOT\s+DISTINCT\s+FROM\s+\?/i.test(text)) {
+          const tenant = params[arg] ?? null;
+          labels = labels.filter((row) => row.tenant === tenant);
+        }
+        return labels.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_drift/i.test(text)) {
+        return state.drift.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_decision_candidates/i.test(text)) {
+        if (/decision_id\s*=\s*\?/i.test(text)) {
+          const id = String(params[0] ?? "");
+          return state.candidates
+            .filter((row) => row.decision_id === id)
+            .map((row) => ({ ...row }));
+        }
+        return state.candidates.map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_run\b/i.test(text)) {
+        if (!/WHERE/i.test(text)) return state.agentRuns.map((row) => ({ ...row }));
+        const id = String(params[0] ?? "");
+        return state.agentRuns.filter((row) => row.run_id === id).map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        if (/MAX\s*\(\s*seq\s*\)/i.test(text)) {
+          const max = state.agentEvents
+            .filter((row) => row.run_id === id)
+            .reduce((highest, row) => Math.max(highest, row.seq), 0);
+          return [{ max_seq: max }];
+        }
+        if (/event_type\s*=/i.test(text)) {
+          const eventType = String(params[1] ?? "");
+          const eventName = String(params[2] ?? "");
+          return state.agentEvents
+            .filter(
+              (row) =>
+                row.run_id === id && row.event_type === eventType && row.event_name === eventName,
+            )
+            .map((row) => ({ ...row }));
+        }
+        const after = /seq\s*>\s*\?/i.test(text) ? Number(params[1] ?? 0) : 0;
+        return state.agentEvents
+          .filter((row) => row.run_id === id && row.seq > after)
+          .sort((a, b) => a.seq - b.seq)
+          .map((row) => ({ ...row }));
+      }
+
+      if (/FROM\s+oke_journal_entries/i.test(text)) {
+        const runId = String(params[0] ?? "");
+        return state.entries
+          .filter((row) => row.run_id === runId)
+          .sort((a, b) => a.seq - b.seq)
+          .map((row) => ({ ...row }));
+      }
+
       throw new Error(`postgres journal fake: unsupported query: ${sql}`);
     },
     async exec(sql, params = []) {
@@ -413,6 +624,14 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
           created_at: Number(record.created_at ?? 0),
           updated_at: Number(record.updated_at ?? 0),
           tenant: (record.tenant as string | null) ?? null,
+          lease_token:
+            record.lease_token === undefined || record.lease_token === null
+              ? (state.rows.find((r) => r.id === String(record.id))?.lease_token ?? null)
+              : Number(record.lease_token),
+          code_version:
+            record.code_version === undefined || record.code_version === null
+              ? (state.rows.find((r) => r.id === String(record.id))?.code_version ?? null)
+              : String(record.code_version),
         };
         const idx = state.rows.findIndex((r) => r.id === next.id);
         if (idx >= 0) state.rows[idx] = next;
@@ -421,15 +640,33 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
       }
 
       const updLease =
-        /^UPDATE\s+oke_journal_runs\s+SET\s+locked_by\s*=\s*\?,\s*lease_expires_at\s*=\s*\?\s+WHERE\s+id\s*=\s*\?\s*$/i.exec(
+        /^UPDATE\s+oke_journal_runs\s+SET\s+locked_by\s*=\s*\?,\s*lease_expires_at\s*=\s*\?/i.exec(
           text,
         );
-      if (updLease) {
-        const row = state.rows.find((r) => r.id === params[2]);
+      if (updLease && /WHERE\s+id\s*=\s*\?/i.test(text) && !/locked_by\s*=\s*NULL/i.test(text)) {
+        const id = String(params[params.length - 1]);
+        const row = state.rows.find((r) => r.id === id);
         if (!row) return { changes: 0 };
         row.locked_by = params[0] === null ? null : String(params[0]);
         row.lease_expires_at =
           params[1] === null || params[1] === undefined ? null : Number(params[1]);
+        if (/lease_token/i.test(text)) row.lease_token = (row.lease_token ?? 0) + 1;
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_journal_entries\b/i.test(text)) {
+        const row: JournalEntryDbRow = {
+          run_id: String(params[0]),
+          seq: Number(params[1]),
+          kind: String(params[2]),
+          name: params[3] === null || params[3] === undefined ? null : String(params[3]),
+          resource: params[4] === null || params[4] === undefined ? null : String(params[4]),
+          value: params[5] === null || params[5] === undefined ? null : String(params[5]),
+          at: Number(params[6]),
+        };
+        const idx = state.entries.findIndex((e) => e.run_id === row.run_id && e.seq === row.seq);
+        if (idx >= 0) state.entries[idx] = row;
+        else state.entries.push(row);
         return { changes: 1 };
       }
 
@@ -539,6 +776,112 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
         row.run_id = String(params[0]);
         return { changes: 1 };
       }
+      if (/^INSERT\s+INTO\s+oke_decision_labels\b/i.test(text)) {
+        state.labels.push({
+          decision_id: String(params[0]),
+          question: String(params[1]),
+          value: String(params[2]),
+          propensity: Number(params[3]),
+          reviewer: String(params[4]),
+          locale: params[5] === null || params[5] === undefined ? null : String(params[5]),
+          model: params[6] === null || params[6] === undefined ? null : String(params[6]),
+          tenant: params[7] === null || params[7] === undefined ? null : String(params[7]),
+          score: params[8] === null || params[8] === undefined ? null : Number(params[8]),
+          loss: params[9] === null || params[9] === undefined ? null : Number(params[9]),
+          raw: params[10] === null || params[10] === undefined ? null : String(params[10]),
+          at: Number(params[11]),
+          input: params[12] === null || params[12] === undefined ? null : String(params[12]),
+          review_id: params[13] === null || params[13] === undefined ? null : String(params[13]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_candidates\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const body = String(params[1]);
+        const idx = state.candidates.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.candidates[idx] = { decision_id: decisionId, body };
+        else state.candidates.push({ decision_id: decisionId, body });
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_decision_drift\b/i.test(text)) return { changes: 0 };
+
+      if (/^DELETE\s+FROM\s+oke_decision_drift\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.drift.length;
+        state.drift = state.drift.filter((row) => row.decision_id !== id);
+        return { changes: before - state.drift.length };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_decision_drift\b/i.test(text)) {
+        const decisionId = String(params[0]);
+        const next = {
+          decision_id: decisionId,
+          suspended: Number(params[1]),
+          certified_at: Number(params[2] ?? 0),
+        };
+        const idx = state.drift.findIndex((row) => row.decision_id === decisionId);
+        if (idx >= 0) state.drift[idx] = next;
+        else state.drift.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^UPDATE\s+oke_agent_run\s+SET\s+sweep_claim_at\b/i.test(text)) {
+        const until = Number(params[0]);
+        const runId = String(params[1] ?? "");
+        const now = Number(params[2]);
+        const row = state.agentRuns.find((candidate) => candidate.run_id === runId);
+        if (!row) return { changes: 0 };
+        if (row.sweep_claim_at !== null && row.sweep_claim_at > now) return { changes: 0 };
+        row.sweep_claim_at = until;
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_run\b/i.test(text)) {
+        const runId = String(params[0]);
+        const existing = state.agentRuns.find((row) => row.run_id === runId);
+        const next = {
+          run_id: runId,
+          header: String(params[1]),
+          sweep_claim_at: existing?.sweep_claim_at ?? null,
+        };
+        const idx = state.agentRuns.findIndex((row) => row.run_id === runId);
+        if (idx >= 0) state.agentRuns[idx] = next;
+        else state.agentRuns.push(next);
+        return { changes: 1 };
+      }
+
+      if (/^INSERT\s+INTO\s+oke_agent_event\b/i.test(text)) {
+        const runId = String(params[0]);
+        const seq = Number(params[1]);
+        if (state.agentEvents.some((row) => row.run_id === runId && row.seq === seq)) {
+          throw new Error(`duplicate key value violates unique constraint "oke_agent_event_pkey"`);
+        }
+        state.agentEvents.push({
+          run_id: runId,
+          seq,
+          event: String(params[2]),
+          event_type: params[3] === undefined || params[3] === null ? null : String(params[3]),
+          event_name: params[4] === undefined || params[4] === null ? null : String(params[4]),
+        });
+        return { changes: 1 };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_event\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentEvents.length;
+        state.agentEvents = state.agentEvents.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentEvents.length };
+      }
+
+      if (/^DELETE\s+FROM\s+oke_agent_run\b/i.test(text)) {
+        const id = String(params[0] ?? "");
+        const before = state.agentRuns.length;
+        state.agentRuns = state.agentRuns.filter((row) => row.run_id !== id);
+        return { changes: before - state.agentRuns.length };
+      }
+
       if (text === IDEM_FORFEIT_SQL) {
         const row = state.idem.find(
           (candidate) =>
@@ -596,15 +939,72 @@ export function createPostgresJournalFake(): PostgresJournalSql & {
   return api;
 }
 
-const UPSERT_SQL = `INSERT INTO oke_journal_runs (id, flow, input, status, entries, wake_at, error, output, locked_by, lease_expires_at, created_at, updated_at, tenant) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT (id) DO UPDATE SET flow = EXCLUDED.flow, input = EXCLUDED.input, status = EXCLUDED.status, entries = EXCLUDED.entries, wake_at = EXCLUDED.wake_at, error = EXCLUDED.error, output = EXCLUDED.output, locked_by = EXCLUDED.locked_by, lease_expires_at = EXCLUDED.lease_expires_at, created_at = EXCLUDED.created_at, updated_at = EXCLUDED.updated_at, tenant = EXCLUDED.tenant`;
+const UPSERT_SQL = `INSERT INTO oke_journal_runs (id, flow, input, status, entries, wake_at, error, output, locked_by, lease_expires_at, created_at, updated_at, tenant, lease_token, code_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT (id) DO UPDATE SET flow = EXCLUDED.flow, input = EXCLUDED.input, status = EXCLUDED.status, entries = EXCLUDED.entries, wake_at = EXCLUDED.wake_at, error = EXCLUDED.error, output = EXCLUDED.output, locked_by = EXCLUDED.locked_by, lease_expires_at = EXCLUDED.lease_expires_at, created_at = EXCLUDED.created_at, updated_at = EXCLUDED.updated_at, tenant = EXCLUDED.tenant, lease_token = EXCLUDED.lease_token, code_version = EXCLUDED.code_version`;
 
 /** Postgres journal store with run-level lease coordination. */
 export type PostgresJournalStore = JournalStore &
   JournalLeaseStore & {
     readonly sql: PostgresJournalSql;
+    /** Bytes written for entry rows plus header entry payloads. */
+    readonly writeBytes: number;
     close(): Promise<void>;
   };
 
+/**
+ * Open decision tables on first use so a journal without decisions stays empty.
+ *
+ * @param sql - Journal SQL client
+ */
+function loadDecisionLabelModule(): typeof import("../kernel/decision-label-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["decision", "label", "store"].join("-"));
+}
+
+function loadAgentEventModule(): typeof import("../kernel/agent-event-store.ts") {
+  return lazyRequire(`${import.meta.dir}/../kernel`, ["agent", "event", "store"].join("-"));
+}
+
+function lazyDecisionLabels(sql: PostgresJournalSql): DecisionLabelStore {
+  let pending: Promise<DecisionLabelStore> | undefined;
+  const ready = (): Promise<DecisionLabelStore> => {
+    pending ??= loadDecisionLabelModule().createPostgresDecisionLabelStore(sql);
+    return pending;
+  };
+  return {
+    insert: (label, at) => ready().then((store) => store.insert(label, at)),
+    list: (decision, tenant) => ready().then((store) => store.list(decision, tenant)),
+    drift: () => ready().then((store) => store.drift()),
+    setDrift: (decision, record) => ready().then((store) => store.setDrift(decision, record)),
+    putCandidate: (decision, entry) => ready().then((store) => store.putCandidate(decision, entry)),
+    getCandidate: (decision) => ready().then((store) => store.getCandidate(decision)),
+    listCandidates: () => ready().then((store) => store.listCandidates()),
+  };
+}
+
+/**
+ * Open the agent event tables on first use.
+ *
+ * @param sql - Journal SQL client
+ */
+function lazyAgentEvents(sql: PostgresJournalSql): AgentEventStore {
+  let pending: Promise<AgentEventStore> | undefined;
+  const ready = (): Promise<AgentEventStore> => {
+    pending ??= loadAgentEventModule().createPostgresAgentEventStore(sql);
+    return pending;
+  };
+  return {
+    read: (runId) => ready().then((store) => store.read(runId)),
+    readAfter: (runId, afterSeq) => ready().then((store) => store.readAfter(runId, afterSeq)),
+    maxSeq: (runId) => ready().then((store) => store.maxSeq(runId)),
+    readHeader: (runId) => ready().then((store) => store.readHeader(runId)),
+    truncated: (runId) => ready().then((store) => store.truncated(runId)),
+    claim: (runId) => ready().then((store) => store.claim(runId)),
+    listHeaders: () => ready().then((store) => store.listHeaders()),
+    writeHeader: (header) => ready().then((store) => store.writeHeader(header)),
+    append: (runId, row) => ready().then((store) => store.append(runId, row)),
+    remove: (runId) => ready().then((store) => store.remove(runId)),
+  };
+}
+
 /**
  * Open a postgres-backed JournalStore (multi-host durable-run coordination).
  *
@@ -622,20 +1022,77 @@ export async function createPostgresJournalStore(
 
   await ensureSchema(sql);
 
+  let writeBytes = 0;
+
+  async function hydrate(row: Record<string, unknown>): Promise<JournalRun> {
+    const run = rowToRun(row);
+    const entryRows = await sql.query(SELECT_ENTRIES_SQL, [run.id]);
+    if (entryRows.length > 0) {
+      (run as { entries: JournalEntry[] }).entries = entryRows.map((entry) => entryFromRow(entry));
+      return run;
+    }
+    if (run.entries.length > 0) {
+      for (let seq = 0; seq < run.entries.length; seq++) {
+        const entry = run.entries[seq];
+        if (!entry) continue;
+        const params = entryToParams(run.id, seq, entry);
+        writeBytes += JSON.stringify(entry).length;
+        await sql.exec(INSERT_ENTRY_SQL, params);
+      }
+    }
+    return run;
+  }
+
+  function assertFence(run: JournalRun | undefined, fence: JournalWriteFence | undefined): void {
+    if (!fence || !run) return;
+    const expired = run.leaseExpiresAt !== undefined && run.leaseExpiresAt <= fence.now;
+    if (run.lockedBy !== fence.lockedBy || run.leaseToken !== fence.leaseToken || expired) {
+      throwOke("JOURNAL_STALE_LEASE", { runId: run.id });
+    }
+  }
+
   const store: PostgresJournalStore = {
     sql,
+    get writeBytes() {
+      return writeBytes;
+    },
     idempotency: createPostgresIdempotencyStore(sql),
+    decisions: lazyDecisionLabels(sql),
+    agentEvents: lazyAgentEvents(sql),
     async get(runId) {
       const rows = await sql.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
       if (!rows[0]) return undefined;
-      return rowToRun(rows[0]);
+      return hydrate(rows[0]);
     },
-    async put(run) {
+    async put(run, fence) {
+      if (fence) {
+        const rows = await sql.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [run.id]);
+        assertFence(rows[0] ? rowToRun(rows[0]) : undefined, fence);
+      }
+      writeBytes += JSON.stringify(run.entries).length;
       await sql.exec(UPSERT_SQL, runToParams(run));
+      for (let seq = 0; seq < run.entries.length; seq++) {
+        const entry = run.entries[seq];
+        if (!entry) continue;
+        writeBytes += JSON.stringify(entry).length;
+        await sql.exec(INSERT_ENTRY_SQL, entryToParams(run.id, seq, entry));
+      }
+    },
+    async appendEntry(runId, seq, entry, fence) {
+      if (fence) {
+        const rows = await sql.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
+        const current = rows[0] ? rowToRun(rows[0]) : undefined;
+        if (!current) throw new Error(`journal: run "${runId}" not found`);
+        assertFence(current, fence);
+      }
+      writeBytes += JSON.stringify(entry).length;
+      await sql.exec(INSERT_ENTRY_SQL, entryToParams(runId, seq, entry));
     },
     async list() {
       const rows = await sql.query(`SELECT * FROM oke_journal_runs`);
-      return rows.map((r) => rowToRun(r));
+      const runs: JournalRun[] = [];
+      for (const row of rows) runs.push(await hydrate(row));
+      return runs;
     },
     async acquireLease(runId, instanceId, now, leaseMs) {
       return sql.begin(async (tx) => {
@@ -645,6 +1102,43 @@ export async function createPostgresJournalStore(
         return true;
       });
     },
+    async cas(runId, instanceId, now, leaseMs, update) {
+      return sql.begin(async (tx) => {
+        const claimed = await tx.query(CLAIM_LEASE_SQL, [runId, instanceId, now]);
+        const row = claimed[0];
+        if (!row) {
+          const exists = await tx.query(`SELECT * FROM oke_journal_runs WHERE id = ?`, [runId]);
+          const held = exists[0];
+          if (!held) return "missing";
+          const current = rowToRun(held);
+          return { lease: true, leaseExpiresAt: current.leaseExpiresAt };
+        }
+        const current = rowToRun(row);
+        const entryRows = await tx.query(SELECT_ENTRIES_SQL, [runId]);
+        if (entryRows.length > 0) {
+          (current as { entries: JournalEntry[] }).entries = entryRows.map((entry) =>
+            entryFromRow(entry),
+          );
+        }
+        const next = update(current) ?? current;
+        const renew =
+          current.lockedBy === instanceId &&
+          current.leaseExpiresAt !== undefined &&
+          current.leaseExpiresAt > now &&
+          current.leaseToken !== undefined;
+        next.lockedBy = instanceId;
+        next.leaseExpiresAt = now + leaseMs;
+        next.leaseToken = renew ? current.leaseToken : (current.leaseToken ?? 0) + 1;
+        for (let seq = 0; seq < next.entries.length; seq++) {
+          const entry = next.entries[seq];
+          if (!entry) continue;
+          await tx.exec(INSERT_ENTRY_SQL, entryToParams(runId, seq, entry));
+        }
+        const header = { ...next, entries: [] as JournalEntry[] };
+        await tx.exec(UPSERT_SQL, runToParams(header));
+        return "ok";
+      });
+    },
     async releaseLease(runId, instanceId) {
       await sql.exec(RELEASE_LEASE_SQL, [runId, instanceId]);
     },
@@ -654,7 +1148,11 @@ export async function createPostgresJournalStore(
         const row = rows[0];
         if (!row) return undefined;
         await tx.exec(UPDATE_LEASE_SQL, [instanceId, now + leaseMs, String(row.id)]);
-        return rowToRun(row);
+        const run = rowToRun(row);
+        run.lockedBy = instanceId;
+        run.leaseExpiresAt = now + leaseMs;
+        run.leaseToken = (run.leaseToken ?? 0) + 1;
+        return run;
       });
     },
     async listOrphans(now) {

package/src/drivers/memory-ddl.test.ts

@@ -0,0 +1,18 @@
+/**
+ * Memory SQL accepts the DDL identity boot issues on the shared connection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { ensureIdentityTables } from "../auth/identity-sql.ts";
+import { memorySqlDriver } from "./memory.ts";
+
+describe("memory sql DDL", () => {
+  test("CREATE INDEX IF NOT EXISTS does not reject identity tables", async () => {
+    const conn = await memorySqlDriver.connect({ role: "primary" });
+    await ensureIdentityTables(conn);
+    await ensureIdentityTables(conn);
+    const rows = await conn.query("SELECT id FROM oke_credentials");
+    expect(rows).toEqual([]);
+    await conn.close();
+  });
+});