open-managed-agents 0.1.0

package/dist/src/control-plane/events/store.js

@@ -0,0 +1,772 @@
+/**
+ * EventStore — durable append-only event log backed by SQLite.
+ *
+ * Persist-before-publish (ADR 0007 Pattern 2): every event hits this table
+ * before being broadcast to live subscribers. Subscribers that miss the live
+ * broadcast (drop, reconnect, never-connected) recover via `list()`.
+ *
+ * Uses `node:sqlite` (built-in to Node 22.5+) so we have no native dependency
+ * that would break under the `ignore-scripts=true` npm policy.
+ */
+import { DatabaseSync } from "node:sqlite";
+import { RuntimeTurnOwnershipLostError } from "./types.js";
+import { withSqliteTransaction } from "../sqlite-transaction.js";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS events (
+  id           TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL DEFAULT 'wrk_default',
+  session_id   TEXT NOT NULL,
+  type         TEXT NOT NULL,
+  processed_at TEXT,
+  payload      TEXT NOT NULL,
+  created_at   TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS pending_runtime_turns (
+  workspace_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  turn_id TEXT NOT NULL,
+  owner_id TEXT NOT NULL,
+  owner_generation INTEGER NOT NULL,
+  lease_expires_at TEXT NOT NULL,
+  state TEXT NOT NULL,
+  trigger_event_ids TEXT NOT NULL,
+  open_model_request_start_ids TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  completed_at TEXT,
+  terminalized_at TEXT,
+  PRIMARY KEY (workspace_id, session_id, turn_id)
+);
+-- Closed turns are retained as history (UPDATE, not DELETE), so live-turn
+-- counts need a partial index or every /metrics scrape and /health check
+-- scans all history (0121 C2 review, Codex-adv HIGH). Serves both the
+-- workspace-scoped and unscoped counts.
+CREATE INDEX IF NOT EXISTS idx_runtime_turns_live
+ON pending_runtime_turns (workspace_id)
+WHERE state NOT IN ('completed', 'terminalized');
+CREATE TABLE IF NOT EXISTS pending_runtime_actions (
+  workspace_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  turn_id TEXT NOT NULL,
+  action_id TEXT NOT NULL,
+  action_type TEXT NOT NULL,
+  state TEXT NOT NULL,
+  acknowledged_at TEXT,
+  closed_at TEXT,
+  close_reason TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, session_id, action_id),
+  FOREIGN KEY (workspace_id, session_id, turn_id)
+    REFERENCES pending_runtime_turns(workspace_id, session_id, turn_id)
+);
+CREATE TABLE IF NOT EXISTS idempotency_keys (
+  workspace_id TEXT NOT NULL,
+  method TEXT NOT NULL,
+  concrete_path TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  route_label TEXT NOT NULL,
+  fingerprint_sha256 TEXT NOT NULL,
+  status TEXT NOT NULL,
+  response_status INTEGER,
+  response_body TEXT,
+  resource_type TEXT,
+  resource_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, method, concrete_path, idempotency_key)
+);
+`;
+const INDEXES = `
+CREATE INDEX IF NOT EXISTS events_by_workspace_session ON events (workspace_id, session_id, id);
+CREATE INDEX IF NOT EXISTS events_by_workspace_session_type ON events (workspace_id, session_id, type, id);
+CREATE INDEX IF NOT EXISTS pending_runtime_actions_by_turn
+  ON pending_runtime_actions (workspace_id, session_id, turn_id);
+CREATE INDEX IF NOT EXISTS idempotency_keys_by_status_expiry
+  ON idempotency_keys (status, expires_at);
+CREATE INDEX IF NOT EXISTS idempotency_keys_by_resource
+  ON idempotency_keys (workspace_id, resource_type, resource_id);
+`;
+export class EventStore {
+    db;
+    appendStmt;
+    deleteForSessionStmt;
+    deleteIdempotencyKeysForSessionStmt;
+    deleteRuntimeActionsForSessionStmt;
+    deleteRuntimeTurnsForSessionStmt;
+    retrieveStmt;
+    findRuntimeActionStmt;
+    listPendingRuntimeTurnsStmt;
+    listWorkspacesWithPendingRuntimeTurnsStmt;
+    countPendingRuntimeTurnsStmt;
+    countAllPendingRuntimeTurnsStmt;
+    runtimeChangesObserver;
+    pendingRuntimeChangeObservations = [];
+    txDepth = 0;
+    listRuntimeActionsForTurnStmt;
+    insertRuntimeTurnStmt;
+    insertRuntimeActionStmt;
+    acknowledgeRuntimeActionStmt;
+    closeRuntimeActionStmt;
+    updateRuntimeTurnStateStmt;
+    renewRuntimeTurnLeaseStmt;
+    updateRuntimeTurnOpenModelRequestStartsStmt;
+    closeRuntimeTurnStmt;
+    closeRuntimeActionsForTurnStmt;
+    claimAcceptedRuntimeTurnStmt;
+    claimTerminalizingRuntimeTurnStmt;
+    retrieveRuntimeTurnStmt;
+    purgeExpiredIdempotencyKeysStmt;
+    reserveIdempotencyKeyStmt;
+    retrieveIdempotencyKeyStmt;
+    acquireAbandonedIdempotencyKeyStmt;
+    completeIdempotencyKeyStmt;
+    releaseIdempotencyReservationStmt;
+    refreshIdempotencyReservationStmt;
+    deleteIdempotencyKeysForResourceStmt;
+    listStmts = new Map();
+    constructor(db) {
+        this.db = db;
+        this.db.exec(SCHEMA);
+        ensureWorkspaceIdColumn(this.db);
+        ensureOpenModelRequestStartIdsColumn(this.db);
+        ensureIdempotencyResourceColumns(this.db);
+        this.db.exec(INDEXES);
+        this.appendStmt = this.db.prepare(`INSERT INTO events (id, workspace_id, session_id, type, processed_at, payload, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        this.deleteForSessionStmt = this.db.prepare(`DELETE FROM events WHERE workspace_id = ? AND session_id = ?`);
+        this.deleteIdempotencyKeysForSessionStmt = this.db.prepare(`DELETE FROM idempotency_keys
+       WHERE workspace_id = ? AND concrete_path = ?`);
+        this.deleteIdempotencyKeysForResourceStmt = this.db.prepare(`DELETE FROM idempotency_keys
+       WHERE workspace_id = ? AND resource_type = ? AND resource_id = ?`);
+        this.deleteRuntimeActionsForSessionStmt = this.db.prepare(`DELETE FROM pending_runtime_actions
+       WHERE workspace_id = ? AND session_id = ?`);
+        this.deleteRuntimeTurnsForSessionStmt = this.db.prepare(`DELETE FROM pending_runtime_turns
+       WHERE workspace_id = ? AND session_id = ?`);
+        this.retrieveStmt = this.db.prepare(`SELECT id, workspace_id, session_id, type, processed_at, payload, created_at
+       FROM events WHERE workspace_id = ? AND id = ?`);
+        this.findRuntimeActionStmt = this.db.prepare(runtimeActionSelectSql(`
+      WHERE a.workspace_id = ? AND a.session_id = ? AND a.action_id = ?
+      LIMIT 1
+    `));
+        this.listPendingRuntimeTurnsStmt = this.db.prepare(`SELECT workspace_id, session_id, turn_id, owner_id, owner_generation,
+              lease_expires_at, state, trigger_event_ids, created_at, updated_at,
+              completed_at, terminalized_at, open_model_request_start_ids
+       FROM pending_runtime_turns
+       WHERE workspace_id = ? AND state NOT IN ('completed', 'terminalized')
+       ORDER BY turn_id ASC`);
+        this.listWorkspacesWithPendingRuntimeTurnsStmt = this.db.prepare(`SELECT DISTINCT workspace_id
+       FROM pending_runtime_turns
+       WHERE state NOT IN ('completed', 'terminalized')
+       ORDER BY workspace_id ASC`);
+        this.countPendingRuntimeTurnsStmt = this.db.prepare(`SELECT COUNT(*) AS n FROM pending_runtime_turns
+       WHERE workspace_id = ? AND state NOT IN ('completed', 'terminalized')`);
+        this.countAllPendingRuntimeTurnsStmt = this.db.prepare(`SELECT COUNT(*) AS n FROM pending_runtime_turns
+       WHERE state NOT IN ('completed', 'terminalized')`);
+        this.listRuntimeActionsForTurnStmt = this.db.prepare(runtimeActionSelectSql(`
+      WHERE a.workspace_id = ? AND a.session_id = ? AND a.turn_id = ?
+      ORDER BY a.action_id ASC
+    `));
+        this.insertRuntimeTurnStmt = this.db.prepare(`INSERT INTO pending_runtime_turns
+        (workspace_id, session_id, turn_id, owner_id, owner_generation,
+         lease_expires_at, state, trigger_event_ids, open_model_request_start_ids,
+         created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'accepted', ?, '[]', ?, ?)`);
+        this.insertRuntimeActionStmt = this.db.prepare(`INSERT INTO pending_runtime_actions
+        (workspace_id, session_id, turn_id, action_id, action_type, state,
+         created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`);
+        this.acknowledgeRuntimeActionStmt = this.db.prepare(`UPDATE pending_runtime_actions
+       SET state = 'acknowledged',
+           acknowledged_at = COALESCE(acknowledged_at, ?),
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND action_id = ?
+         AND state = 'pending'`);
+        this.closeRuntimeActionStmt = this.db.prepare(`UPDATE pending_runtime_actions
+       SET state = 'closed',
+           closed_at = COALESCE(closed_at, ?),
+           close_reason = COALESCE(close_reason, ?),
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND action_id = ?
+         AND state != 'closed'`);
+        this.updateRuntimeTurnStateStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET state = ?,
+           lease_expires_at = COALESCE(?, lease_expires_at),
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state NOT IN ('completed', 'terminalized')
+         AND (? IS NULL OR (owner_id = ? AND owner_generation = ?))`);
+        this.renewRuntimeTurnLeaseStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET lease_expires_at = ?, updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state NOT IN ('completed', 'terminalized')
+         AND owner_id = ? AND owner_generation = ?`);
+        this.updateRuntimeTurnOpenModelRequestStartsStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET open_model_request_start_ids = ?, updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state NOT IN ('completed', 'terminalized')
+         AND owner_id = ? AND owner_generation = ?`);
+        this.closeRuntimeTurnStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET state = ?,
+           updated_at = ?,
+           open_model_request_start_ids = '[]',
+           completed_at = CASE WHEN ? = 'completed' THEN COALESCE(completed_at, ?) ELSE completed_at END,
+           terminalized_at = CASE WHEN ? = 'terminalized' THEN COALESCE(terminalized_at, ?) ELSE terminalized_at END
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state NOT IN ('completed', 'terminalized')
+         AND (? IS NULL OR (owner_id = ? AND owner_generation = ?))`);
+        this.closeRuntimeActionsForTurnStmt = this.db.prepare(`UPDATE pending_runtime_actions
+       SET state = 'closed',
+           closed_at = COALESCE(closed_at, ?),
+           close_reason = COALESCE(close_reason, ?),
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state != 'closed'`);
+        this.claimAcceptedRuntimeTurnStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET owner_id = ?,
+           owner_generation = owner_generation + 1,
+           lease_expires_at = ?,
+           state = 'dispatching',
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state = 'accepted'
+         AND (owner_id = ? OR lease_expires_at <= ?)`);
+        this.claimTerminalizingRuntimeTurnStmt = this.db.prepare(`UPDATE pending_runtime_turns
+       SET owner_id = ?,
+           owner_generation = owner_generation + 1,
+           lease_expires_at = ?,
+           state = 'terminalizing',
+           updated_at = ?
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?
+         AND state NOT IN ('completed', 'terminalized')
+         AND (owner_id = ? OR lease_expires_at <= ?)`);
+        this.retrieveRuntimeTurnStmt = this.db.prepare(`SELECT workspace_id, session_id, turn_id, owner_id, owner_generation,
+              lease_expires_at, state, trigger_event_ids, created_at, updated_at,
+              completed_at, terminalized_at, open_model_request_start_ids
+       FROM pending_runtime_turns
+       WHERE workspace_id = ? AND session_id = ? AND turn_id = ?`);
+        this.purgeExpiredIdempotencyKeysStmt = this.db.prepare(`DELETE FROM idempotency_keys
+       WHERE status IN ('completed', 'in_progress') AND expires_at <= ?`);
+        this.reserveIdempotencyKeyStmt = this.db.prepare(`INSERT INTO idempotency_keys
+        (workspace_id, method, concrete_path, idempotency_key, route_label,
+         fingerprint_sha256, status, created_at, updated_at, expires_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'in_progress', ?, ?, ?)
+       ON CONFLICT(workspace_id, method, concrete_path, idempotency_key) DO NOTHING`);
+        this.retrieveIdempotencyKeyStmt = this.db.prepare(`SELECT workspace_id, method, concrete_path, idempotency_key, route_label,
+              fingerprint_sha256, status, response_status, response_body,
+              resource_type, resource_id, created_at, updated_at, expires_at
+       FROM idempotency_keys
+       WHERE workspace_id = ? AND method = ? AND concrete_path = ?
+         AND idempotency_key = ?`);
+        this.acquireAbandonedIdempotencyKeyStmt = this.db.prepare(`UPDATE idempotency_keys
+       SET updated_at = ?, expires_at = ?
+       WHERE workspace_id = ? AND method = ? AND concrete_path = ?
+         AND idempotency_key = ? AND fingerprint_sha256 = ?
+         AND status = 'in_progress' AND updated_at <= ?`);
+        this.completeIdempotencyKeyStmt = this.db.prepare(`UPDATE idempotency_keys
+       SET status = 'completed',
+           response_status = ?,
+           response_body = ?,
+           resource_type = ?,
+           resource_id = ?,
+           updated_at = ?,
+           expires_at = ?
+       WHERE workspace_id = ? AND method = ? AND concrete_path = ?
+         AND idempotency_key = ? AND fingerprint_sha256 = ?
+         AND status = 'in_progress'`);
+        this.releaseIdempotencyReservationStmt = this.db.prepare(`DELETE FROM idempotency_keys
+       WHERE workspace_id = ? AND method = ? AND concrete_path = ?
+         AND idempotency_key = ? AND fingerprint_sha256 = ?
+         AND status = 'in_progress'`);
+        this.refreshIdempotencyReservationStmt = this.db.prepare(`UPDATE idempotency_keys
+       SET updated_at = ?, expires_at = ?
+       WHERE workspace_id = ? AND method = ? AND concrete_path = ?
+         AND idempotency_key = ? AND fingerprint_sha256 = ?
+         AND status = 'in_progress'`);
+    }
+    /** Open a store backed by a SQLite file. Pass `:memory:` for in-memory. */
+    static open(path = ":memory:") {
+        return new EventStore(new DatabaseSync(path));
+    }
+    append(event) {
+        this.appendEvent(event);
+    }
+    appendBatch(events) {
+        this.appendBatchWithRuntimeChanges(events, {});
+    }
+    appendBatchWithRuntimeChanges(events, changes) {
+        this.withTransaction(() => {
+            this.appendBatchWithRuntimeChangesInTransaction(events, changes);
+        });
+    }
+    appendBatchWithRuntimeChangesAndCompleteIdempotency(events, changes, completion) {
+        this.withTransaction(() => {
+            this.appendBatchWithRuntimeChangesInTransaction(events, changes);
+            this.completeIdempotencyInTransaction(completion);
+        });
+    }
+    appendBatchWithRuntimeChangesInTransaction(events, changes) {
+        for (const event of events) {
+            this.appendEvent(event);
+        }
+        this.applyRuntimeChanges(changes);
+    }
+    completeIdempotencyInTransaction(completion) {
+        const result = this.completeIdempotencyKeyStmt.run(completion.responseStatus, JSON.stringify(completion.responseBody), completion.resourceType ?? null, completion.resourceId ?? null, completion.now, completion.expiresAt, completion.workspaceId, completion.method, completion.concretePath, completion.key, completion.fingerprintSha256);
+        if (result.changes === 0) {
+            throw new Error("Idempotency key reservation was not active at completion");
+        }
+    }
+    completeIdempotency(completion) {
+        this.withTransaction(() => {
+            this.completeIdempotencyInTransaction(completion);
+        });
+    }
+    releaseIdempotencyReservation(input) {
+        this.releaseIdempotencyReservationStmt.run(input.workspaceId, input.method, input.concretePath, input.key, input.fingerprintSha256);
+    }
+    refreshIdempotencyReservation(input) {
+        this.refreshIdempotencyReservationStmt.run(input.now, input.expiresAt, input.workspaceId, input.method, input.concretePath, input.key, input.fingerprintSha256);
+    }
+    reserveIdempotencyKey(input) {
+        // Policy lives here because this store owns the durable ledger rows. The
+        // service currently passes a conservative five-minute abandoned threshold.
+        // Reacquiring an abandoned in-progress row is safe because reservation
+        // commits before the domain transaction; if the completed response did not
+        // commit, the event/runtime side effect could not have committed either.
+        this.purgeExpiredIdempotencyKeysStmt.run(input.now);
+        const inserted = this.reserveIdempotencyKeyStmt.run(input.workspaceId, input.method, input.concretePath, input.key, input.routeLabel, input.fingerprintSha256, input.now, input.now, input.expiresAt);
+        if (inserted.changes === 1)
+            return { kind: "reserved" };
+        const row = this.retrieveIdempotencyKey(input);
+        if (!row)
+            return { kind: "reserved" };
+        if (row.fingerprint_sha256 !== input.fingerprintSha256) {
+            return { kind: "fingerprint_mismatch" };
+        }
+        if (row.status === "completed") {
+            if (row.response_status === null || row.response_body === null) {
+                throw new Error("Completed idempotency row is missing response data");
+            }
+            return {
+                kind: "replay",
+                responseStatus: row.response_status,
+                responseBody: JSON.parse(row.response_body),
+            };
+        }
+        if (row.status === "in_progress") {
+            const acquired = this.acquireAbandonedIdempotencyKeyStmt.run(input.now, input.expiresAt, input.workspaceId, input.method, input.concretePath, input.key, input.fingerprintSha256, input.abandonedBefore);
+            return acquired.changes === 1 ? { kind: "reserved" } : { kind: "in_progress" };
+        }
+        throw new Error(`Unknown idempotency key status: ${row.status}`);
+    }
+    deleteForSession(workspaceId, sessionId) {
+        this.withTransaction(() => {
+            this.deleteRuntimeActionsForSessionStmt.run(workspaceId, sessionId);
+            this.deleteRuntimeTurnsForSessionStmt.run(workspaceId, sessionId);
+            this.deleteForSessionStmt.run(workspaceId, sessionId);
+            this.deleteIdempotencyKeysForSessionStmt.run(workspaceId, `/v1/sessions/${sessionId}/events`);
+            this.deleteIdempotencyKeysForResourceStmt.run(workspaceId, "session", sessionId);
+        });
+    }
+    withTransaction(fn) {
+        this.txDepth += 1;
+        try {
+            return withSqliteTransaction(this.db, fn);
+        }
+        catch (error) {
+            // This savepoint rolled back; the recorded changes never committed.
+            // (Dropping ALL pending observations undercounts if a sibling nested
+            // transaction already succeeded — the safe direction for a counter.)
+            this.pendingRuntimeChangeObservations.length = 0;
+            throw error;
+        }
+        finally {
+            this.txDepth -= 1;
+            if (this.txDepth === 0)
+                this.flushRuntimeChangeObservations();
+        }
+    }
+    // Post-commit observation seam for /metrics (plan 0121 §2): fires AFTER
+    // the outermost store transaction releases, never inside it, so metrics
+    // can't alter commit semantics. One seam covers every apply path — the
+    // service's direct appends, persist.ts helpers, and both runtime-event
+    // coordinators. Caveat (documented, accepted): when an EventStore
+    // transaction is nested inside another store's savepoint on the same
+    // connection, the observer fires before that OUTER commit — a rare
+    // rollback there overcounts a turn; gauges self-correct from DB truth.
+    setRuntimeChangesObserver(observer) {
+        this.runtimeChangesObserver = observer;
+    }
+    flushRuntimeChangeObservations() {
+        if (this.pendingRuntimeChangeObservations.length === 0)
+            return;
+        const batches = this.pendingRuntimeChangeObservations.splice(0);
+        const observer = this.runtimeChangesObserver;
+        if (observer === undefined)
+            return;
+        for (const changes of batches) {
+            try {
+                observer(changes);
+            }
+            catch {
+                // Observers are telemetry; they must never fail a request.
+            }
+        }
+    }
+    list(workspaceId, sessionId, opts = {}) {
+        return this.listPage(workspaceId, sessionId, {
+            ...opts,
+            limit: opts.limit ?? 1000,
+        }).data;
+    }
+    listPage(workspaceId, sessionId, opts = {}) {
+        const cursor = resolveCursor(opts);
+        if (cursor === "") {
+            return { data: [], next_page: null };
+        }
+        const order = resolveOrder(opts);
+        const limit = normalizeLimit(opts.limit);
+        const stmt = this.listStmt({
+            hasCursor: cursor !== undefined,
+            order,
+            types: opts.types ?? [],
+        });
+        const rows = stmt.all(...selectListArgs(workspaceId, sessionId, cursor, limit + 1, opts.types));
+        const data = rows.slice(0, limit).map(deserialize);
+        return {
+            data,
+            next_page: rows.length > limit ? data[data.length - 1]?.id ?? null : null,
+        };
+    }
+    retrieve(workspaceId, id) {
+        const row = this.retrieveStmt.get(workspaceId, id);
+        return row ? deserialize(row) : undefined;
+    }
+    findRuntimeAction(workspaceId, sessionId, actionId) {
+        const row = this.findRuntimeActionStmt.get(workspaceId, sessionId, actionId);
+        return row ? deserializeRuntimeAction(row) : undefined;
+    }
+    listPendingRuntimeTurns(workspaceId) {
+        const rows = this.listPendingRuntimeTurnsStmt.all(workspaceId);
+        return rows.map(deserializeRuntimeTurn);
+    }
+    countPendingRuntimeTurns(workspaceId) {
+        return this.countPendingRuntimeTurnsStmt.get(workspaceId).n;
+    }
+    // Unscoped, for the /metrics gauge (0121 C2). Bounded by in-flight work,
+    // so no dedicated index is needed.
+    countAllPendingRuntimeTurns() {
+        return this.countAllPendingRuntimeTurnsStmt.get().n;
+    }
+    listWorkspaceIdsWithPendingRuntimeTurns() {
+        const rows = this.listWorkspacesWithPendingRuntimeTurnsStmt.all();
+        return rows.map((row) => row.workspace_id);
+    }
+    claimAcceptedRuntimeTurnForRecovery(claim) {
+        const result = this.claimAcceptedRuntimeTurnStmt.run(claim.ownerId, claim.leaseExpiresAt, claim.now, claim.workspaceId, claim.sessionId, claim.turnId, claim.ownerId, claim.now);
+        if (result.changes === 0)
+            return undefined;
+        return this.retrieveRuntimeTurn(claim.workspaceId, claim.sessionId, claim.turnId);
+    }
+    claimRuntimeTurnForTerminalization(claim) {
+        const result = this.claimTerminalizingRuntimeTurnStmt.run(claim.ownerId, claim.leaseExpiresAt, claim.now, claim.workspaceId, claim.sessionId, claim.turnId, claim.ownerId, claim.now);
+        if (result.changes === 0)
+            return undefined;
+        return this.retrieveRuntimeTurn(claim.workspaceId, claim.sessionId, claim.turnId);
+    }
+    listRuntimeActionsForTurn(workspaceId, sessionId, turnId) {
+        const rows = this.listRuntimeActionsForTurnStmt.all(workspaceId, sessionId, turnId);
+        return rows.map(deserializeRuntimeAction);
+    }
+    retrieveRuntimeTurn(workspaceId, sessionId, turnId) {
+        const row = this.retrieveRuntimeTurnStmt.get(workspaceId, sessionId, turnId);
+        return row ? deserializeRuntimeTurn(row) : undefined;
+    }
+    retrieveIdempotencyKey(input) {
+        return this.retrieveIdempotencyKeyStmt.get(input.workspaceId, input.method, input.concretePath, input.key);
+    }
+    close() {
+        this.db.close();
+    }
+    appendEvent(event) {
+        this.appendStmt.run(event.id, event.workspace_id, event.session_id, event.type, event.processed_at, JSON.stringify(event.payload), event.created_at);
+    }
+    applyRuntimeChanges(changes) {
+        if (this.runtimeChangesObserver !== undefined &&
+            ((changes.acceptedTurns?.length ?? 0) > 0 ||
+                (changes.closedTurns?.length ?? 0) > 0)) {
+            this.pendingRuntimeChangeObservations.push(changes);
+        }
+        for (const turn of changes.acceptedTurns ?? []) {
+            this.insertRuntimeTurnStmt.run(turn.workspaceId, turn.sessionId, turn.turnId, turn.ownerId, turn.ownerGeneration, turn.leaseExpiresAt, JSON.stringify([...turn.triggerEventIds]), turn.now, turn.now);
+        }
+        for (const action of changes.openedActions ?? []) {
+            this.insertRuntimeActionStmt.run(action.workspaceId, action.sessionId, action.turnId, action.actionId, action.actionType, action.now, action.now);
+        }
+        for (const action of changes.acknowledgedActions ?? []) {
+            this.acknowledgeRuntimeActionStmt.run(action.now, action.now, action.workspaceId, action.sessionId, action.actionId);
+        }
+        for (const action of changes.closedActions ?? []) {
+            this.closeRuntimeActionStmt.run(action.now, action.reason, action.now, action.workspaceId, action.sessionId, action.actionId);
+        }
+        for (const turn of changes.turnStates ?? []) {
+            const result = this.updateRuntimeTurnStateStmt.run(turn.state, turn.leaseExpiresAt ?? null, turn.now, turn.workspaceId, turn.sessionId, turn.turnId, turn.ownerId ?? null, turn.ownerId ?? null, turn.ownerGeneration ?? null);
+            if (turn.ownerId !== undefined && result.changes === 0) {
+                throw new RuntimeTurnOwnershipLostError(turn.turnId);
+            }
+        }
+        for (const turn of changes.leaseRenewals ?? []) {
+            const result = this.renewRuntimeTurnLeaseStmt.run(turn.leaseExpiresAt, turn.now, turn.workspaceId, turn.sessionId, turn.turnId, turn.ownerId, turn.ownerGeneration);
+            if (result.changes === 0) {
+                throw new RuntimeTurnOwnershipLostError(turn.turnId);
+            }
+        }
+        for (const turn of changes.openedModelRequestStarts ?? []) {
+            this.updateRuntimeTurnOpenModelRequestStarts(turn, (current) => [
+                ...current,
+                turn.startEventId,
+            ]);
+        }
+        for (const turn of changes.closedModelRequestStarts ?? []) {
+            this.updateRuntimeTurnOpenModelRequestStarts(turn, (current) => {
+                const index = current.lastIndexOf(turn.startEventId);
+                return index === -1
+                    ? current
+                    : [...current.slice(0, index), ...current.slice(index + 1)];
+            });
+        }
+        for (const turn of changes.closedTurns ?? []) {
+            const result = this.closeRuntimeTurnStmt.run(turn.state, turn.now, turn.state, turn.now, turn.state, turn.now, turn.workspaceId, turn.sessionId, turn.turnId, turn.ownerId ?? null, turn.ownerId ?? null, turn.ownerGeneration ?? null);
+            if (turn.ownerId !== undefined && result.changes === 0) {
+                throw new RuntimeTurnOwnershipLostError(turn.turnId);
+            }
+            this.closeRuntimeActionsForTurnStmt.run(turn.now, turn.reason, turn.now, turn.workspaceId, turn.sessionId, turn.turnId);
+        }
+    }
+    updateRuntimeTurnOpenModelRequestStarts(turn, update) {
+        const existing = this.retrieveRuntimeTurn(turn.workspaceId, turn.sessionId, turn.turnId);
+        const current = existing?.open_model_request_start_ids ?? [];
+        const next = update(current);
+        const result = this.updateRuntimeTurnOpenModelRequestStartsStmt.run(JSON.stringify(next), turn.now, turn.workspaceId, turn.sessionId, turn.turnId, turn.ownerId, turn.ownerGeneration);
+        if (result.changes === 0) {
+            throw new RuntimeTurnOwnershipLostError(turn.turnId);
+        }
+    }
+    listStmt(opts) {
+        const key = JSON.stringify({
+            hasCursor: opts.hasCursor,
+            order: opts.order,
+            typeCount: opts.types.length,
+        });
+        const existing = this.listStmts.get(key);
+        if (existing)
+            return existing;
+        const predicates = ["workspace_id = ?", "session_id = ?"];
+        if (opts.types.length > 0) {
+            predicates.push(`type IN (${opts.types.map(() => "?").join(", ")})`);
+        }
+        if (opts.hasCursor) {
+            predicates.push(opts.order === "asc" ? "id > ?" : "id < ?");
+        }
+        const stmt = this.db.prepare(`SELECT id, workspace_id, session_id, type, processed_at, payload, created_at
+       FROM events
+       WHERE ${predicates.join(" AND ")}
+       ORDER BY id ${opts.order.toUpperCase()}
+       LIMIT ?`);
+        this.listStmts.set(key, stmt);
+        return stmt;
+    }
+}
+function selectListArgs(workspaceId, sessionId, cursor, limit, types) {
+    const t = types ?? [];
+    if (cursor === undefined) {
+        return t.length === 0
+            ? [workspaceId, sessionId, limit]
+            : [workspaceId, sessionId, ...t, limit];
+    }
+    return t.length === 0
+        ? [workspaceId, sessionId, cursor, limit]
+        : [workspaceId, sessionId, ...t, cursor, limit];
+}
+function resolveCursor(opts) {
+    return opts.page ?? opts.afterId;
+}
+function resolveOrder(opts) {
+    if (opts.afterId !== undefined && opts.order === undefined) {
+        return "asc";
+    }
+    return opts.order ?? "asc";
+}
+function normalizeLimit(limit) {
+    if (limit === undefined)
+        return 20;
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        return 20;
+    return Math.min(limit, 1000);
+}
+function deserialize(row) {
+    return {
+        id: row.id,
+        workspace_id: row.workspace_id,
+        session_id: row.session_id,
+        type: row.type,
+        processed_at: row.processed_at,
+        payload: JSON.parse(row.payload),
+        created_at: row.created_at,
+    };
+}
+function runtimeActionSelectSql(whereClause) {
+    return `
+    SELECT
+      a.workspace_id,
+      a.session_id,
+      a.turn_id,
+      a.action_id,
+      a.action_type,
+      a.state AS action_state,
+      a.acknowledged_at,
+      a.closed_at,
+      a.close_reason,
+      a.created_at AS action_created_at,
+      a.updated_at AS action_updated_at,
+      t.owner_id,
+      t.owner_generation,
+      t.lease_expires_at,
+      t.state AS turn_state,
+      t.trigger_event_ids,
+      t.open_model_request_start_ids,
+      t.created_at AS turn_created_at,
+      t.updated_at AS turn_updated_at,
+      t.completed_at,
+      t.terminalized_at
+    FROM pending_runtime_actions a
+    JOIN pending_runtime_turns t
+      ON t.workspace_id = a.workspace_id
+     AND t.session_id = a.session_id
+     AND t.turn_id = a.turn_id
+    ${whereClause}
+  `;
+}
+function deserializeRuntimeAction(row) {
+    return {
+        workspace_id: row.workspace_id,
+        session_id: row.session_id,
+        turn_id: row.turn_id,
+        action_id: row.action_id,
+        action_type: row.action_type,
+        state: row.action_state,
+        acknowledged_at: row.acknowledged_at,
+        closed_at: row.closed_at,
+        close_reason: row.close_reason,
+        created_at: row.action_created_at,
+        updated_at: row.action_updated_at,
+        turn: {
+            workspace_id: row.workspace_id,
+            session_id: row.session_id,
+            turn_id: row.turn_id,
+            owner_id: row.owner_id,
+            owner_generation: row.owner_generation,
+            lease_expires_at: row.lease_expires_at,
+            state: row.turn_state,
+            trigger_event_ids: parseTriggerEventIds(row.trigger_event_ids),
+            open_model_request_start_ids: parseStringArray(row.open_model_request_start_ids),
+            created_at: row.turn_created_at,
+            updated_at: row.turn_updated_at,
+            completed_at: row.completed_at,
+            terminalized_at: row.terminalized_at,
+        },
+    };
+}
+function deserializeRuntimeTurn(row) {
+    return {
+        workspace_id: row.workspace_id,
+        session_id: row.session_id,
+        turn_id: row.turn_id,
+        owner_id: row.owner_id,
+        owner_generation: row.owner_generation,
+        lease_expires_at: row.lease_expires_at,
+        state: row.state,
+        trigger_event_ids: parseTriggerEventIds(row.trigger_event_ids),
+        open_model_request_start_ids: parseStringArray(row.open_model_request_start_ids),
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        completed_at: row.completed_at,
+        terminalized_at: row.terminalized_at,
+    };
+}
+function parseTriggerEventIds(value) {
+    return parseStringArray(value);
+}
+function parseStringArray(value) {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "string")
+        ? parsed
+        : [];
+}
+function ensureWorkspaceIdColumn(db) {
+    const columns = db.prepare("PRAGMA table_info(events)").all();
+    if (columns.some((column) => column.name === "workspace_id"))
+        return;
+    const existing = db.prepare("SELECT COUNT(*) AS count FROM events").get();
+    db.exec("BEGIN");
+    try {
+        db.exec("ALTER TABLE events ADD COLUMN workspace_id TEXT NOT NULL DEFAULT 'wrk_default'");
+        if (existing.count === 0) {
+            db.exec("COMMIT");
+            return;
+        }
+        if (hasTable(db, "sessions")) {
+            db.exec(`
+        UPDATE events
+        SET workspace_id = (
+          SELECT sessions.workspace_id
+          FROM sessions
+          WHERE sessions.id = events.session_id
+        )
+        WHERE EXISTS (
+          SELECT 1 FROM sessions WHERE sessions.id = events.session_id
+        )
+      `);
+            const unmapped = db.prepare(`
+        SELECT COUNT(*) AS count
+        FROM events
+        WHERE NOT EXISTS (
+          SELECT 1 FROM sessions WHERE sessions.id = events.session_id
+        )
+      `).get();
+            if (unmapped.count === 0) {
+                db.exec("COMMIT");
+                return;
+            }
+        }
+        throw new Error("Cannot automatically migrate legacy events without workspace_id; run an explicit workspace backfill first.");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function ensureOpenModelRequestStartIdsColumn(db) {
+    const columns = db.prepare("PRAGMA table_info(pending_runtime_turns)").all();
+    if (columns.some((column) => column.name === "open_model_request_start_ids")) {
+        return;
+    }
+    db.exec("ALTER TABLE pending_runtime_turns ADD COLUMN open_model_request_start_ids TEXT NOT NULL DEFAULT '[]'");
+}
+function ensureIdempotencyResourceColumns(db) {
+    const columns = db.prepare("PRAGMA table_info(idempotency_keys)").all();
+    if (!columns.some((column) => column.name === "resource_type")) {
+        db.exec("ALTER TABLE idempotency_keys ADD COLUMN resource_type TEXT");
+    }
+    if (!columns.some((column) => column.name === "resource_id")) {
+        db.exec("ALTER TABLE idempotency_keys ADD COLUMN resource_id TEXT");
+    }
+}
+function hasTable(db, name) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(name);
+    return row !== undefined;
+}