@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/work-items/dist/index.js

@@ -0,0 +1,1784 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { initializeSessionRuntimeSchema } from "./session-schema.js";
+import { projectSessionEvent } from "./session-projector.js";
+import { appendSessionEventInTransaction, createSqliteSessionRuntimeTransaction, importProviderHistory, parseSessionTurnMessage, resolveRunExecutionKind, } from "./session-runtime.js";
+const { DatabaseSync } = createRequire(import.meta.url)("node:sqlite");
+const STATUS_BY_EVENT = {
+    PLAN_PROPOSED: "planned",
+    APPROVAL_REQUESTED: "awaiting_approval",
+    RUN_CANCELLED: "cancelled",
+    STEP_STARTED: "executing",
+    VERIFICATION_COMPLETED: "verifying",
+    STEP_FAILED: "failed",
+    WORK_ITEM_COMPLETED: "completed",
+};
+export class SqliteEventStore {
+    database;
+    transactionDepth = 0;
+    constructor(databasePath) {
+        if (databasePath !== ":memory:") {
+            fs.mkdirSync(path.dirname(databasePath), { recursive: true });
+        }
+        this.database = new DatabaseSync(databasePath);
+        this.database.exec("PRAGMA busy_timeout = 5000;");
+        if (databasePath !== ":memory:") {
+            this.database.exec("PRAGMA journal_mode = WAL;");
+        }
+        this.database.exec(`
+      PRAGMA foreign_keys = ON;
+
+      CREATE TABLE IF NOT EXISTS work_items (
+        id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        title TEXT NOT NULL,
+        status TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        conversation_id TEXT NOT NULL,
+        agent_id TEXT,
+        workflow_id TEXT,
+        workflow_revision TEXT,
+        workspace_scope TEXT NOT NULL,
+        identifiers TEXT NOT NULL,
+        context_revision INTEGER NOT NULL,
+        risk_level TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS domain_events (
+        event_id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        sequence INTEGER NOT NULL,
+        work_item_id TEXT NOT NULL,
+        run_id TEXT,
+        execution_kind TEXT CHECK (execution_kind IN ('agent', 'flow') OR execution_kind IS NULL),
+        type TEXT NOT NULL,
+        occurred_at TEXT NOT NULL,
+        actor TEXT NOT NULL,
+        target TEXT,
+        input_hash TEXT,
+        result_ref TEXT,
+        payload TEXT NOT NULL,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id),
+        UNIQUE (work_item_id, sequence)
+      );
+
+      CREATE INDEX IF NOT EXISTS domain_events_work_item_sequence
+        ON domain_events (work_item_id, sequence);
+
+      CREATE INDEX IF NOT EXISTS domain_events_target_sequence
+        ON domain_events (target, sequence);
+
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        work_item_id TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        status TEXT NOT NULL,
+        execution_kind TEXT NOT NULL DEFAULT 'agent'
+          CHECK (execution_kind IN ('agent', 'flow')),
+        agent_id TEXT,
+        plan_id TEXT,
+        workflow_revision TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS runs_work_item_created
+        ON runs (work_item_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS message_attachments (
+        id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        work_item_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        mime_type TEXT NOT NULL,
+        data_base64 TEXT NOT NULL,
+        byte_size INTEGER NOT NULL,
+        content_hash TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS message_attachments_work_item_created
+        ON message_attachments (work_item_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS plans (
+        plan_id TEXT PRIMARY KEY,
+        schema_version INTEGER NOT NULL,
+        source TEXT NOT NULL,
+        workflow_id TEXT NOT NULL,
+        definition_revision TEXT,
+        session_id TEXT,
+        run_id TEXT UNIQUE,
+        steps TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS idempotency_responses (
+        namespace TEXT NOT NULL,
+        idempotency_key TEXT NOT NULL,
+        response TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        PRIMARY KEY (namespace, idempotency_key)
+      );
+
+      CREATE TABLE IF NOT EXISTS artifacts (
+        id TEXT PRIMARY KEY,
+        work_item_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        step_id TEXT,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        mime_type TEXT NOT NULL,
+        content TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        metadata TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id),
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+      CREATE INDEX IF NOT EXISTS artifacts_run_created ON artifacts (run_id, created_at);
+
+      CREATE TABLE IF NOT EXISTS verifications (
+        id TEXT PRIMARY KEY,
+        work_item_id TEXT NOT NULL,
+        run_id TEXT NOT NULL,
+        step_id TEXT,
+        validator TEXT NOT NULL,
+        status TEXT NOT NULL,
+        summary TEXT NOT NULL,
+        artifact_ids TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (work_item_id) REFERENCES work_items(id),
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+      CREATE INDEX IF NOT EXISTS verifications_run_created ON verifications (run_id, created_at);
+    `);
+        for (const statement of [
+            "ALTER TABLE runs ADD COLUMN workflow_revision TEXT",
+            "ALTER TABLE plans ADD COLUMN plan_ir_hash TEXT",
+            "ALTER TABLE runs ADD COLUMN plan_ir_hash TEXT",
+        ]) {
+            try {
+                this.database.exec(statement);
+            }
+            catch { /* Existing databases already contain the column. */ }
+        }
+        initializeSessionRuntimeSchema(this.database);
+    }
+    createWorkItem(input) {
+        const now = new Date().toISOString();
+        const workItem = {
+            schemaVersion: 1,
+            id: input.id ?? createId("wi"),
+            title: input.title,
+            status: "created",
+            mode: input.mode,
+            conversationId: input.conversationId,
+            sessionId: input.sessionId ?? null,
+            agentId: input.agentId ?? null,
+            workflowId: input.workflowId ?? null,
+            workflowRevision: input.workflowRevision ?? null,
+            workspaceScope: [...(input.workspaceScope ?? [])],
+            identifiers: { ...(input.identifiers ?? {}) },
+            contextRevision: input.contextRevision ?? 1,
+            riskLevel: input.riskLevel,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.withTransaction(() => {
+            this.database
+                .prepare(`INSERT INTO work_items (
+            id, schema_version, title, status, mode, conversation_id,
+            session_id, agent_id, workflow_id, workflow_revision, workspace_scope,
+            identifiers, context_revision, risk_level, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(workItem.id, workItem.schemaVersion, workItem.title, workItem.status, workItem.mode, workItem.conversationId, workItem.sessionId, workItem.agentId, workItem.workflowId, workItem.workflowRevision, JSON.stringify(workItem.workspaceScope), JSON.stringify(workItem.identifiers), workItem.contextRevision, workItem.riskLevel, workItem.createdAt, workItem.updatedAt);
+            if (workItem.sessionId) {
+                this.database
+                    .prepare(`INSERT INTO session_runtime (
+              session_id, active_run_id, queue_state, queue_pause_reason,
+              last_event_sequence, version, updated_at
+            ) VALUES (?, NULL, 'ready', NULL, 0, 1, ?)`)
+                    .run(workItem.sessionId, workItem.createdAt);
+            }
+            this.appendEventInTransaction({
+                workItemId: workItem.id,
+                type: "WORK_ITEM_CREATED",
+                actor: "system",
+            });
+        });
+        return workItem;
+    }
+    getWorkItem(workItemId) {
+        const row = this.database
+            .prepare("SELECT * FROM work_items WHERE id = ?")
+            .get(workItemId);
+        return row ? toWorkItem(row) : undefined;
+    }
+    getWorkItemBySessionId(sessionId) {
+        const row = this.database
+            .prepare("SELECT * FROM work_items WHERE session_id = ?")
+            .get(sessionId);
+        return row ? toWorkItem(row) : undefined;
+    }
+    getSessionRuntime(sessionId) {
+        const row = this.database
+            .prepare("SELECT * FROM session_runtime WHERE session_id = ?")
+            .get(sessionId);
+        return row ? toSessionRuntime(row) : undefined;
+    }
+    /**
+     * First and latest ACP usage_update persisted for a session (context tokens in use / model window).
+     * INDEXED BY: without ANALYZE stats SQLite picks the (target, sequence) index and scans every
+     * session's usage rows; this keeps the lookup inside one work item.
+     */
+    getContextUsage(sessionId) {
+        const workItemId = this.getWorkItemBySessionId(sessionId)?.id;
+        if (!workItemId)
+            return undefined;
+        const read = (order) => {
+            const row = this.database
+                .prepare(`SELECT payload FROM domain_events INDEXED BY domain_events_work_item_sequence
+           WHERE work_item_id = ? AND target = 'usage_update'
+           ORDER BY sequence ${order} LIMIT 1`)
+                .get(workItemId);
+            const event = row?.payload
+                ? JSON.parse(row.payload).event
+                : undefined;
+            return typeof event?.used === "number" && typeof event.size === "number"
+                ? { used: event.used, size: event.size }
+                : undefined;
+        };
+        const latest = read("DESC");
+        const first = latest && read("ASC");
+        return latest && first ? { first, latest } : undefined;
+    }
+    getTurn(turnId) {
+        const row = this.database
+            .prepare("SELECT * FROM session_turns WHERE turn_id = ?")
+            .get(turnId);
+        return row ? toSessionTurn(row) : undefined;
+    }
+    listQueuedTurns(sessionId, options) {
+        const afterPosition = Math.max(0, Math.floor(options.afterPosition ?? 0));
+        const limit = Math.max(1, Math.min(100, Math.floor(options.limit)));
+        const rows = this.database
+            .prepare(`SELECT * FROM session_turns
+         WHERE session_id = ? AND status = 'queued' AND queue_position > ?
+         ORDER BY queue_position ASC
+         LIMIT ?`)
+            .all(sessionId, afterPosition, limit + 1);
+        const totalRow = this.database
+            .prepare(`SELECT COUNT(*) AS total FROM session_turns
+         WHERE session_id = ? AND status = 'queued'`)
+            .get(sessionId);
+        const hasMore = rows.length > limit;
+        const turns = rows.slice(0, limit).map(toSessionTurn);
+        return {
+            turns,
+            total: Number(totalRow?.total ?? 0),
+            nextCursor: hasMore
+                ? turns.at(-1)?.queuePosition ?? null
+                : null,
+        };
+    }
+    listTimelineTurns(sessionId, options) {
+        const limit = Math.max(1, Math.min(50, Math.floor(options.limit)));
+        const before = Number.isFinite(options.before)
+            ? Math.max(1, Math.floor(options.before))
+            : Number.MAX_SAFE_INTEGER;
+        const contentBudget = Math.max(1, Math.min(1_048_576, Math.floor(options.contentBudgetBytes ?? 1_048_576)));
+        const rows = this.database
+            .prepare(`SELECT * FROM session_timeline_turns
+         WHERE session_id = ? AND timeline_index < ?
+         ORDER BY timeline_index DESC
+         LIMIT ?`)
+            .all(sessionId, before, limit + 1);
+        const hasEarlier = rows.length > limit;
+        const selectedRows = rows.slice(0, limit).reverse();
+        const truncatedBlockIds = [];
+        let usedBytes = 0;
+        const turns = selectedRows.map((turnRow) => {
+            const blockRows = this.database
+                .prepare(`SELECT * FROM session_timeline_blocks
+           WHERE turn_id = ?
+           ORDER BY block_index ASC`)
+                .all(String(turnRow.turn_id));
+            const blocks = blockRows.map((blockRow) => {
+                const segmentRows = this.database
+                    .prepare(`SELECT * FROM session_output_segments
+             WHERE block_id = ?
+             ORDER BY segment_index ASC
+             LIMIT 101`)
+                    .all(String(blockRow.block_id));
+                const segments = [];
+                for (const segmentRow of segmentRows.slice(0, 100)) {
+                    const byteLength = Number(segmentRow.byte_length);
+                    if (usedBytes + byteLength > contentBudget)
+                        break;
+                    segments.push(toTimelineSegment(segmentRow));
+                    usedBytes += byteLength;
+                }
+                const hasMore = segments.length < segmentRows.length;
+                if (hasMore)
+                    truncatedBlockIds.push(String(blockRow.block_id));
+                return {
+                    ...toTimelineBlock(blockRow),
+                    segments,
+                    nextSegmentCursor: hasMore
+                        ? segments.at(-1)?.segmentIndex ?? -1
+                        : null,
+                };
+            });
+            return {
+                ...toTimelineTurn(turnRow),
+                blocks,
+            };
+        });
+        return {
+            turns,
+            previousCursor: hasEarlier
+                ? turns[0]?.timelineIndex ?? null
+                : null,
+            truncatedBlockIds,
+        };
+    }
+    listTimelineSegments(blockId, options) {
+        const after = Number.isFinite(options.after)
+            ? Math.floor(options.after)
+            : -1;
+        const limit = Math.max(1, Math.min(100, Math.floor(options.limit)));
+        const rows = this.database
+            .prepare(`SELECT * FROM session_output_segments
+         WHERE block_id = ? AND segment_index > ?
+         ORDER BY segment_index ASC
+         LIMIT ?`)
+            .all(blockId, after, limit + 1);
+        const hasMore = rows.length > limit;
+        const segments = rows.slice(0, limit).map(toTimelineSegment);
+        return {
+            segments,
+            nextCursor: hasMore
+                ? segments.at(-1)?.segmentIndex ?? null
+                : null,
+        };
+    }
+    listSessionCommands(sessionId) {
+        const rows = this.database
+            .prepare(`SELECT name, description, input_json
+         FROM session_commands
+         WHERE session_id = ?
+         ORDER BY name ASC`)
+            .all(sessionId);
+        return rows.map((row) => {
+            const input = row.input_json === null || row.input_json === undefined
+                ? undefined
+                : JSON.parse(String(row.input_json));
+            return {
+                name: String(row.name),
+                description: String(row.description),
+                ...(input ? { input } : {}),
+            };
+        });
+    }
+    countAllChanges() {
+        const row = this.database
+            .prepare("SELECT total_changes() AS value")
+            .get();
+        return Number(row?.value ?? 0);
+    }
+    getProviderHistoryImport(sessionId, providerSessionId) {
+        const row = this.database
+            .prepare(`SELECT provider_digest, imported_position, imported_at
+         FROM provider_history_imports
+         WHERE session_id = ? AND provider_session_id = ?`)
+            .get(sessionId, providerSessionId);
+        return row
+            ? {
+                providerDigest: String(row.provider_digest),
+                importedPosition: Number(row.imported_position),
+                importedAt: String(row.imported_at),
+            }
+            : undefined;
+    }
+    importProviderHistory(input) {
+        return this.withSessionTransaction((tx) => importProviderHistory(tx, input));
+    }
+    withSessionTransaction(operation) {
+        return this.withTransaction(() => {
+            const { transaction, deactivate } = createSqliteSessionRuntimeTransaction(this.database);
+            try {
+                return operation(transaction);
+            }
+            finally {
+                deactivate();
+            }
+        });
+    }
+    withTransaction(operation) {
+        if (this.transactionDepth > 0) {
+            throw new Error("nested transaction is not supported");
+        }
+        this.database.exec("BEGIN IMMEDIATE;");
+        this.transactionDepth = 1;
+        try {
+            const result = operation();
+            this.database.exec("COMMIT;");
+            return result;
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK;");
+            throw error;
+        }
+        finally {
+            this.transactionDepth = 0;
+        }
+    }
+    previewSessionRuntimeMigration(bindings) {
+        const conflicts = [];
+        for (const binding of bindings) {
+            const activeRuns = this.database
+                .prepare(`SELECT id
+           FROM runs
+           WHERE work_item_id = ?
+             AND status IN ('queued', 'running', 'waiting')
+           ORDER BY created_at ASC, id ASC`)
+                .all(binding.workItemId);
+            const activeRunIds = activeRuns.map((row) => String(row.id));
+            if (activeRunIds.length > 1) {
+                conflicts.push({
+                    sessionId: binding.sessionId,
+                    activeRunIds,
+                });
+            }
+        }
+        return { conflicts };
+    }
+    bindWorkItemToSession(sessionId, workItemId) {
+        this.withTransaction(() => {
+            const workItem = this.database
+                .prepare("SELECT session_id FROM work_items WHERE id = ?")
+                .get(workItemId);
+            if (!workItem) {
+                throw new Error(`WorkItem not found: ${workItemId}`);
+            }
+            const existingBinding = this.database
+                .prepare("SELECT id FROM work_items WHERE session_id = ? AND id != ? LIMIT 1")
+                .get(sessionId, workItemId);
+            if (existingBinding) {
+                throw new Error(`Session already bound to another WorkItem: ${sessionId}`);
+            }
+            if (workItem.session_id !== null
+                && workItem.session_id !== undefined
+                && String(workItem.session_id) !== sessionId) {
+                throw new Error(`WorkItem already bound to another Session: ${workItemId}`);
+            }
+            const now = new Date().toISOString();
+            this.database
+                .prepare("UPDATE work_items SET session_id = ?, updated_at = ? WHERE id = ?")
+                .run(sessionId, now, workItemId);
+            this.database
+                .prepare(`INSERT INTO session_runtime (
+            session_id, active_run_id, queue_state, queue_pause_reason,
+            last_event_sequence, version, updated_at
+          ) VALUES (?, NULL, 'ready', NULL, 0, 1, ?)
+          ON CONFLICT(session_id) DO NOTHING`)
+                .run(sessionId, now);
+        });
+    }
+    backfillRunTurns(sessionId, workItemId) {
+        return this.withTransaction(() => {
+            const runs = this.database
+                .prepare(`SELECT *
+           FROM runs
+           WHERE work_item_id = ?
+           ORDER BY created_at ASC, id ASC`)
+                .all(workItemId);
+            if (runs.length === 0) {
+                const events = this.database
+                    .prepare(`SELECT *
+             FROM domain_events
+             WHERE work_item_id = ?
+               AND type IN ('MESSAGE_RECEIVED', 'AGENT_EVENT')
+             ORDER BY sequence ASC`)
+                    .all(workItemId);
+                let activeGroup = false;
+                let syntheticCount = 0;
+                for (const row of events) {
+                    const event = toDomainEvent(row);
+                    if (event.type !== "MESSAGE_RECEIVED" && activeGroup)
+                        continue;
+                    const seed = event.type === "MESSAGE_RECEIVED"
+                        ? `message:${event.sequence}`
+                        : `agent:${event.sequence}`;
+                    const turnId = createMigrationId("turn", sessionId, seed);
+                    const runId = createMigrationId("run", sessionId, seed);
+                    const message = event.type === "MESSAGE_RECEIVED"
+                        ? legacyTurnMessageFromEvent(event)
+                        : emptyLegacyTurnMessage();
+                    const run = createLegacySyntheticRun({
+                        runId,
+                        turnId,
+                        workItemId,
+                        sessionId,
+                        occurredAt: event.occurredAt,
+                    });
+                    upsertLegacyRunTurn(this.database, {
+                        sessionId,
+                        workItemId,
+                        runId,
+                        turnId,
+                        queuePosition: syntheticCount + 1,
+                        message,
+                        createdAt: event.occurredAt,
+                    }, run, event.occurredAt);
+                    syntheticCount += 1;
+                    activeGroup = true;
+                }
+                return syntheticCount;
+            }
+            const messageRows = this.database
+                .prepare(`SELECT *
+           FROM domain_events
+           WHERE work_item_id = ? AND type = 'MESSAGE_RECEIVED'
+           ORDER BY sequence ASC`)
+                .all(workItemId);
+            const explicitMessagesByRunId = new Map();
+            const unscopedMessages = [];
+            for (const row of messageRows) {
+                const message = toDomainEvent(row);
+                if (message.runId) {
+                    explicitMessagesByRunId.set(message.runId, message);
+                }
+                else {
+                    unscopedMessages.push(message);
+                }
+            }
+            let unscopedIndex = 0;
+            let boundCount = 0;
+            for (const [index, row] of runs.entries()) {
+                const run = toRun(row);
+                const turnEvent = this.database
+                    .prepare(`SELECT *
+             FROM domain_events
+             WHERE work_item_id = ? AND run_id = ? AND type = 'TURN_DISPATCHED'
+             ORDER BY sequence ASC
+             LIMIT 1`)
+                    .get(workItemId, run.id);
+                const messageEvent = explicitMessagesByRunId.get(run.id)
+                    ?? unscopedMessages.at(unscopedIndex++)
+                    ?? undefined;
+                const turnId = turnEvent
+                    ? legacyTurnIdFromEvent(sessionId, turnEvent, run.id)
+                    : run.turnId
+                        ?? (messageEvent
+                            ? createMigrationId("turn", sessionId, `message:${messageEvent.sequence}`)
+                            : createMigrationId("turn", sessionId, `run:${run.id}`));
+                const queuePosition = index + 1;
+                const message = messageEvent
+                    ? legacyTurnMessageFromEvent(messageEvent)
+                    : emptyLegacyTurnMessage();
+                upsertLegacyRunTurn(this.database, {
+                    sessionId,
+                    workItemId,
+                    runId: run.id,
+                    turnId,
+                    queuePosition,
+                    message,
+                    createdAt: messageEvent?.occurredAt === undefined
+                        ? run.createdAt
+                        : String(messageEvent.occurredAt),
+                }, run, turnEvent ? String(turnEvent.occurred_at) : undefined);
+                boundCount += 1;
+            }
+            return boundCount;
+        });
+    }
+    ensureRuntimeFromRuns(sessionId) {
+        return this.withTransaction(() => {
+            const current = this.getSessionRuntime(sessionId);
+            const runs = this.database
+                .prepare(`SELECT *
+           FROM runs
+           WHERE session_id = ? OR work_item_id IN (
+             SELECT id FROM work_items WHERE session_id = ?
+           )
+           ORDER BY created_at ASC, id ASC`)
+                .all(sessionId, sessionId);
+            const activeRuns = runs
+                .map(toRun)
+                .filter((run) => isActiveRunStatus(run.status));
+            if (activeRuns.length > 1) {
+                const error = new Error("session_runtime_migration_conflict");
+                error.conflicts = [{
+                        sessionId,
+                        activeRunIds: activeRuns.map((run) => run.id),
+                    }];
+                throw error;
+            }
+            const latestRun = runs.length > 0
+                ? toRun(runs.at(-1))
+                : undefined;
+            const next = activeRuns[0]
+                ? {
+                    activeRunId: activeRuns[0].id,
+                    queueState: "ready",
+                    queuePauseReason: null,
+                }
+                : latestRun && (latestRun.status === "failed"
+                    || latestRun.status === "cancelled"
+                    || latestRun.status === "interrupted")
+                    ? {
+                        activeRunId: null,
+                        queueState: "paused",
+                        queuePauseReason: latestRun.status,
+                    }
+                    : {
+                        activeRunId: current?.activeRunId ?? null,
+                        queueState: current?.queueState ?? "ready",
+                        queuePauseReason: current?.queuePauseReason ?? null,
+                    };
+            const now = new Date().toISOString();
+            if (current) {
+                this.database
+                    .prepare(`UPDATE session_runtime
+             SET active_run_id = ?, queue_state = ?, queue_pause_reason = ?,
+               updated_at = ?
+             WHERE session_id = ?`)
+                    .run(next.activeRunId, next.queueState, next.queuePauseReason, now, sessionId);
+            }
+            else {
+                this.database
+                    .prepare(`INSERT INTO session_runtime (
+              session_id, active_run_id, queue_state, queue_pause_reason,
+              last_event_sequence, version, updated_at
+            ) VALUES (?, ?, ?, ?, 0, 1, ?)`)
+                    .run(sessionId, next.activeRunId, next.queueState, next.queuePauseReason, now);
+            }
+            return this.getSessionRuntime(sessionId);
+        });
+    }
+    getProjectionCursor(sessionId) {
+        const row = this.database
+            .prepare("SELECT last_projected_sequence FROM session_projection_cursors WHERE session_id = ?")
+            .get(sessionId);
+        return row ? Number(row.last_projected_sequence) : 0;
+    }
+    backfillSessionProjection(sessionId, workItemId, batchSize) {
+        return this.withTransaction(() => {
+            const cursor = this.getProjectionCursor(sessionId);
+            const boundedBatchSize = Math.max(1, Math.min(1_000, Math.floor(batchSize)));
+            const projectionBindings = this.database
+                .prepare(`SELECT st.turn_id, st.dispatched_run_id
+           FROM session_turns st
+           WHERE st.session_id = ?
+             AND NOT EXISTS (
+               SELECT 1
+               FROM domain_events de
+               WHERE de.run_id = st.dispatched_run_id
+                 AND de.type = 'MESSAGE_RECEIVED'
+             )
+           ORDER BY queue_position ASC, turn_id ASC`)
+                .all(sessionId);
+            const priorUnscopedMessages = this.database
+                .prepare(`SELECT COUNT(*) AS count
+           FROM domain_events
+           WHERE work_item_id = ? AND type = 'MESSAGE_RECEIVED'
+             AND run_id IS NULL AND sequence <= ?`)
+                .get(workItemId, cursor);
+            const bindings = projectionBindings.map((row) => ({
+                turnId: String(row.turn_id),
+                runId: String(row.dispatched_run_id),
+            }));
+            const bindingIndex = Number(priorUnscopedMessages?.count ?? 0);
+            const bindingState = {
+                index: bindingIndex,
+                bindings,
+            };
+            const priorUnscopedMessageRow = bindingIndex > 0
+                ? this.database
+                    .prepare(`SELECT *
+               FROM domain_events
+               WHERE work_item_id = ? AND type = 'MESSAGE_RECEIVED'
+                 AND run_id IS NULL AND sequence <= ?
+               ORDER BY sequence DESC
+               LIMIT 1`)
+                    .get(workItemId, cursor)
+                : undefined;
+            const rows = this.database
+                .prepare(`SELECT *
+           FROM domain_events
+           WHERE work_item_id = ? AND sequence > ?
+           ORDER BY sequence ASC
+           LIMIT ?`)
+                .all(workItemId, cursor, boundedBatchSize);
+            if (!rows.length) {
+                return 0;
+            }
+            const priorBinding = bindingIndex > 0
+                ? bindings.at(bindingIndex - 1)
+                : undefined;
+            const priorMessage = priorUnscopedMessageRow
+                ? toDomainEvent(priorUnscopedMessageRow)
+                : undefined;
+            let currentSynthetic = priorBinding
+                ? {
+                    ...priorBinding,
+                    queuePosition: bindingIndex,
+                }
+                : priorMessage
+                    ? {
+                        runId: createMigrationId("run", sessionId, `message:${priorMessage.sequence}`),
+                        turnId: createMigrationId("turn", sessionId, `message:${priorMessage.sequence}`),
+                        queuePosition: bindingIndex,
+                    }
+                    : null;
+            let projected = 0;
+            for (const row of rows) {
+                const event = toDomainEvent(row);
+                const projectedEvent = normalizeLegacyProjectionEvent(this.database, sessionId, event, currentSynthetic, bindingState);
+                currentSynthetic = projectedEvent.syntheticGroup ?? currentSynthetic;
+                projectSessionEvent(this.database, sessionId, projectedEvent.event);
+                projected += 1;
+            }
+            return projected;
+        });
+    }
+    listWorkItems() {
+        const rows = this.database
+            .prepare("SELECT * FROM work_items ORDER BY updated_at DESC, rowid ASC")
+            .all();
+        return rows.map(toWorkItem);
+    }
+    appendEvent(input) {
+        if (!this.getWorkItem(input.workItemId)) {
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        }
+        return this.withTransaction(() => {
+            const event = this.appendEventInTransaction(input);
+            return event;
+        });
+    }
+    appendLeasedRunEvent(owner, input) {
+        return this.withTransaction(() => {
+            const lease = this.database
+                .prepare(`SELECT 1 FROM runs
+           WHERE id = ? AND session_id = ? AND status = 'running'
+             AND lease_owner = ? AND lease_expires_at >= ?`)
+                .get(input.runId, input.sessionId, owner, new Date().toISOString());
+            if (!lease)
+                throw new Error("run_lease_lost");
+            const event = appendSessionEventInTransaction(this.database, input);
+            return event;
+        });
+    }
+    appendEventOnce(input) {
+        if (!this.getWorkItem(input.workItemId)) {
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        }
+        return this.withTransaction(() => {
+            const existing = this.database
+                .prepare("SELECT * FROM domain_events WHERE work_item_id = ? AND input_hash = ? LIMIT 1")
+                .get(input.workItemId, input.inputHash);
+            const event = existing ? toDomainEvent(existing) : this.appendEventInTransaction(input);
+            return event;
+        });
+    }
+    listEvents(workItemId, afterSequence = 0) {
+        const rows = this.database
+            .prepare(`SELECT * FROM domain_events
+         WHERE work_item_id = ? AND sequence > ?
+         ORDER BY sequence ASC`)
+            .all(workItemId, afterSequence);
+        return rows.map(toDomainEvent);
+    }
+    listEventsByTarget(target) {
+        const rows = this.database
+            .prepare(`SELECT * FROM domain_events
+         WHERE target = ?
+         ORDER BY sequence ASC`)
+            .all(target);
+        return rows.map(toDomainEvent);
+    }
+    listEventsPage(workItemId, afterSequence, limit) {
+        const boundedLimit = Math.max(1, Math.min(501, Math.floor(limit)));
+        const rows = this.database
+            .prepare(`SELECT * FROM domain_events
+         WHERE work_item_id = ? AND sequence > ?
+         ORDER BY sequence ASC
+         LIMIT ?`)
+            .all(workItemId, afterSequence, boundedLimit);
+        return rows.map(toDomainEvent);
+    }
+    listRecentEvents(workItemId, limit) {
+        const boundedLimit = Math.max(1, Math.min(10_000, Math.floor(limit)));
+        const rows = this.database
+            .prepare(`SELECT * FROM domain_events
+         WHERE work_item_id = ?
+         ORDER BY sequence DESC
+         LIMIT ?`)
+            .all(workItemId, boundedLimit);
+        return rows.reverse().map(toDomainEvent);
+    }
+    listEventInputHashes(workItemId) {
+        const rows = this.database
+            .prepare(`SELECT input_hash FROM domain_events
+         WHERE work_item_id = ? AND input_hash IS NOT NULL`)
+            .all(workItemId);
+        return new Set(rows.map((row) => String(row.input_hash)));
+    }
+    sequenceForEventId(workItemId, eventId) {
+        const row = this.database
+            .prepare("SELECT sequence FROM domain_events WHERE work_item_id = ? AND event_id = ?")
+            .get(workItemId, eventId);
+        return row?.sequence ? Number(row.sequence) : 0;
+    }
+    savePlan(input) {
+        const plan = {
+            schemaVersion: 1,
+            planId: input.planId,
+            source: input.source,
+            workflowId: input.workflowId,
+            definitionRevision: input.definitionRevision,
+            planIrHash: input.planIrHash ?? null,
+            sessionId: input.sessionId ?? null,
+            runId: input.runId ?? null,
+            steps: input.steps.map(clonePlanStep),
+            createdAt: new Date().toISOString(),
+        };
+        this.database
+            .prepare(`INSERT INTO plans (
+          plan_id, schema_version, source, workflow_id, definition_revision,
+          plan_ir_hash, session_id, run_id, steps, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(plan_id) DO UPDATE SET
+          source = excluded.source,
+          workflow_id = excluded.workflow_id,
+          definition_revision = excluded.definition_revision,
+          plan_ir_hash = excluded.plan_ir_hash,
+          session_id = excluded.session_id,
+          run_id = excluded.run_id,
+          steps = excluded.steps`)
+            .run(plan.planId, plan.schemaVersion, plan.source, plan.workflowId, plan.definitionRevision, plan.planIrHash, plan.sessionId, plan.runId, JSON.stringify(plan.steps), plan.createdAt);
+        return this.getPlan(plan.planId);
+    }
+    getPlan(planId) {
+        const row = this.database.prepare("SELECT * FROM plans WHERE plan_id = ?").get(planId);
+        return row ? toPlan(row) : undefined;
+    }
+    getPlanForRun(runId) {
+        const row = this.database.prepare("SELECT * FROM plans WHERE run_id = ?").get(runId);
+        return row ? toPlan(row) : undefined;
+    }
+    createRun(input) {
+        const workItem = this.getWorkItem(input.workItemId);
+        if (!workItem) {
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        }
+        const plan = input.planId ? this.getPlan(input.planId) : undefined;
+        if (input.planId && !plan) {
+            throw new Error(`Plan not found: ${input.planId}`);
+        }
+        if (plan?.runId && input.id && plan.runId !== input.id) {
+            throw new Error(`Plan ${plan.planId} is bound to another Run`);
+        }
+        const now = new Date().toISOString();
+        const run = {
+            schemaVersion: 1,
+            id: input.id ?? createId("run"),
+            workItemId: input.workItemId,
+            sessionId: input.sessionId ?? workItem.sessionId,
+            turnId: input.turnId ?? null,
+            mode: input.mode,
+            status: "queued",
+            executionKind: input.executionKind,
+            agentId: input.agentId ?? workItem.agentId,
+            planId: input.planId ?? null,
+            planIrHash: input.planIrHash ?? plan?.planIrHash ?? null,
+            workflowRevision: input.workflowRevision ?? plan?.definitionRevision ?? workItem.workflowRevision,
+            terminalReason: null,
+            replaySafety: "safe",
+            leaseOwner: null,
+            leaseExpiresAt: null,
+            cancelRequestedAt: null,
+            cancelDeadlineAt: null,
+            providerSessionId: input.providerSessionId ?? null,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.withTransaction(() => {
+            this.database
+                .prepare(`INSERT INTO runs (
+            id, schema_version, work_item_id, session_id, turn_id, mode, status,
+            execution_kind, agent_id, plan_id, plan_ir_hash, workflow_revision, terminal_reason,
+            replay_safety, lease_owner, lease_expires_at, cancel_requested_at,
+            cancel_deadline_at, provider_session_id, created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(run.id, run.schemaVersion, run.workItemId, run.sessionId, run.turnId, run.mode, run.status, run.executionKind, run.agentId, run.planId, run.planIrHash, run.workflowRevision, run.terminalReason, run.replaySafety, run.leaseOwner, run.leaseExpiresAt, run.cancelRequestedAt, run.cancelDeadlineAt, run.providerSessionId ?? null, run.createdAt, run.updatedAt);
+            this.appendEventInTransaction({
+                workItemId: run.workItemId,
+                runId: run.id,
+                type: "RUN_CREATED",
+                actor: "system",
+                target: run.id,
+                payload: {
+                    mode: run.mode,
+                    agent_id: run.agentId,
+                    plan_id: run.planId,
+                    workflow_revision: run.workflowRevision,
+                    execution_kind: run.executionKind,
+                },
+            });
+            if (plan) {
+                this.appendEventInTransaction({
+                    workItemId: run.workItemId,
+                    runId: run.id,
+                    type: "PLAN_VALIDATED",
+                    actor: "system",
+                    target: plan.planId,
+                    payload: {
+                        workflow_id: plan.workflowId,
+                        definition_revision: plan.definitionRevision,
+                        source: plan.source,
+                        step_count: plan.steps.length,
+                    },
+                });
+            }
+        });
+        return run;
+    }
+    getRun(runId) {
+        const row = this.database.prepare("SELECT * FROM runs WHERE id = ?").get(runId);
+        return row ? toRun(row) : undefined;
+    }
+    listRuns(workItemId) {
+        const rows = this.database
+            .prepare("SELECT * FROM runs WHERE work_item_id = ? ORDER BY created_at ASC")
+            .all(workItemId);
+        return rows.map(toRun);
+    }
+    listRunsByStatus(statuses) {
+        if (!statuses.length)
+            return [];
+        const placeholders = statuses.map(() => "?").join(", ");
+        const rows = this.database
+            .prepare(`SELECT * FROM runs WHERE status IN (${placeholders}) ORDER BY created_at ASC`)
+            .all(...statuses);
+        return rows.map(toRun);
+    }
+    updateRunStatus(runId, status) {
+        const now = new Date().toISOString();
+        const result = this.database
+            .prepare("UPDATE runs SET status = ?, updated_at = ? WHERE id = ?")
+            .run(status, now, runId);
+        if (Number(result.changes) !== 1)
+            throw new Error(`Run not found: ${runId}`);
+        return this.getRun(runId);
+    }
+    updateRunControl(runId, patch) {
+        const current = this.getRun(runId);
+        if (!current)
+            throw new Error(`Run not found: ${runId}`);
+        const next = {
+            ...current,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        this.database
+            .prepare(`UPDATE runs
+         SET status = ?, terminal_reason = ?, replay_safety = ?,
+           lease_owner = ?, lease_expires_at = ?, cancel_requested_at = ?,
+           cancel_deadline_at = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(next.status, next.terminalReason, next.replaySafety, next.leaseOwner, next.leaseExpiresAt, next.cancelRequestedAt, next.cancelDeadlineAt, next.updatedAt, runId);
+        return this.getRun(runId);
+    }
+    claimRun(runId, owner, now, expiresAt) {
+        return this.withSessionTransaction((tx) => tx.claimRun(runId, owner, now, expiresAt));
+    }
+    renewRunLease(runId, owner, now, expiresAt) {
+        return this.withSessionTransaction((tx) => tx.renewRunLease(runId, owner, now, expiresAt));
+    }
+    reclaimRunLease(runId, owner, expiresAt) {
+        return this.withSessionTransaction((tx) => tx.reclaimRunLease(runId, owner, expiresAt));
+    }
+    updateLeasedRunReplaySafety(runId, owner, replaySafety) {
+        const now = new Date().toISOString();
+        const result = this.database
+            .prepare(`UPDATE runs
+         SET replay_safety = ?, updated_at = ?
+         WHERE id = ? AND status = 'running' AND lease_owner = ?
+           AND lease_expires_at >= ?`)
+            .run(replaySafety, now, runId, owner, now);
+        if (Number(result.changes) !== 1) {
+            throw new Error("run_lease_lost");
+        }
+        return this.getRun(runId);
+    }
+    listExpiredRunningRuns(now, limit) {
+        return createSqliteSessionRuntimeTransaction(this.database)
+            .transaction.listExpiredRunningRuns(now, limit);
+    }
+    listCancellationDeadlineRuns(now, limit) {
+        return createSqliteSessionRuntimeTransaction(this.database)
+            .transaction.listCancellationDeadlineRuns(now, limit);
+    }
+    listDeliveries(channel, surfaceMessageId) {
+        return createSqliteSessionRuntimeTransaction(this.database)
+            .transaction.listDeliveries(channel, surfaceMessageId);
+    }
+    claimProviderSession(input) {
+        return this.withSessionTransaction((tx) => tx.claimProviderSession(input));
+    }
+    renewProviderSession(input) {
+        return this.withSessionTransaction((tx) => tx.renewProviderSession(input));
+    }
+    releaseProviderSession(input) {
+        return this.withSessionTransaction((tx) => tx.releaseProviderSession(input));
+    }
+    findLiveProviderLease(agentId, providerSessionId, now) {
+        return createSqliteSessionRuntimeTransaction(this.database)
+            .transaction.findLiveProviderLease(agentId, providerSessionId, now);
+    }
+    setSessionProviderSessionId(sessionId, providerSessionId) {
+        this.withSessionTransaction((tx) => tx.setSessionProviderSessionId(sessionId, providerSessionId));
+    }
+    startRunAttempt(runId) {
+        if (!this.getRun(runId))
+            throw new Error(`Run not found: ${runId}`);
+        return this.withTransaction(() => {
+            const row = this.database
+                .prepare(`SELECT COALESCE(MAX(attempt_number), 0) + 1 AS next_attempt
+           FROM run_attempts WHERE run_id = ?`)
+                .get(runId);
+            const attemptId = `attempt_${randomUUID().replaceAll("-", "")}`;
+            this.database
+                .prepare(`INSERT INTO run_attempts (
+            attempt_id, run_id, attempt_number, started_at, ended_at,
+            provider_error, side_effect_boundary
+          ) VALUES (?, ?, ?, ?, NULL, NULL, 'safe')`)
+                .run(attemptId, runId, Number(row?.next_attempt ?? 1), new Date().toISOString());
+            const attempt = this.database
+                .prepare("SELECT * FROM run_attempts WHERE attempt_id = ?")
+                .get(attemptId);
+            return toRunAttempt(attempt);
+        });
+    }
+    finishRunAttempt(attemptId, input) {
+        const result = this.database
+            .prepare(`UPDATE run_attempts
+         SET ended_at = ?, provider_error = ?,
+           side_effect_boundary = ?
+         WHERE attempt_id = ? AND ended_at IS NULL`)
+            .run(new Date().toISOString(), input.providerError, input.sideEffectBoundary, attemptId);
+        if (Number(result.changes) !== 1) {
+            throw new Error(`Open Run attempt not found: ${attemptId}`);
+        }
+        const row = this.database
+            .prepare("SELECT * FROM run_attempts WHERE attempt_id = ?")
+            .get(attemptId);
+        return toRunAttempt(row);
+    }
+    listRunAttempts(runId) {
+        const rows = this.database
+            .prepare(`SELECT * FROM run_attempts
+         WHERE run_id = ? ORDER BY attempt_number ASC`)
+            .all(runId);
+        return rows.map(toRunAttempt);
+    }
+    findTerminalEventForRun(runId) {
+        const row = this.database
+            .prepare(`SELECT * FROM domain_events
+         WHERE run_id = ?
+           AND type IN (
+             'RUN_SUCCEEDED', 'RUN_FAILED',
+             'RUN_CANCELLED', 'RUN_INTERRUPTED'
+           )
+         ORDER BY sequence DESC
+         LIMIT 1`)
+            .get(runId);
+        return row ? toDomainEvent(row) : undefined;
+    }
+    requeueRun(runId) {
+        return this.updateRunStatus(runId, "queued");
+    }
+    putIdempotencyResponse(namespace, key, response, createdAt) {
+        this.database
+            .prepare(`INSERT OR IGNORE INTO idempotency_responses
+         (namespace, idempotency_key, response, created_at) VALUES (?, ?, ?, ?)`)
+            .run(namespace, key, JSON.stringify(response), createdAt ?? new Date().toISOString());
+    }
+    getIdempotencyRecord(namespace, key) {
+        const row = this.database
+            .prepare("SELECT response, created_at FROM idempotency_responses WHERE namespace = ? AND idempotency_key = ?")
+            .get(namespace, key);
+        if (!row?.response)
+            return undefined;
+        return { response: JSON.parse(row.response), createdAt: row.created_at ?? "" };
+    }
+    getIdempotencyResponse(namespace, key) {
+        return this.getIdempotencyRecord(namespace, key)?.response;
+    }
+    deleteIdempotencyResponse(namespace, key) {
+        this.database
+            .prepare("DELETE FROM idempotency_responses WHERE namespace = ? AND idempotency_key = ?")
+            .run(namespace, key);
+    }
+    createMessageAttachment(input) {
+        if (!this.getWorkItem(input.workItemId))
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(input.dataBase64) || input.dataBase64.length % 4 === 1) {
+            throw new Error("attachment data must be valid base64");
+        }
+        const bytes = Buffer.from(input.dataBase64, "base64");
+        if (bytes.length === 0)
+            throw new Error("attachment data cannot be empty");
+        if (bytes.length > 10_000_000)
+            throw new Error("attachment content exceeds 10 MB");
+        const record = {
+            schemaVersion: 1,
+            id: input.id ?? createId("attachment"),
+            workItemId: input.workItemId,
+            name: path.basename(input.name || "attachment"),
+            mimeType: input.mimeType || "application/octet-stream",
+            dataBase64: input.dataBase64,
+            byteSize: bytes.length,
+            contentHash: `sha256:${createHash("sha256").update(bytes).digest("hex")}`,
+            createdAt: new Date().toISOString(),
+        };
+        this.database
+            .prepare(`INSERT INTO message_attachments (
+          id, schema_version, work_item_id, name, mime_type, data_base64,
+          byte_size, content_hash, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.id, record.schemaVersion, record.workItemId, record.name, record.mimeType, record.dataBase64, record.byteSize, record.contentHash, record.createdAt);
+        return record;
+    }
+    getMessageAttachment(id) {
+        const row = this.database.prepare("SELECT * FROM message_attachments WHERE id = ?").get(id);
+        return row ? toMessageAttachment(row) : undefined;
+    }
+    listMessageAttachments(workItemId, ids) {
+        const rows = this.database
+            .prepare("SELECT * FROM message_attachments WHERE work_item_id = ? ORDER BY created_at ASC")
+            .all(workItemId);
+        const attachments = rows.map(toMessageAttachment);
+        if (!ids)
+            return attachments;
+        const byId = new Map(attachments.map((attachment) => [attachment.id, attachment]));
+        return ids.flatMap((id) => {
+            const attachment = byId.get(id);
+            return attachment ? [attachment] : [];
+        });
+    }
+    createArtifact(input) {
+        if (!this.getWorkItem(input.workItemId))
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        if (!this.getRun(input.runId))
+            throw new Error(`Run not found: ${input.runId}`);
+        if (input.content.length > 10_000_000)
+            throw new Error("artifact content exceeds 10 MB");
+        const record = {
+            id: input.id ?? createId("artifact"),
+            workItemId: input.workItemId,
+            runId: input.runId,
+            stepId: input.stepId ?? null,
+            kind: input.kind ?? "output",
+            name: input.name,
+            mimeType: input.mimeType ?? "text/plain",
+            content: input.content,
+            contentHash: `sha256:${createHash("sha256").update(input.content).digest("hex")}`,
+            metadata: { ...(input.metadata ?? {}) },
+            createdAt: new Date().toISOString(),
+        };
+        this.database
+            .prepare(`INSERT INTO artifacts (
+          id, work_item_id, run_id, step_id, kind, name, mime_type, content,
+          content_hash, metadata, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.id, record.workItemId, record.runId, record.stepId, record.kind, record.name, record.mimeType, record.content, record.contentHash, JSON.stringify(record.metadata), record.createdAt);
+        this.appendEvent({
+            workItemId: record.workItemId,
+            runId: record.runId,
+            type: "ARTIFACT_CREATED",
+            actor: input.actor ?? "adapter",
+            target: record.id,
+            resultRef: `artifact://${record.id}`,
+            payload: {
+                artifact_id: record.id,
+                step_id: record.stepId,
+                kind: record.kind,
+                name: record.name,
+                mime_type: record.mimeType,
+                content_hash: record.contentHash,
+            },
+        });
+        return record;
+    }
+    getArtifact(id) {
+        const row = this.database.prepare("SELECT * FROM artifacts WHERE id = ?").get(id);
+        return row ? toArtifact(row) : undefined;
+    }
+    listArtifacts(runId) {
+        return this.database.prepare("SELECT * FROM artifacts WHERE run_id = ? ORDER BY created_at ASC").all(runId).map(toArtifact);
+    }
+    recordVerification(input) {
+        if (!this.getWorkItem(input.workItemId))
+            throw new Error(`WorkItem not found: ${input.workItemId}`);
+        if (!this.getRun(input.runId))
+            throw new Error(`Run not found: ${input.runId}`);
+        const record = {
+            id: input.id ?? createId("verification"),
+            workItemId: input.workItemId,
+            runId: input.runId,
+            stepId: input.stepId ?? null,
+            validator: input.validator,
+            status: input.status,
+            summary: input.summary,
+            artifactIds: [...(input.artifactIds ?? [])],
+            createdAt: new Date().toISOString(),
+        };
+        this.database
+            .prepare(`INSERT INTO verifications (
+          id, work_item_id, run_id, step_id, validator, status, summary,
+          artifact_ids, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(record.id, record.workItemId, record.runId, record.stepId, record.validator, record.status, record.summary, JSON.stringify(record.artifactIds), record.createdAt);
+        this.appendEvent({
+            workItemId: record.workItemId,
+            runId: record.runId,
+            type: "VERIFICATION_COMPLETED",
+            actor: "adapter",
+            target: record.stepId ?? record.runId,
+            resultRef: record.artifactIds[0] ? `artifact://${record.artifactIds[0]}` : null,
+            payload: {
+                verification_id: record.id,
+                step_id: record.stepId,
+                validator: record.validator,
+                status: record.status,
+                summary: record.summary,
+                artifact_ids: record.artifactIds,
+            },
+        });
+        return record;
+    }
+    listVerifications(runId) {
+        return this.database.prepare("SELECT * FROM verifications WHERE run_id = ? ORDER BY created_at ASC").all(runId).map(toVerification);
+    }
+    close() {
+        if (this.database.isOpen)
+            this.database.close();
+    }
+    appendEventInTransaction(input) {
+        const workItem = this.database
+            .prepare("SELECT session_id FROM work_items WHERE id = ?")
+            .get(input.workItemId);
+        if (workItem?.session_id) {
+            return appendSessionEventInTransaction(this.database, {
+                ...input,
+                sessionId: String(workItem.session_id),
+            });
+        }
+        const sequenceRow = this.database
+            .prepare("SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM domain_events WHERE work_item_id = ?")
+            .get(input.workItemId);
+        const sequence = Number(sequenceRow?.next_sequence ?? 1);
+        const event = {
+            schemaVersion: 1,
+            eventId: createId("evt"),
+            sequence,
+            workItemId: input.workItemId,
+            runId: input.runId ?? null,
+            executionKind: resolveRunExecutionKind(this.database, input.runId ?? null),
+            type: input.type,
+            occurredAt: new Date().toISOString(),
+            actor: input.actor,
+            target: input.target ?? null,
+            inputHash: input.inputHash ?? null,
+            resultRef: input.resultRef ?? null,
+            payload: { ...(input.payload ?? {}) },
+        };
+        this.database
+            .prepare(`INSERT INTO domain_events (
+          event_id, schema_version, sequence, work_item_id, run_id, execution_kind, type,
+          occurred_at, actor, target, input_hash, result_ref, payload
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(event.eventId, event.schemaVersion, event.sequence, event.workItemId, event.runId, event.executionKind, event.type, event.occurredAt, event.actor, event.target, event.inputHash, event.resultRef, JSON.stringify(event.payload));
+        this.database
+            .prepare(`UPDATE session_runtime
+         SET last_event_sequence = ?, updated_at = ?
+         WHERE session_id = (
+           SELECT session_id FROM work_items WHERE id = ?
+         )`)
+            .run(event.sequence, event.occurredAt, event.workItemId);
+        const nextStatus = STATUS_BY_EVENT[event.type];
+        if (nextStatus) {
+            this.database
+                .prepare("UPDATE work_items SET status = ?, updated_at = ? WHERE id = ?")
+                .run(nextStatus, event.occurredAt, event.workItemId);
+        }
+        return event;
+    }
+}
+function createId(prefix) {
+    return `${prefix}_${randomUUID().replaceAll("-", "")}`;
+}
+function createMigrationId(prefix, sessionId, seed) {
+    return `${prefix}_mig_${createHash("sha256")
+        .update(`${sessionId}\0${seed}`)
+        .digest("hex")
+        .slice(0, 24)}`;
+}
+function createLegacySyntheticRun(input) {
+    return {
+        schemaVersion: 1,
+        id: input.runId,
+        workItemId: input.workItemId,
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        mode: "auto",
+        status: "succeeded",
+        executionKind: "agent",
+        agentId: null,
+        planId: null,
+        planIrHash: null,
+        workflowRevision: null,
+        terminalReason: "legacy_history_import",
+        replaySafety: "safe",
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        cancelRequestedAt: null,
+        cancelDeadlineAt: null,
+        createdAt: input.occurredAt,
+        updatedAt: input.occurredAt,
+    };
+}
+function isActiveRunStatus(status) {
+    return status === "queued" || status === "running" || status === "waiting";
+}
+function legacyTurnMessageFromEvent(event) {
+    const payload = event.payload;
+    return {
+        text: typeof payload.message === "string" ? payload.message : "",
+        attachmentIds: Array.isArray(payload.attachment_ids)
+            ? payload.attachment_ids.map((value) => String(value))
+            : [],
+        executionKind: "agent",
+        model: null,
+        effort: null,
+        permissionMode: null,
+        plan: null,
+    };
+}
+function emptyLegacyTurnMessage() {
+    return {
+        text: "",
+        attachmentIds: [],
+        executionKind: "agent",
+        model: null,
+        effort: null,
+        permissionMode: null,
+        plan: null,
+    };
+}
+function legacyTurnIdFromEvent(sessionId, event, runId) {
+    const target = event.target === null || event.target === undefined
+        ? null
+        : String(event.target);
+    if (target)
+        return target;
+    return createMigrationId("turn", sessionId, `run:${runId}`);
+}
+function nextLegacyQueuePosition(database, sessionId) {
+    const row = database
+        .prepare(`SELECT COALESCE(MAX(queue_position), 0) + 1 AS next_position
+         FROM session_turns
+         WHERE session_id = ?`)
+        .get(sessionId);
+    return Number(row?.next_position ?? 1);
+}
+function ensureSyntheticTimelineTurn(database, sessionId, turnId, runId, startedSequence, occurredAt) {
+    const existing = database
+        .prepare(`SELECT 1 FROM session_timeline_turns
+       WHERE turn_id = ? OR run_id = ?`)
+        .get(turnId, runId);
+    if (existing)
+        return;
+    const row = database
+        .prepare(`SELECT COALESCE(MAX(timeline_index), 0) + 1 AS next_index
+       FROM session_timeline_turns
+       WHERE session_id = ?`)
+        .get(sessionId);
+    database
+        .prepare(`INSERT INTO session_timeline_turns (
+        session_id, timeline_index, turn_id, run_id, started_sequence,
+        ended_sequence, status, updated_at
+      ) VALUES (?, ?, ?, ?, ?, NULL, 'dispatched', ?)`)
+        .run(sessionId, Number(row?.next_index ?? 1), turnId, runId, startedSequence, occurredAt);
+}
+function upsertLegacyRunTurn(database, input, run, dispatchOccurredAt) {
+    database
+        .prepare(`INSERT INTO runs (
+        id, schema_version, work_item_id, session_id, turn_id, mode, status,
+        execution_kind, agent_id, plan_id, plan_ir_hash, workflow_revision, terminal_reason,
+        replay_safety, lease_owner, lease_expires_at, cancel_requested_at,
+        cancel_deadline_at, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        work_item_id = excluded.work_item_id,
+        session_id = excluded.session_id,
+        turn_id = excluded.turn_id`)
+        .run(input.runId, run.schemaVersion, input.workItemId, input.sessionId, input.turnId, run.mode, run.status, run.executionKind, run.agentId, run.planId, run.planIrHash, run.workflowRevision, run.terminalReason, run.replaySafety, run.leaseOwner, run.leaseExpiresAt, run.cancelRequestedAt, run.cancelDeadlineAt, run.createdAt, run.updatedAt);
+    upsertSessionTurnBinding(database, {
+        turnId: input.turnId,
+        sessionId: input.sessionId,
+        queuePosition: input.queuePosition,
+        message: input.message,
+        dispatchedRunId: input.runId,
+        createdAt: input.createdAt,
+        dispatchedAt: dispatchOccurredAt ?? input.createdAt,
+    });
+}
+function upsertSessionTurnBinding(database, input) {
+    const existingTurn = database
+        .prepare(`SELECT turn_id, queue_position
+       FROM session_turns
+       WHERE turn_id = ? OR dispatched_run_id = ? OR (
+         session_id = ? AND queue_position = ?
+       )
+       ORDER BY
+         CASE
+           WHEN turn_id = ? THEN 0
+           WHEN dispatched_run_id = ? THEN 1
+           ELSE 2
+         END,
+         queue_position ASC
+       LIMIT 1`)
+        .get(input.turnId, input.dispatchedRunId, input.sessionId, input.queuePosition, input.turnId, input.dispatchedRunId);
+    if (existingTurn?.turn_id) {
+        database
+            .prepare(`UPDATE session_turns
+         SET session_id = ?, status = 'dispatched',
+           message_json = ?, dispatched_run_id = ?, created_at = ?,
+           dispatched_at = ?, cancelled_at = NULL
+         WHERE turn_id = ?`)
+            .run(input.sessionId, JSON.stringify(input.message), input.dispatchedRunId, input.createdAt, input.dispatchedAt, String(existingTurn.turn_id));
+        return;
+    }
+    database
+        .prepare(`INSERT INTO session_turns (
+        turn_id, session_id, queue_position, status, message_json, version,
+        dispatched_run_id, created_at, dispatched_at, cancelled_at
+      ) VALUES (?, ?, ?, 'dispatched', ?, 2, ?, ?, ?, NULL)`)
+        .run(input.turnId, input.sessionId, input.queuePosition, JSON.stringify(input.message), input.dispatchedRunId, input.createdAt, input.dispatchedAt);
+}
+function normalizeLegacyProjectionEvent(database, sessionId, event, currentSynthetic, bindingState) {
+    if (event.runId) {
+        if (event.type === "MESSAGE_RECEIVED"
+            || event.type === "AGENT_EVENT"
+            || event.type === "APPROVAL_REQUESTED") {
+            ensureSyntheticProjectionTurnForRun(database, sessionId, event);
+        }
+        return { event, syntheticGroup: currentSynthetic };
+    }
+    let syntheticGroup = currentSynthetic;
+    if (event.type !== "MESSAGE_RECEIVED" && event.type !== "AGENT_EVENT") {
+        return { event, syntheticGroup };
+    }
+    if (event.type === "MESSAGE_RECEIVED" || !syntheticGroup) {
+        const binding = bindingState && bindingState.index < bindingState.bindings.length
+            ? bindingState.bindings[bindingState.index++]
+            : undefined;
+        if (binding) {
+            syntheticGroup = {
+                runId: binding.runId,
+                turnId: binding.turnId,
+                queuePosition: bindingState ? bindingState.index : nextLegacyQueuePosition(database, sessionId),
+            };
+            ensureSyntheticTimelineTurn(database, sessionId, binding.turnId, binding.runId, event.sequence, event.occurredAt);
+        }
+        else {
+            const seed = event.type === "MESSAGE_RECEIVED"
+                ? `message:${event.sequence}`
+                : `agent:${event.sequence}`;
+            syntheticGroup = {
+                runId: createMigrationId("run", sessionId, seed),
+                turnId: createMigrationId("turn", sessionId, seed),
+                queuePosition: nextLegacyQueuePosition(database, sessionId),
+            };
+            ensureSyntheticTimelineTurn(database, sessionId, syntheticGroup.turnId, syntheticGroup.runId, event.sequence, event.occurredAt);
+        }
+    }
+    else {
+        ensureSyntheticTimelineTurn(database, sessionId, syntheticGroup.turnId, syntheticGroup.runId, event.sequence, event.occurredAt);
+    }
+    if (!syntheticGroup) {
+        throw new Error("legacy synthetic projection group missing");
+    }
+    return {
+        event: {
+            ...event,
+            runId: syntheticGroup.runId,
+            target: event.target ?? syntheticGroup.turnId,
+        },
+        syntheticGroup,
+    };
+}
+function ensureSyntheticProjectionTurnForRun(database, sessionId, event) {
+    const run = database
+        .prepare("SELECT * FROM runs WHERE id = ?")
+        .get(event.runId);
+    if (!run)
+        return;
+    const turnId = run.turn_id === null || run.turn_id === undefined
+        ? legacyTurnIdFromEvent(sessionId, event, event.runId)
+        : String(run.turn_id);
+    ensureSyntheticTimelineTurn(database, sessionId, turnId, event.runId, event.sequence, event.occurredAt);
+}
+function toWorkItem(row) {
+    return {
+        schemaVersion: Number(row.schema_version),
+        id: String(row.id),
+        title: String(row.title),
+        status: String(row.status),
+        mode: String(row.mode),
+        conversationId: String(row.conversation_id),
+        sessionId: row.session_id === null || row.session_id === undefined
+            ? null
+            : String(row.session_id),
+        agentId: row.agent_id === null ? null : String(row.agent_id),
+        workflowId: row.workflow_id === null ? null : String(row.workflow_id),
+        workflowRevision: row.workflow_revision === null ? null : String(row.workflow_revision),
+        workspaceScope: JSON.parse(String(row.workspace_scope)),
+        identifiers: JSON.parse(String(row.identifiers)),
+        contextRevision: Number(row.context_revision),
+        riskLevel: String(row.risk_level),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function toDomainEvent(row) {
+    const runId = row.run_id === null ? null : String(row.run_id);
+    return {
+        schemaVersion: Number(row.schema_version),
+        eventId: String(row.event_id),
+        sequence: Number(row.sequence),
+        workItemId: String(row.work_item_id),
+        runId,
+        executionKind: executionKindValue(row.execution_kind, runId),
+        type: String(row.type),
+        occurredAt: String(row.occurred_at),
+        actor: String(row.actor),
+        target: row.target === null ? null : String(row.target),
+        inputHash: row.input_hash === null ? null : String(row.input_hash),
+        resultRef: row.result_ref === null ? null : String(row.result_ref),
+        payload: JSON.parse(String(row.payload)),
+    };
+}
+function toRun(row) {
+    return {
+        schemaVersion: Number(row.schema_version),
+        id: String(row.id),
+        workItemId: String(row.work_item_id),
+        sessionId: row.session_id === null || row.session_id === undefined
+            ? null
+            : String(row.session_id),
+        turnId: row.turn_id === null || row.turn_id === undefined
+            ? null
+            : String(row.turn_id),
+        mode: String(row.mode),
+        status: String(row.status),
+        executionKind: executionKindValue(row.execution_kind, String(row.id)),
+        agentId: row.agent_id === null ? null : String(row.agent_id),
+        planId: row.plan_id === null ? null : String(row.plan_id),
+        planIrHash: row.plan_ir_hash === null || row.plan_ir_hash === undefined ? null : String(row.plan_ir_hash),
+        workflowRevision: row.workflow_revision === null || row.workflow_revision === undefined
+            ? null
+            : String(row.workflow_revision),
+        terminalReason: row.terminal_reason === null || row.terminal_reason === undefined
+            ? null
+            : String(row.terminal_reason),
+        replaySafety: String(row.replay_safety ?? "safe"),
+        leaseOwner: row.lease_owner === null || row.lease_owner === undefined
+            ? null
+            : String(row.lease_owner),
+        leaseExpiresAt: row.lease_expires_at === null || row.lease_expires_at === undefined
+            ? null
+            : String(row.lease_expires_at),
+        cancelRequestedAt: row.cancel_requested_at === null || row.cancel_requested_at === undefined
+            ? null
+            : String(row.cancel_requested_at),
+        cancelDeadlineAt: row.cancel_deadline_at === null || row.cancel_deadline_at === undefined
+            ? null
+            : String(row.cancel_deadline_at),
+        providerSessionId: row.provider_session_id === null || row.provider_session_id === undefined
+            ? null
+            : String(row.provider_session_id),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+    };
+}
+function executionKindValue(value, runId) {
+    if (runId === null) {
+        if (value === null || value === undefined)
+            return null;
+        throw new Error("Runless event cannot have an execution kind");
+    }
+    if (value === "agent" || value === "flow")
+        return value;
+    throw new Error(`Invalid Run execution kind: ${runId}`);
+}
+function toSessionRuntime(row) {
+    return {
+        sessionId: String(row.session_id),
+        activeRunId: row.active_run_id === null || row.active_run_id === undefined
+            ? null
+            : String(row.active_run_id),
+        queueState: String(row.queue_state),
+        queuePauseReason: row.queue_pause_reason === null || row.queue_pause_reason === undefined
+            ? null
+            : String(row.queue_pause_reason),
+        lastEventSequence: Number(row.last_event_sequence),
+        version: Number(row.version),
+        updatedAt: String(row.updated_at),
+    };
+}
+function toSessionTurn(row) {
+    return {
+        turnId: String(row.turn_id),
+        sessionId: String(row.session_id),
+        queuePosition: Number(row.queue_position),
+        status: String(row.status),
+        message: parseSessionTurnMessage(String(row.message_json)),
+        version: Number(row.version),
+        dispatchedRunId: row.dispatched_run_id === null || row.dispatched_run_id === undefined
+            ? null
+            : String(row.dispatched_run_id),
+        createdAt: String(row.created_at),
+        dispatchedAt: row.dispatched_at === null || row.dispatched_at === undefined
+            ? null
+            : String(row.dispatched_at),
+        cancelledAt: row.cancelled_at === null || row.cancelled_at === undefined
+            ? null
+            : String(row.cancelled_at),
+    };
+}
+function toRunAttempt(row) {
+    return {
+        attemptId: String(row.attempt_id),
+        runId: String(row.run_id),
+        attemptNumber: Number(row.attempt_number),
+        startedAt: String(row.started_at),
+        endedAt: row.ended_at === null
+            ? null
+            : String(row.ended_at),
+        providerError: row.provider_error === null
+            ? null
+            : String(row.provider_error),
+        sideEffectBoundary: String(row.side_effect_boundary),
+    };
+}
+function toTimelineSegment(row) {
+    return {
+        segmentId: String(row.segment_id),
+        blockId: String(row.block_id),
+        segmentIndex: Number(row.segment_index),
+        content: String(row.content),
+        byteLength: Number(row.byte_length),
+        sealed: Number(row.sealed) === 1,
+    };
+}
+function toTimelineBlock(row) {
+    return {
+        blockId: String(row.block_id),
+        sessionId: String(row.session_id),
+        turnId: String(row.turn_id),
+        runId: String(row.run_id),
+        blockIndex: Number(row.block_index),
+        kind: String(row.kind),
+        status: String(row.status),
+        metadata: JSON.parse(String(row.metadata_json ?? "{}")),
+    };
+}
+function toTimelineTurn(row) {
+    return {
+        sessionId: String(row.session_id),
+        timelineIndex: Number(row.timeline_index),
+        turnId: String(row.turn_id),
+        runId: String(row.run_id),
+        startedSequence: Number(row.started_sequence),
+        endedSequence: row.ended_sequence === null || row.ended_sequence === undefined
+            ? null
+            : Number(row.ended_sequence),
+        status: String(row.status),
+    };
+}
+function toPlan(row) {
+    return {
+        schemaVersion: Number(row.schema_version),
+        planId: String(row.plan_id),
+        source: String(row.source),
+        workflowId: String(row.workflow_id),
+        definitionRevision: row.definition_revision === null ? null : String(row.definition_revision),
+        planIrHash: row.plan_ir_hash === null || row.plan_ir_hash === undefined ? null : String(row.plan_ir_hash),
+        sessionId: row.session_id === null ? null : String(row.session_id),
+        runId: row.run_id === null ? null : String(row.run_id),
+        steps: JSON.parse(String(row.steps)).map(clonePlanStep),
+        createdAt: String(row.created_at),
+    };
+}
+function toArtifact(row) {
+    return {
+        id: String(row.id),
+        workItemId: String(row.work_item_id),
+        runId: String(row.run_id),
+        stepId: row.step_id === null ? null : String(row.step_id),
+        kind: String(row.kind),
+        name: String(row.name),
+        mimeType: String(row.mime_type),
+        content: String(row.content),
+        contentHash: String(row.content_hash),
+        metadata: JSON.parse(String(row.metadata)),
+        createdAt: String(row.created_at),
+    };
+}
+function toMessageAttachment(row) {
+    return {
+        schemaVersion: Number(row.schema_version),
+        id: String(row.id),
+        workItemId: String(row.work_item_id),
+        name: String(row.name),
+        mimeType: String(row.mime_type),
+        dataBase64: String(row.data_base64),
+        byteSize: Number(row.byte_size),
+        contentHash: String(row.content_hash),
+        createdAt: String(row.created_at),
+    };
+}
+function toVerification(row) {
+    return {
+        id: String(row.id),
+        workItemId: String(row.work_item_id),
+        runId: String(row.run_id),
+        stepId: row.step_id === null ? null : String(row.step_id),
+        validator: String(row.validator),
+        status: String(row.status),
+        summary: String(row.summary),
+        artifactIds: JSON.parse(String(row.artifact_ids)),
+        createdAt: String(row.created_at),
+    };
+}
+function clonePlanStep(step) {
+    return {
+        ...step,
+        dependsOn: [...step.dependsOn],
+        branches: step.branches.map((branch) => ({ ...branch })),
+        retry: step.retry ? { ...step.retry } : null,
+    };
+}
+//# sourceMappingURL=index.js.map