@myagentroam/node 0.1.0

package/dist/database.js

@@ -0,0 +1,1347 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { runnerDefaultConfigurationSchema } from '@myagentroam/protocol';
+export class NodeDatabase {
+    now;
+    activeWorkspaceLeaseCount() {
+        const row = this.raw
+            .prepare("SELECT COUNT(*) AS count FROM workspace_leases WHERE state IN ('ACTIVE', 'SUSPECT')")
+            .get();
+        return row.count;
+    }
+    raw;
+    constructor(path, nodeId, now = Date.now) {
+        this.now = now;
+        this.nodeIdProvider = typeof nodeId === 'string' ? () => nodeId : nodeId;
+        if (path !== ':memory:')
+            mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        this.raw = new DatabaseSync(path, {
+            enableForeignKeyConstraints: true,
+            timeout: 5_000,
+            defensive: true
+        });
+        this.raw.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+        migrate(this.raw);
+    }
+    close() {
+        this.raw.close();
+    }
+    getRunnerDefaults() {
+        const rows = this.raw
+            .prepare('SELECT runner, model, effort, access FROM runner_defaults ORDER BY runner')
+            .all();
+        return rows.flatMap((row) => {
+            const parsed = runnerDefaultConfigurationSchema.safeParse({
+                runner: stringValue(row, 'runner'),
+                model: stringValue(row, 'model'),
+                effort: stringValue(row, 'effort'),
+                access: stringValue(row, 'access')
+            });
+            return parsed.success ? [parsed.data] : [];
+        });
+    }
+    saveRunnerDefaults(input) {
+        this.raw
+            .prepare(`INSERT INTO runner_defaults (runner, model, effort, access)
+         VALUES (?, ?, ?, ?)
+         ON CONFLICT(runner) DO UPDATE SET
+           model = excluded.model, effort = excluded.effort,
+           access = excluded.access`)
+            .run(input.runner, input.model, input.effort, input.access);
+        return input;
+    }
+    /**
+     * Stores only terminal lifecycle metadata. PTY input/output must remain in
+     * the Node-local bounded replay buffer and must never be passed here.
+     */
+    saveTerminalSession(input) {
+        this.raw
+            .prepare(`INSERT INTO terminal_sessions
+          (id, workspace_id, profile_id, state, exit_code, rows, cols, latest_sequence, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET workspace_id = excluded.workspace_id, profile_id = excluded.profile_id, state = excluded.state,
+           exit_code = excluded.exit_code, rows = excluded.rows, cols = excluded.cols,
+           latest_sequence = excluded.latest_sequence, updated_at = excluded.updated_at`)
+            .run(input.id, input.workspaceId, input.profileId, input.state, input.exitCode, input.rows, input.cols, input.latestSequence, input.createdAt, input.updatedAt);
+        return this.getTerminalSession(input.id);
+    }
+    getTerminalSession(id) {
+        const row = this.raw
+            .prepare(`SELECT id, workspace_id, profile_id, state, exit_code, rows, cols, latest_sequence, created_at, updated_at
+         FROM terminal_sessions WHERE id = ?`)
+            .get(id);
+        return row === undefined ? undefined : terminalSession(row);
+    }
+    listTerminalSessions() {
+        return this.raw
+            .prepare(`SELECT id, workspace_id, profile_id, state, exit_code, rows, cols, latest_sequence, created_at, updated_at
+         FROM terminal_sessions WHERE state = 'RUNNING' ORDER BY created_at ASC, id ASC`)
+            .all()
+            .map((row) => terminalSession(row));
+    }
+    /** A restart cannot safely reattach an orphaned PTY, so record it as closed. */
+    closeRunningTerminalSessions() {
+        this.raw
+            .prepare("UPDATE terminal_sessions SET state = 'CLOSED', updated_at = ? WHERE state = 'RUNNING'")
+            .run(this.now());
+    }
+    saveWorkspace(input) {
+        const current = this.raw.prepare('SELECT id FROM workspaces WHERE path = ?').get(input.path);
+        const workspace = {
+            id: current === undefined ? (input.id ?? randomUUID()) : stringValue(current, 'id'),
+            path: input.path,
+            kind: input.kind,
+            gitSummary: input.gitSummary
+        };
+        const timestamp = this.now();
+        this.raw
+            .prepare(`INSERT INTO workspaces (id, path, kind, git_summary, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT(path) DO UPDATE SET kind = excluded.kind,
+           git_summary = excluded.git_summary, updated_at = excluded.updated_at`)
+            .run(workspace.id, workspace.path, workspace.kind, workspace.gitSummary === null ? null : JSON.stringify(workspace.gitSummary), timestamp, timestamp);
+        return workspace;
+    }
+    listWorkspaces() {
+        return this.raw
+            .prepare('SELECT id, path, kind, git_summary FROM workspaces ORDER BY created_at ASC')
+            .all()
+            .map((row) => workspace(row));
+    }
+    getWorkspace(id) {
+        const row = this.raw
+            .prepare('SELECT id, path, kind, git_summary FROM workspaces WHERE id = ?')
+            .get(id);
+        return row === undefined ? undefined : workspace(row);
+    }
+    /** Unregisters a Workspace registration without deleting its local directory. */
+    removeWorkspace(id) {
+        const current = this.getWorkspace(id);
+        if (current === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        this.raw.exec('BEGIN');
+        try {
+            // Session deletion cascades their runs, conversation and attachments. The workspace
+            // record itself never represents a filesystem deletion.
+            this.raw.prepare('DELETE FROM agent_sessions WHERE workspace_id = ?').run(id);
+            this.raw.prepare('DELETE FROM workspaces WHERE id = ?').run(id);
+            this.raw.exec('COMMIT');
+            return current;
+        }
+        catch (error) {
+            this.raw.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    createAgentSession(input) {
+        if (this.getWorkspace(input.workspaceId) === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const session = {
+            id: randomUUID(),
+            nodeId: this.nodeIdProvider(),
+            workspaceId: input.workspaceId,
+            runner: input.runner,
+            externalSessionId: input.externalSessionId ?? null,
+            nativeControl: input.externalSessionId === undefined ? 'MAR_MANAGED' : (input.nativeControl ?? 'EXTERNAL'),
+            channelToken: null,
+            cwd: input.cwd,
+            model: optionValue(input.model),
+            effort: optionValue(input.effort),
+            access: optionValue(input.access),
+            customTitle: null,
+            runnerTitle: input.title?.trim().slice(0, 160) || null,
+            pinnedAt: null,
+            titleSource: input.title?.trim() ? 'RUNNER' : 'AUTO',
+            lastActivityAt: this.now(),
+            createdAt: this.now()
+        };
+        this.raw
+            .prepare(`INSERT INTO agent_sessions
+          (id, workspace_id, runner, external_session_id, native_control, channel_token, cwd, model, effort, access, custom_title, runner_title, pinned_at, title_source, last_activity_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(session.id, session.workspaceId, session.runner, session.externalSessionId, session.nativeControl, session.channelToken, session.cwd, session.model, session.effort, session.access, session.customTitle, session.runnerTitle, session.pinnedAt, session.titleSource, session.lastActivityAt, session.createdAt, session.createdAt);
+        return session;
+    }
+    getAgentSession(id) {
+        const row = this.raw
+            .prepare('SELECT id, workspace_id, runner, external_session_id, native_control, channel_token, cwd, model, effort, access, custom_title, runner_title, pinned_at, title_source, last_activity_at, created_at FROM agent_sessions WHERE id = ?')
+            .get(id);
+        return row === undefined ? undefined : session(row, this.nodeIdProvider());
+    }
+    updateAgentSessionConfiguration(input) {
+        const result = this.raw
+            .prepare(`UPDATE agent_sessions
+         SET model = ?, effort = ?, access = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(input.model, input.effort, input.access, this.now(), input.sessionId);
+        if (Number(result.changes) === 0)
+            throw new Error('SESSION_NOT_FOUND');
+        return this.getAgentSession(input.sessionId);
+    }
+    listAgentSessions() {
+        return this.raw
+            .prepare('SELECT id, workspace_id, runner, external_session_id, native_control, channel_token, cwd, model, effort, access, custom_title, runner_title, pinned_at, title_source, last_activity_at, created_at FROM agent_sessions ORDER BY pinned_at IS NULL, pinned_at DESC, last_activity_at DESC, id DESC')
+            .all()
+            .map((row) => session(row, this.nodeIdProvider()));
+    }
+    findAgentSessionByExternalSession(runner, externalSessionId) {
+        const row = this.raw
+            .prepare(`SELECT id, workspace_id, runner, external_session_id, native_control, channel_token, cwd, model, effort, access, custom_title, runner_title, pinned_at, title_source, last_activity_at, created_at
+         FROM agent_sessions WHERE runner = ? AND external_session_id = ?`)
+            .get(runner, externalSessionId);
+        return row === undefined ? undefined : session(row, this.nodeIdProvider());
+    }
+    setNativeControl(sessionId, nativeControl) {
+        const result = this.raw
+            .prepare('UPDATE agent_sessions SET native_control = ?, updated_at = ? WHERE id = ?')
+            .run(nativeControl, this.now(), sessionId);
+        if (Number(result.changes) === 0)
+            throw new Error('SESSION_NOT_FOUND');
+    }
+    setExternalSessionId(sessionId, externalSessionId) {
+        if (externalSessionId.length === 0)
+            throw new Error('SESSION_EXTERNAL_ID_INVALID');
+        const result = this.raw
+            .prepare("UPDATE agent_sessions SET external_session_id = ?, native_control = 'MAR_MANAGED', updated_at = ? WHERE id = ?")
+            .run(externalSessionId, this.now(), sessionId);
+        if (Number(result.changes) === 0)
+            throw new Error('SESSION_NOT_FOUND');
+    }
+    setChannelToken(sessionId, token) {
+        if (token.length < 16)
+            throw new Error('SESSION_CHANNEL_TOKEN_INVALID');
+        const result = this.raw
+            .prepare('UPDATE agent_sessions SET channel_token = ?, updated_at = ? WHERE id = ?')
+            .run(token, this.now(), sessionId);
+        if (Number(result.changes) === 0)
+            throw new Error('SESSION_NOT_FOUND');
+    }
+    updateSessionMetadata(input) {
+        const current = this.getAgentSession(input.sessionId);
+        if (current === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const title = input.customTitle === undefined ? current.customTitle : input.customTitle?.trim() || null;
+        if (title !== null && title.length > 160)
+            throw new Error('SESSION_TITLE_INVALID');
+        const pinnedAt = input.pinned === undefined ? current.pinnedAt : input.pinned ? this.now() : null;
+        const titleSource = title === null ? 'AUTO' : 'CUSTOM';
+        this.raw
+            .prepare('UPDATE agent_sessions SET custom_title = ?, pinned_at = ?, title_source = ?, updated_at = ? WHERE id = ?')
+            .run(title, pinnedAt, titleSource, this.now(), input.sessionId);
+        return this.getAgentSession(input.sessionId);
+    }
+    getNativeSessionMetadata(runner, externalSessionId, workspaceId) {
+        const row = this.raw
+            .prepare(`SELECT custom_title, runner_title, runner_title_pending, pinned_at, model, effort, access FROM native_session_metadata
+         WHERE runner = ? AND external_session_id = ? AND workspace_id = ?`)
+            .get(runner, externalSessionId, workspaceId);
+        return row === undefined
+            ? undefined
+            : {
+                customTitle: nullableString(row, 'custom_title'),
+                runnerTitle: nullableString(row, 'runner_title'),
+                runnerTitlePending: row['runner_title_pending'] === 1,
+                pinnedAt: nullableNumber(row, 'pinned_at'),
+                model: nullableString(row, 'model'),
+                effort: nullableString(row, 'effort'),
+                access: nullableString(row, 'access')
+            };
+    }
+    saveNativeSessionMetadata(input) {
+        const current = this.getNativeSessionMetadata(input.runner, input.externalSessionId, input.workspaceId);
+        const customTitle = input.customTitle === undefined
+            ? (current?.customTitle ?? null)
+            : input.customTitle?.trim() || null;
+        const runnerTitle = input.runnerTitle === undefined
+            ? (current?.runnerTitle ?? null)
+            : input.runnerTitle?.trim() || null;
+        const runnerTitlePending = input.runnerTitlePending === undefined
+            ? (current?.runnerTitlePending ?? false)
+            : input.runnerTitlePending;
+        if (customTitle !== null && customTitle.length > 160)
+            throw new Error('SESSION_TITLE_INVALID');
+        if (runnerTitle !== null && runnerTitle.length > 160)
+            throw new Error('SESSION_TITLE_INVALID');
+        const pinnedAt = input.pinned === undefined ? (current?.pinnedAt ?? null) : input.pinned ? this.now() : null;
+        const model = input.model === undefined ? (current?.model ?? null) : input.model;
+        const effort = input.effort === undefined ? (current?.effort ?? null) : input.effort;
+        const access = input.access === undefined ? (current?.access ?? null) : input.access;
+        this.raw
+            .prepare(`INSERT INTO native_session_metadata
+          (runner, external_session_id, workspace_id, custom_title, runner_title, runner_title_pending, pinned_at, model, effort, access, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(runner, external_session_id, workspace_id) DO UPDATE SET
+           custom_title = excluded.custom_title, runner_title = excluded.runner_title,
+           runner_title_pending = excluded.runner_title_pending, pinned_at = excluded.pinned_at,
+           model = excluded.model, effort = excluded.effort, access = excluded.access,
+           updated_at = excluded.updated_at`)
+            .run(input.runner, input.externalSessionId, input.workspaceId, customTitle, runnerTitle, runnerTitlePending ? 1 : 0, pinnedAt, model, effort, access, this.now());
+        return { customTitle, runnerTitle, runnerTitlePending, pinnedAt, model, effort, access };
+    }
+    /**
+     * Replaces only transcript-derived, run-less history. Managed Run turns are
+     * never touched by a vendor file scan.
+     */
+    syncNativeTranscript(sessionId, history) {
+        const current = this.getAgentSession(sessionId);
+        if (current === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const checkpoint = this.raw
+            .prepare('SELECT digest FROM native_session_checkpoints WHERE session_id = ?')
+            .get(sessionId);
+        if (checkpoint !== undefined && stringValue(checkpoint, 'digest') === history.digest)
+            return false;
+        const now = this.now();
+        this.raw.exec('BEGIN IMMEDIATE');
+        try {
+            this.raw
+                .prepare('DELETE FROM conversation_turns WHERE session_id = ? AND run_id IS NULL')
+                .run(sessionId);
+            for (const [index, item] of history.items.entries()) {
+                if (item.kind !== 'message')
+                    continue;
+                const turnId = randomUUID();
+                const itemId = randomUUID();
+                const createdAt = item.createdAt ?? now + index;
+                this.raw
+                    .prepare(`INSERT INTO conversation_turns
+              (id, session_id, run_id, user_item_id, status, started_at, completed_at, created_at, updated_at)
+             VALUES (?, ?, NULL, ?, 'SUCCEEDED', ?, ?, ?, ?)`)
+                    .run(turnId, sessionId, item.role === 'USER' ? itemId : null, createdAt, createdAt, createdAt, now);
+                this.raw
+                    .prepare(`INSERT INTO conversation_items
+              (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+             VALUES (?, ?, ?, NULL, NULL, ?, 0, ?, 'COMPLETED', ?, ?, ?, ?, ?)`)
+                    .run(itemId, sessionId, turnId, index, item.role === 'USER' ? 'user_message' : 'assistant_message', JSON.stringify({ text: item.text, format: 'markdown', source: 'native-file' }), createdAt, createdAt, createdAt, now);
+                this.recordConversationItemChange(sessionId, itemId, 0);
+            }
+            const runnerTitle = history.title?.trim().slice(0, 160) || current.runnerTitle;
+            this.raw
+                .prepare(`UPDATE agent_sessions
+           SET runner_title = ?, title_source = CASE WHEN custom_title IS NULL THEN 'RUNNER' ELSE title_source END,
+               last_activity_at = CASE WHEN ? > last_activity_at THEN ? ELSE last_activity_at END, updated_at = ?
+           WHERE id = ?`)
+                .run(runnerTitle, now, now, now, sessionId);
+            this.raw
+                .prepare(`INSERT INTO native_session_checkpoints (session_id, digest, updated_at)
+           VALUES (?, ?, ?)
+           ON CONFLICT(session_id) DO UPDATE SET digest = excluded.digest, updated_at = excluded.updated_at`)
+                .run(sessionId, history.digest, now);
+            this.raw.exec('COMMIT');
+            return true;
+        }
+        catch (error) {
+            this.raw.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    createMessageRun(input) {
+        const existing = this.raw
+            .prepare(`SELECT r.id, r.session_id, r.workspace_id, r.runner, r.status, r.recovery_state, r.version,
+                m.client_message_id, r.created_at, r.updated_at
+         FROM agent_runs r JOIN session_messages m ON m.id = r.message_id
+         WHERE m.session_id = ? AND m.client_message_id = ?`)
+            .get(input.sessionId, input.clientMessageId);
+        if (existing !== undefined)
+            return { run: run(existing, this.nodeIdProvider()), created: false };
+        const agentSession = this.getAgentSession(input.sessionId);
+        if (agentSession === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const attachments = normalizeAttachments(input.attachments ?? []);
+        const value = {
+            id: randomUUID(),
+            sessionId: agentSession.id,
+            nodeId: this.nodeIdProvider(),
+            workspaceId: agentSession.workspaceId,
+            runner: agentSession.runner,
+            status: 'QUEUED',
+            recoveryState: 'ACTIVE',
+            version: 0,
+            clientMessageId: input.clientMessageId,
+            createdAt: this.now(),
+            updatedAt: this.now()
+        };
+        this.raw.exec('BEGIN IMMEDIATE');
+        try {
+            const messageId = randomUUID();
+            this.raw
+                .prepare(`INSERT INTO session_messages (id, session_id, client_message_id, role, content, created_at)
+           VALUES (?, ?, ?, 'USER', ?, ?)`)
+                .run(messageId, input.sessionId, input.clientMessageId, input.content, value.createdAt);
+            for (const attachment of attachments) {
+                this.raw
+                    .prepare(`INSERT INTO message_attachments (id, message_id, name, mime, byte_size, data, created_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                    .run(randomUUID(), messageId, attachment.name, attachment.mime, attachment.data.length, attachment.data, value.createdAt);
+            }
+            this.raw
+                .prepare(`INSERT INTO agent_runs
+            (id, session_id, message_id, workspace_id, runner, status, recovery_state, version, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, 'ACTIVE', 0, ?, ?)`)
+                .run(value.id, value.sessionId, messageId, value.workspaceId, value.runner, value.status, value.createdAt, value.updatedAt);
+            this.raw
+                .prepare(`INSERT INTO workspace_leases (id, workspace_id, run_id, state, created_at, updated_at)
+           VALUES (?, ?, ?, 'ACTIVE', ?, ?)`)
+                .run(randomUUID(), value.workspaceId, value.id, value.createdAt, value.createdAt);
+            const turnId = randomUUID();
+            const userItemId = randomUUID();
+            this.raw
+                .prepare(`INSERT INTO conversation_turns
+            (id, session_id, run_id, user_item_id, status, model, effort, access, started_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, 'QUEUED', ?, ?, ?, NULL, ?, ?)`)
+                .run(turnId, value.sessionId, value.id, userItemId, agentSession.model, agentSession.effort, agentSession.access, value.createdAt, value.createdAt);
+            this.raw
+                .prepare(`INSERT INTO conversation_items
+            (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, NULL, NULL, 0, 'user_message', 'COMPLETED', ?, ?, ?, ?, ?)`)
+                .run(userItemId, value.sessionId, turnId, value.id, JSON.stringify({
+                clientMessageId: input.clientMessageId,
+                text: input.content,
+                contexts: [],
+                attachments: attachments.map(({ name, mime, data }) => ({
+                    name,
+                    mime,
+                    byteSize: data.length
+                })),
+                delivery: 'ACCEPTED'
+            }), value.createdAt, value.createdAt, value.createdAt, value.createdAt);
+            this.recordConversationItemChange(value.sessionId, userItemId, 0);
+            this.raw
+                .prepare('UPDATE agent_sessions SET last_activity_at = ?, updated_at = ? WHERE id = ?')
+                .run(value.createdAt, value.createdAt, value.sessionId);
+            this.recordWorkspaceActivity(value.workspaceId, 'run.created', {
+                runId: value.id,
+                sessionId: value.sessionId,
+                runner: value.runner
+            });
+            this.raw.exec('COMMIT');
+            return { run: value, created: true };
+        }
+        catch (error) {
+            this.raw.exec('ROLLBACK');
+            if (isConstraint(error))
+                throw new Error('WORKSPACE_BUSY');
+            throw error;
+        }
+    }
+    getRun(id) {
+        const row = this.raw
+            .prepare(`SELECT r.id, r.session_id, r.workspace_id, r.runner, r.status, r.recovery_state, r.version,
+                m.client_message_id, r.created_at, r.updated_at
+         FROM agent_runs r JOIN session_messages m ON m.id = r.message_id WHERE r.id = ?`)
+            .get(id);
+        return row === undefined ? undefined : run(row, this.nodeIdProvider());
+    }
+    listRunsForSession(sessionId) {
+        if (this.getAgentSession(sessionId) === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        return this.raw
+            .prepare(`SELECT r.id, r.session_id, r.workspace_id, r.runner, r.status, r.recovery_state, r.version,
+                m.client_message_id, r.created_at, r.updated_at
+         FROM agent_runs r JOIN session_messages m ON m.id = r.message_id
+         WHERE r.session_id = ? ORDER BY r.created_at DESC, r.id DESC`)
+            .all(sessionId)
+            .map((row) => run(row, this.nodeIdProvider()));
+    }
+    getRunInput(id) {
+        const row = this.raw
+            .prepare('SELECT m.content FROM session_messages m JOIN agent_runs r ON r.message_id = m.id WHERE r.id = ?')
+            .get(id);
+        return row === undefined ? undefined : stringValue(row, 'content');
+    }
+    transitionRun(runId, next) {
+        const current = this.getRun(runId);
+        if (current === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        if (current.recoveryState === 'LOST')
+            throw new Error('RUN_LOST');
+        if (!transitionAllowed(current.status, next))
+            throw new Error('RUN_STATE_INVALID');
+        const changed = this.raw
+            .prepare('UPDATE agent_runs SET status = ?, version = version + 1, updated_at = ? WHERE id = ? AND version = ?')
+            .run(next, this.now(), runId, current.version);
+        if (Number(changed.changes) === 0)
+            throw new Error('RUN_VERSION_CONFLICT');
+        if (terminal(next))
+            this.releaseLease(runId);
+        return this.getRun(runId);
+    }
+    appendRunEvent(input) {
+        if (this.getRun(input.runId) === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        const row = this.raw
+            .prepare('SELECT MAX(sequence) AS sequence FROM run_events WHERE run_id = ?')
+            .get(input.runId);
+        const lastSequence = row['sequence'] === null ? 0 : numberValue(row, 'sequence');
+        if (input.sequence > lastSequence + 1)
+            throw new Error('EVENT_SEQUENCE_GAP');
+        const timestamp = this.now();
+        const result = this.raw
+            .prepare(`INSERT INTO run_events (run_id, sequence, event_type, payload, created_at)
+         VALUES (?, ?, ?, ?, ?) ON CONFLICT(run_id, sequence) DO NOTHING`)
+            .run(input.runId, input.sequence, input.eventType, JSON.stringify(input.payload ?? null), timestamp);
+        if (Number(result.changes) === 0)
+            return undefined;
+        if (input.status !== undefined)
+            this.transitionRun(input.runId, input.status);
+        const stored = this.raw
+            .prepare('SELECT id, run_id, sequence, event_type, payload, created_at FROM run_events WHERE run_id = ? AND sequence = ?')
+            .get(input.runId, input.sequence);
+        const value = event(stored);
+        this.projectRunEvent(value, input.status);
+        const run = this.getRun(input.runId);
+        if (run !== undefined) {
+            this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
+                runId: run.id,
+                eventType: input.eventType,
+                status: input.status ?? null
+            });
+        }
+        return value;
+    }
+    listRunEvents(runId, after = 0) {
+        return this.raw
+            .prepare(`SELECT id, run_id, sequence, event_type, payload, created_at FROM run_events
+         WHERE run_id = ? AND sequence > ? ORDER BY sequence ASC`)
+            .all(runId, after)
+            .map((row) => event(row));
+    }
+    /**
+     * Returns durable final item snapshots. Run events stay internal to the
+     * replay path; callers never need to reconstruct native runner payloads.
+     */
+    listConversationTurns(input) {
+        if (this.getAgentSession(input.sessionId) === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const limit = pageLimit(input.limit);
+        const cursor = decodeCursor(input.cursor, 'turn', input.sessionId);
+        const rows = this.raw
+            .prepare(`SELECT rowid AS cursor_id, id, session_id, run_id, user_item_id, status, model, effort, access, started_at, completed_at, created_at
+         FROM conversation_turns
+         WHERE session_id = ?
+           AND (? = 0 OR run_id IS NULL)
+           AND (? IS NULL OR rowid < ?)
+         ORDER BY rowid DESC LIMIT ?`)
+            .all(input.sessionId, input.nativeOnly === true ? 1 : 0, cursor?.value ?? null, cursor?.value ?? 0, limit + 1);
+        const page = rows.slice(0, limit);
+        const turns = page.map((row) => this.readConversationTurn(row));
+        const last = page.at(-1);
+        return {
+            turns,
+            nextCursor: rows.length > limit && last !== undefined
+                ? encodeCursor('turn', input.sessionId, numberValue(last, 'cursor_id'), '')
+                : null
+        };
+    }
+    hasNativeTranscript(sessionId) {
+        const row = this.raw
+            .prepare(`SELECT EXISTS(
+           SELECT 1 FROM native_session_checkpoints checkpoint
+           JOIN conversation_turns turn ON turn.session_id = checkpoint.session_id AND turn.run_id IS NULL
+           WHERE checkpoint.session_id = ?
+         ) AS found`)
+            .get(sessionId);
+        return numberValue(row, 'found') === 1;
+    }
+    /** Session detail cursor is intentionally distinct from history paging. */
+    listConversationItems(input) {
+        if (this.getAgentSession(input.sessionId) === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const limit = pageLimit(input.limit);
+        const cursor = decodeCursor(input.cursor, 'session-item', input.sessionId);
+        const rows = this.raw
+            .prepare(`SELECT cie.id AS cursor_id, ci.id, ci.session_id, ci.turn_id, ci.run_id, ci.parent_item_id,
+                ci.source_sequence, ci.revision, ci.kind, ci.status, ci.payload, ci.started_at, ci.completed_at
+         FROM conversation_item_events cie
+         JOIN conversation_items ci ON ci.id = cie.item_id
+         WHERE cie.session_id = ? AND (? IS NULL OR cie.id > ?)
+         ORDER BY cie.id ASC LIMIT ?`)
+            .all(input.sessionId, cursor?.value ?? null, cursor?.value ?? 0, limit + 1);
+        const page = rows.slice(0, limit);
+        const last = page.at(-1);
+        return {
+            items: page.map((row) => conversationItem(row)),
+            nextCursor: rows.length > limit && last !== undefined
+                ? encodeCursor('session-item', input.sessionId, numberValue(last, 'cursor_id'), '')
+                : null
+        };
+    }
+    listWorkspaceActivity(input) {
+        if (this.getWorkspace(input.workspaceId) === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const limit = pageLimit(input.limit);
+        const cursor = decodeCursor(input.cursor, 'workspace-activity', input.workspaceId);
+        const rows = this.raw
+            .prepare(`SELECT id, workspace_id, event_type, payload, created_at FROM workspace_activity_events
+         WHERE workspace_id = ? AND (? IS NULL OR id > ?)
+         ORDER BY id ASC LIMIT ?`)
+            .all(input.workspaceId, cursor === undefined ? null : cursor.value, cursor?.value ?? 0, limit + 1);
+        const page = rows.slice(0, limit);
+        const last = page.at(-1);
+        return {
+            events: page.map((row) => workspaceActivityEvent(row)),
+            nextCursor: rows.length > limit && last !== undefined
+                ? encodeCursor('workspace-activity', input.workspaceId, numberValue(last, 'id'), '')
+                : null
+        };
+    }
+    createApproval(input) {
+        if (this.getRun(input.runId) === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        if (!Number.isSafeInteger(input.expiresAt) || input.expiresAt <= this.now())
+            throw new Error('APPROVAL_EXPIRED');
+        try {
+            this.raw
+                .prepare(`INSERT INTO approvals (id, run_id, status, payload, expires_at, created_at, updated_at)
+           VALUES (?, ?, 'PENDING', ?, ?, ?, ?)`)
+                .run(input.approvalId, input.runId, JSON.stringify(input.payload ?? null), input.expiresAt, this.now(), this.now());
+        }
+        catch (error) {
+            if (isConstraint(error))
+                throw new Error('APPROVAL_ALREADY_EXISTS');
+            throw error;
+        }
+        const result = this.getApproval(input.approvalId);
+        this.projectApproval(result);
+        return result;
+    }
+    getApproval(id) {
+        const row = this.raw
+            .prepare('SELECT id, run_id, status, payload, expires_at, created_at, decided_at FROM approvals WHERE id = ?')
+            .get(id);
+        if (row === undefined)
+            return undefined;
+        if (stringValue(row, 'status') === 'PENDING' && numberValue(row, 'expires_at') <= this.now()) {
+            return this.expireApproval(id);
+        }
+        return approval(row, this.now());
+    }
+    listApprovals(runId) {
+        return this.raw
+            .prepare('SELECT id FROM approvals WHERE run_id = ?')
+            .all(runId)
+            .map((row) => this.getApproval(stringValue(row, 'id')));
+    }
+    /** Persists an expiry so a later decision cannot resurrect an old prompt. */
+    expireApproval(id) {
+        const row = this.raw
+            .prepare('SELECT id, run_id, status, payload, expires_at, created_at, decided_at FROM approvals WHERE id = ?')
+            .get(id);
+        if (row === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        const storedStatus = stringValue(row, 'status');
+        if (storedStatus !== 'PENDING')
+            return approval(row, this.now());
+        if (numberValue(row, 'expires_at') > this.now())
+            throw new Error('APPROVAL_NOT_EXPIRED');
+        this.raw
+            .prepare(`UPDATE approvals SET status = 'EXPIRED', decided_at = ?, updated_at = ?
+         WHERE id = ? AND status = 'PENDING' AND expires_at <= ?`)
+            .run(this.now(), this.now(), id, this.now());
+        const result = this.getApproval(id);
+        this.projectApproval(result);
+        return result;
+    }
+    expireDueApprovals() {
+        const rows = this.raw
+            .prepare("SELECT id FROM approvals WHERE status = 'PENDING' AND expires_at <= ?")
+            .all(this.now());
+        return rows.map((row) => this.expireApproval(stringValue(row, 'id')));
+    }
+    decideApproval(id, decision) {
+        const current = this.getApproval(id);
+        if (current === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        if (current.status === 'EXPIRED')
+            throw new Error('APPROVAL_EXPIRED');
+        if (current.status !== 'PENDING')
+            throw new Error('APPROVAL_ALREADY_DECIDED');
+        const changed = this.raw
+            .prepare(`UPDATE approvals SET status = ?, decided_at = ?, updated_at = ?
+         WHERE id = ? AND status = 'PENDING' AND expires_at > ?`)
+            .run(decision, this.now(), this.now(), id, this.now());
+        if (Number(changed.changes) === 0) {
+            if (this.getApproval(id)?.status === 'EXPIRED')
+                throw new Error('APPROVAL_EXPIRED');
+            throw new Error('APPROVAL_ALREADY_DECIDED');
+        }
+        const result = this.getApproval(id);
+        this.projectApproval(result);
+        return result;
+    }
+    listNonterminalRuns() {
+        return this.raw
+            .prepare(`SELECT r.id, r.session_id, r.workspace_id, r.runner, r.status, r.recovery_state, r.version,
+                m.client_message_id, r.created_at, r.updated_at
+         FROM agent_runs r JOIN session_messages m ON m.id = r.message_id
+         WHERE r.status NOT IN ('SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED')
+         ORDER BY r.created_at ASC`)
+            .all()
+            .map((row) => run(row, this.nodeIdProvider()));
+    }
+    lastRunSequence(runId) {
+        const row = this.raw
+            .prepare('SELECT MAX(sequence) AS sequence FROM run_events WHERE run_id = ?')
+            .get(runId);
+        return row['sequence'] === null ? 0 : numberValue(row, 'sequence');
+    }
+    saveSnapshot(runId, snapshot) {
+        this.raw
+            .prepare(`INSERT INTO run_snapshots (run_id, snapshot, created_at) VALUES (?, ?, ?)
+         ON CONFLICT(run_id) DO UPDATE SET snapshot = excluded.snapshot, created_at = excluded.created_at`)
+            .run(runId, JSON.stringify(snapshot), this.now());
+    }
+    getSnapshot(runId) {
+        const row = this.raw
+            .prepare('SELECT snapshot FROM run_snapshots WHERE run_id = ?')
+            .get(runId);
+        return row === undefined ? undefined : JSON.parse(stringValue(row, 'snapshot'));
+    }
+    markActiveRunsSuspect() {
+        this.raw
+            .prepare("UPDATE agent_runs SET recovery_state = 'SUSPECT', recovery_updated_at = ? WHERE status NOT IN ('SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED')")
+            .run(this.now());
+        this.raw
+            .prepare("UPDATE workspace_leases SET state = 'SUSPECT', updated_at = ? WHERE state = 'ACTIVE'")
+            .run(this.now());
+    }
+    hasActiveWorkspaceLease(workspaceId) {
+        const row = this.raw
+            .prepare("SELECT 1 AS present FROM workspace_leases WHERE workspace_id = ? AND state IN ('ACTIVE', 'SUSPECT') LIMIT 1")
+            .get(workspaceId);
+        return row !== undefined;
+    }
+    reconcileRun(runId, active) {
+        const current = this.getRun(runId);
+        if (current === undefined || terminal(current.status))
+            return;
+        if (active) {
+            this.raw
+                .prepare("UPDATE agent_runs SET recovery_state = 'ACTIVE', recovery_updated_at = ? WHERE id = ?")
+                .run(this.now(), runId);
+            this.raw
+                .prepare("UPDATE workspace_leases SET state = 'ACTIVE', updated_at = ? WHERE run_id = ? AND state = 'SUSPECT'")
+                .run(this.now(), runId);
+            return;
+        }
+        this.raw
+            .prepare("UPDATE agent_runs SET recovery_state = 'LOST', recovery_updated_at = ? WHERE id = ?")
+            .run(this.now(), runId);
+        this.releaseLease(runId);
+    }
+    releaseLease(runId) {
+        this.raw
+            .prepare("UPDATE workspace_leases SET state = 'RELEASED', updated_at = ? WHERE run_id = ? AND state IN ('ACTIVE', 'SUSPECT')")
+            .run(this.now(), runId);
+    }
+    recordWorkspaceActivity(workspaceId, eventType, payload) {
+        this.raw
+            .prepare(`INSERT INTO workspace_activity_events (workspace_id, event_type, payload, created_at)
+         VALUES (?, ?, ?, ?)`)
+            .run(workspaceId, eventType, JSON.stringify(payload), this.now());
+    }
+    recordConversationItemChange(sessionId, itemId, revision) {
+        this.raw
+            .prepare(`INSERT INTO conversation_item_events (session_id, item_id, revision, created_at)
+         VALUES (?, ?, ?, ?)`)
+            .run(sessionId, itemId, revision, this.now());
+    }
+    projectApproval(value) {
+        const turn = this.raw
+            .prepare('SELECT id, session_id FROM conversation_turns WHERE run_id = ?')
+            .get(value.runId);
+        if (turn === undefined)
+            return;
+        const sessionId = stringValue(turn, 'session_id');
+        const turnId = stringValue(turn, 'id');
+        const status = value.status === 'PENDING'
+            ? 'PENDING'
+            : value.status === 'APPROVED'
+                ? 'COMPLETED'
+                : 'DECLINED';
+        const payload = value.payload;
+        const source = typeof payload?.method === 'string' ? payload.method : payload?.toolName;
+        const category = source === 'item/commandExecution/requestApproval' || source === 'Bash'
+            ? 'COMMAND'
+            : source === 'item/fileChange/requestApproval'
+                ? 'FILE_CHANGE'
+                : 'TOOL';
+        const timestamp = this.now();
+        this.raw
+            .prepare(`INSERT INTO conversation_items
+          (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, NULL, NULL, 0, 'approval', ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET revision = conversation_items.revision + 1,
+           status = excluded.status, payload = excluded.payload, completed_at = excluded.completed_at, updated_at = excluded.updated_at`)
+            .run(value.id, sessionId, turnId, value.runId, status, JSON.stringify({
+            approvalId: value.id,
+            category,
+            reason: null,
+            expiresAt: value.expiresAt,
+            resolvedDecision: value.status === 'PENDING' ? null : value.status
+        }), value.createdAt, value.status === 'PENDING' ? null : timestamp, value.createdAt, timestamp);
+        const item = this.raw
+            .prepare('SELECT revision FROM conversation_items WHERE id = ?')
+            .get(value.id);
+        this.recordConversationItemChange(sessionId, value.id, numberValue(item, 'revision'));
+    }
+    readConversationTurn(row) {
+        const turnId = stringValue(row, 'id');
+        const items = this.raw
+            .prepare(`SELECT id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at
+         FROM conversation_items WHERE turn_id = ?
+         ORDER BY source_sequence IS NOT NULL, source_sequence ASC, created_at ASC, id ASC`)
+            .all(turnId)
+            .map((item) => conversationItem(item));
+        return {
+            id: turnId,
+            sessionId: stringValue(row, 'session_id'),
+            runId: nullableString(row, 'run_id'),
+            userItemId: nullableString(row, 'user_item_id'),
+            status: stringValue(row, 'status'),
+            model: nullableString(row, 'model'),
+            effort: nullableString(row, 'effort'),
+            access: nullableString(row, 'access'),
+            items,
+            startedAt: nullableNumber(row, 'started_at'),
+            completedAt: nullableNumber(row, 'completed_at')
+        };
+    }
+    projectRunEvent(event, status) {
+        const turn = this.raw
+            .prepare('SELECT id, session_id, started_at FROM conversation_turns WHERE run_id = ?')
+            .get(event.runId);
+        if (turn === undefined)
+            return;
+        const turnId = stringValue(turn, 'id');
+        const sessionId = stringValue(turn, 'session_id');
+        const timestamp = this.now();
+        const payload = event.payload;
+        if ((event.eventType === 'text' || event.eventType === 'text.delta') &&
+            typeof payload?.text === 'string') {
+            const itemId = `${event.runId}:assistant`;
+            const existing = this.raw
+                .prepare('SELECT payload, revision FROM conversation_items WHERE id = ?')
+                .get(itemId);
+            const previous = existing === undefined
+                ? ''
+                : (JSON.parse(stringValue(existing, 'payload')).text ?? '');
+            const text = `${typeof previous === 'string' ? previous : ''}${payload.text}`;
+            const revision = existing === undefined ? 0 : numberValue(existing, 'revision') + 1;
+            this.raw
+                .prepare(`INSERT INTO conversation_items
+            (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, NULL, ?, ?, 'assistant_message', 'IN_PROGRESS', ?, ?, NULL, ?, ?)
+           ON CONFLICT(id) DO UPDATE SET source_sequence = excluded.source_sequence, revision = excluded.revision,
+             payload = excluded.payload, updated_at = excluded.updated_at`)
+                .run(itemId, sessionId, turnId, event.runId, event.sequence, revision, JSON.stringify({ text, format: 'markdown', model: null }), timestamp, timestamp, timestamp);
+            this.recordConversationItemChange(sessionId, itemId, revision);
+        }
+        if (event.eventType === 'tool' && typeof payload?.name === 'string') {
+            this.raw
+                .prepare(`INSERT INTO conversation_items
+            (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+           VALUES (?, ?, ?, ?, NULL, ?, 0, 'tool_call', 'COMPLETED', ?, ?, ?, ?, ?)`)
+                .run(`${event.runId}:tool:${event.sequence}`, sessionId, turnId, event.runId, event.sequence, JSON.stringify({
+                namespace: 'runner',
+                toolName: payload.name,
+                title: payload.name,
+                inputSummary: payload.input === undefined ? null : JSON.stringify(payload.input),
+                outputSummary: null,
+                progressLabel: null,
+                errorCode: null,
+                truncated: false
+            }), timestamp, timestamp, timestamp, timestamp);
+            this.recordConversationItemChange(sessionId, `${event.runId}:tool:${event.sequence}`, 0);
+        }
+        if (status !== undefined) {
+            const turnStatus = status === 'SUCCEEDED'
+                ? 'SUCCEEDED'
+                : status === 'FAILED'
+                    ? 'FAILED'
+                    : status === 'CANCELLED'
+                        ? 'CANCELLED'
+                        : status === 'INTERRUPTED'
+                            ? 'INTERRUPTED'
+                            : status === 'STARTING' || status === 'RUNNING'
+                                ? 'RUNNING'
+                                : 'QUEUED';
+            const complete = terminal(status);
+            this.raw
+                .prepare('UPDATE conversation_turns SET status = ?, started_at = COALESCE(started_at, ?), completed_at = ?, updated_at = ? WHERE id = ?')
+                .run(turnStatus, timestamp, complete ? timestamp : null, timestamp, turnId);
+            if (complete) {
+                const pendingItems = this.raw
+                    .prepare("SELECT id FROM conversation_items WHERE turn_id = ? AND status IN ('PENDING', 'IN_PROGRESS')")
+                    .all(turnId);
+                this.raw
+                    .prepare("UPDATE conversation_items SET status = ?, revision = revision + 1, completed_at = ?, updated_at = ? WHERE turn_id = ? AND status IN ('PENDING', 'IN_PROGRESS')")
+                    .run(status === 'SUCCEEDED'
+                    ? 'COMPLETED'
+                    : status === 'FAILED'
+                        ? 'FAILED'
+                        : status === 'CANCELLED'
+                            ? 'CANCELLED'
+                            : 'INTERRUPTED', timestamp, timestamp, turnId);
+                for (const item of pendingItems) {
+                    const itemId = stringValue(item, 'id');
+                    const current = this.raw
+                        .prepare('SELECT revision FROM conversation_items WHERE id = ?')
+                        .get(itemId);
+                    this.recordConversationItemChange(sessionId, itemId, numberValue(current, 'revision'));
+                }
+                const summaryId = `${event.runId}:summary`;
+                const startedAt = nullableNumber(turn, 'started_at');
+                const durationMs = startedAt === null ? null : Math.max(0, timestamp - startedAt);
+                this.raw
+                    .prepare(`INSERT INTO conversation_items
+              (id, session_id, turn_id, run_id, parent_item_id, source_sequence, revision, kind, status, payload, started_at, completed_at, created_at, updated_at)
+             VALUES (?, ?, ?, ?, NULL, ?, 0, 'turn_summary', 'COMPLETED', ?, ?, ?, ?, ?)
+             ON CONFLICT(id) DO UPDATE SET revision = conversation_items.revision + 1,
+               status = excluded.status, payload = excluded.payload, completed_at = excluded.completed_at, updated_at = excluded.updated_at`)
+                    .run(summaryId, sessionId, turnId, event.runId, event.sequence, JSON.stringify({ status, durationMs }), startedAt ?? timestamp, timestamp, timestamp, timestamp);
+                const summary = this.raw
+                    .prepare('SELECT revision FROM conversation_items WHERE id = ?')
+                    .get(summaryId);
+                this.recordConversationItemChange(sessionId, summaryId, numberValue(summary, 'revision'));
+            }
+        }
+        this.raw
+            .prepare('UPDATE agent_sessions SET last_activity_at = ?, updated_at = ? WHERE id = ?')
+            .run(timestamp, timestamp, sessionId);
+    }
+    nodeIdProvider;
+}
+function migrate(database) {
+    database.exec(`CREATE TABLE IF NOT EXISTS node_schema_migrations (version INTEGER PRIMARY KEY, applied_at INTEGER NOT NULL) STRICT;
+     CREATE TABLE IF NOT EXISTS workspaces (
+       id TEXT PRIMARY KEY, path TEXT NOT NULL UNIQUE, kind TEXT NOT NULL CHECK (kind IN ('DIRECTORY', 'GIT_WORKSPACE')),
+       git_summary TEXT,
+       created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS agent_sessions (
+       id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL REFERENCES workspaces(id),
+       runner TEXT NOT NULL CHECK (runner IN ('codex', 'claude-code')), external_session_id TEXT,
+       native_control TEXT NOT NULL DEFAULT 'EXTERNAL' CHECK (native_control IN ('MAR_MANAGED', 'EXTERNAL')), channel_token TEXT,
+       cwd TEXT NOT NULL, model TEXT, effort TEXT, access TEXT, custom_title TEXT, runner_title TEXT, pinned_at INTEGER,
+       title_source TEXT NOT NULL DEFAULT 'AUTO' CHECK (title_source IN ('AUTO', 'RUNNER', 'CUSTOM')),
+       last_activity_at INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS native_session_checkpoints (
+       session_id TEXT PRIMARY KEY REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       digest TEXT NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS native_session_metadata (
+       runner TEXT NOT NULL CHECK (runner IN ('codex', 'claude-code')),
+       external_session_id TEXT NOT NULL, workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+       custom_title TEXT, runner_title TEXT, runner_title_pending INTEGER NOT NULL DEFAULT 0 CHECK (runner_title_pending IN (0, 1)), pinned_at INTEGER,
+       model TEXT, effort TEXT, access TEXT, updated_at INTEGER NOT NULL,
+       PRIMARY KEY (runner, external_session_id, workspace_id)
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS session_messages (
+       id TEXT PRIMARY KEY, session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       client_message_id TEXT NOT NULL, role TEXT NOT NULL CHECK (role IN ('USER', 'ASSISTANT', 'SYSTEM')),
+       content TEXT NOT NULL, created_at INTEGER NOT NULL, UNIQUE(session_id, client_message_id)
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS message_attachments (
+       id TEXT PRIMARY KEY, message_id TEXT NOT NULL REFERENCES session_messages(id) ON DELETE CASCADE,
+       name TEXT NOT NULL, mime TEXT NOT NULL, byte_size INTEGER NOT NULL CHECK (byte_size >= 0),
+       data BLOB NOT NULL, created_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS agent_runs (
+       id TEXT PRIMARY KEY, session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       message_id TEXT NOT NULL UNIQUE REFERENCES session_messages(id) ON DELETE CASCADE,
+       workspace_id TEXT NOT NULL REFERENCES workspaces(id), runner TEXT NOT NULL CHECK (runner IN ('codex', 'claude-code')),
+       status TEXT NOT NULL CHECK (status IN ('QUEUED', 'STARTING', 'RUNNING', 'CANCELLING', 'SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED')),
+       recovery_state TEXT NOT NULL CHECK (recovery_state IN ('ACTIVE', 'SUSPECT', 'LOST')),
+       recovery_updated_at INTEGER NOT NULL DEFAULT 0, version INTEGER NOT NULL CHECK (version >= 0),
+       created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS run_events (
+       id INTEGER PRIMARY KEY, run_id TEXT NOT NULL REFERENCES agent_runs(id) ON DELETE CASCADE,
+       sequence INTEGER NOT NULL CHECK (sequence > 0), event_type TEXT NOT NULL, payload TEXT NOT NULL,
+       created_at INTEGER NOT NULL, UNIQUE(run_id, sequence)
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS conversation_turns (
+       id TEXT PRIMARY KEY, session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       run_id TEXT UNIQUE REFERENCES agent_runs(id) ON DELETE SET NULL, user_item_id TEXT,
+       status TEXT NOT NULL, model TEXT, effort TEXT, access TEXT,
+       started_at INTEGER, completed_at INTEGER, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS conversation_items (
+       id TEXT PRIMARY KEY, session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       turn_id TEXT NOT NULL REFERENCES conversation_turns(id) ON DELETE CASCADE,
+       run_id TEXT REFERENCES agent_runs(id) ON DELETE SET NULL, parent_item_id TEXT,
+       source_sequence INTEGER, revision INTEGER NOT NULL CHECK (revision >= 0), kind TEXT NOT NULL,
+       status TEXT NOT NULL, payload TEXT NOT NULL, started_at INTEGER, completed_at INTEGER,
+       created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, UNIQUE(turn_id, id)
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS conversation_item_events (
+       id INTEGER PRIMARY KEY, session_id TEXT NOT NULL REFERENCES agent_sessions(id) ON DELETE CASCADE,
+       item_id TEXT NOT NULL REFERENCES conversation_items(id) ON DELETE CASCADE,
+       revision INTEGER NOT NULL CHECK (revision >= 0), created_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS workspace_activity_events (
+       id INTEGER PRIMARY KEY, workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+       event_type TEXT NOT NULL, payload TEXT NOT NULL, created_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS approvals (
+       id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES agent_runs(id) ON DELETE CASCADE,
+       status TEXT NOT NULL CHECK (status IN ('PENDING', 'APPROVED', 'REJECTED', 'EXPIRED')), payload TEXT NOT NULL,
+       expires_at INTEGER NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, decided_at INTEGER
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS workspace_leases (
+       id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+       run_id TEXT NOT NULL UNIQUE REFERENCES agent_runs(id) ON DELETE CASCADE,
+       state TEXT NOT NULL CHECK (state IN ('ACTIVE', 'SUSPECT', 'RELEASED')), created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE UNIQUE INDEX IF NOT EXISTS workspace_leases_active_workspace_idx
+       ON workspace_leases(workspace_id) WHERE state IN ('ACTIVE', 'SUSPECT');
+     CREATE TABLE IF NOT EXISTS run_snapshots (
+       run_id TEXT PRIMARY KEY REFERENCES agent_runs(id) ON DELETE CASCADE, snapshot TEXT NOT NULL, created_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS terminal_sessions (
+       id TEXT PRIMARY KEY, workspace_id TEXT REFERENCES workspaces(id) ON DELETE SET NULL, profile_id TEXT NOT NULL,
+       state TEXT NOT NULL CHECK (state IN ('RUNNING', 'EXITED', 'CLOSED')),
+       exit_code INTEGER, rows INTEGER NOT NULL CHECK (rows > 0 AND rows <= 1000),
+       cols INTEGER NOT NULL CHECK (cols > 0 AND cols <= 1000),
+       latest_sequence INTEGER NOT NULL CHECK (latest_sequence >= 0),
+       created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL
+     ) STRICT;
+     CREATE TABLE IF NOT EXISTS runner_defaults (
+       runner TEXT PRIMARY KEY CHECK (runner IN ('codex', 'claude-code')),
+       model TEXT NOT NULL, effort TEXT NOT NULL, access TEXT NOT NULL
+     ) STRICT;
+     CREATE INDEX IF NOT EXISTS agent_runs_session_idx ON agent_runs(session_id, created_at);
+     CREATE INDEX IF NOT EXISTS run_events_cursor_idx ON run_events(run_id, sequence);
+     CREATE INDEX IF NOT EXISTS conversation_turns_session_idx ON conversation_turns(session_id, created_at, id);
+     CREATE INDEX IF NOT EXISTS conversation_items_turn_idx ON conversation_items(turn_id, source_sequence);
+     CREATE INDEX IF NOT EXISTS conversation_items_session_cursor_idx ON conversation_items(session_id, updated_at, id);
+     CREATE INDEX IF NOT EXISTS conversation_item_events_session_cursor_idx ON conversation_item_events(session_id, id);
+     CREATE INDEX IF NOT EXISTS workspace_activity_cursor_idx ON workspace_activity_events(workspace_id, id);`);
+    database.exec('DROP TABLE IF EXISTS run_change_snapshots');
+    const workspaceColumns = database
+        .prepare('PRAGMA table_info(workspaces)')
+        .all();
+    // A short-lived legacy schema required this field without a default. The
+    // current Workspace model has no sharing flag, so retaining it would reject
+    // every subsequent registration performed by the current INSERT statement.
+    if (workspaceColumns.some((column) => column['name'] === 'share_allowed'))
+        database.exec('ALTER TABLE workspaces DROP COLUMN share_allowed');
+    const nativeMetadataColumns = database
+        .prepare('PRAGMA table_info(native_session_metadata)')
+        .all();
+    if (!nativeMetadataColumns.some((column) => column['name'] === 'runner_title'))
+        database.exec('ALTER TABLE native_session_metadata ADD COLUMN runner_title TEXT');
+    if (!nativeMetadataColumns.some((column) => column['name'] === 'runner_title_pending'))
+        database.exec('ALTER TABLE native_session_metadata ADD COLUMN runner_title_pending INTEGER NOT NULL DEFAULT 0 CHECK (runner_title_pending IN (0, 1))');
+    for (const column of ['model', 'effort', 'access']) {
+        if (!nativeMetadataColumns.some((value) => value['name'] === column))
+            database.exec(`ALTER TABLE native_session_metadata ADD COLUMN ${column} TEXT`);
+    }
+    const runnerDefaultColumns = database
+        .prepare('PRAGMA table_info(runner_defaults)')
+        .all();
+    if (runnerDefaultColumns.some((column) => column['name'] === 'singleton')) {
+        database.exec(`BEGIN IMMEDIATE;
+       CREATE TABLE runner_defaults_next (
+         runner TEXT PRIMARY KEY CHECK (runner IN ('codex', 'claude-code')),
+         model TEXT NOT NULL, effort TEXT NOT NULL, access TEXT NOT NULL
+       ) STRICT;
+       INSERT INTO runner_defaults_next (runner, model, effort, access)
+         SELECT runner, model, effort, access FROM runner_defaults;
+       DROP TABLE runner_defaults;
+       ALTER TABLE runner_defaults_next RENAME TO runner_defaults;
+       COMMIT;`);
+    }
+    const columns = database.prepare('PRAGMA table_info(agent_sessions)').all();
+    if (!columns.some((column) => column['name'] === 'native_control')) {
+        // Existing databases cannot prove how an old native ID was obtained.  The
+        // safe migration is therefore OBSERVE_ONLY until the user creates or
+        // resumes it through this Node again.
+        database.exec("ALTER TABLE agent_sessions ADD COLUMN native_control TEXT NOT NULL DEFAULT 'EXTERNAL' CHECK (native_control IN ('MAR_MANAGED', 'EXTERNAL'))");
+    }
+    if (!columns.some((column) => column['name'] === 'custom_title')) {
+        database.exec('ALTER TABLE agent_sessions ADD COLUMN custom_title TEXT');
+    }
+    if (!columns.some((column) => column['name'] === 'runner_title')) {
+        database.exec('ALTER TABLE agent_sessions ADD COLUMN runner_title TEXT');
+    }
+    if (!columns.some((column) => column['name'] === 'pinned_at')) {
+        database.exec('ALTER TABLE agent_sessions ADD COLUMN pinned_at INTEGER');
+    }
+    if (!columns.some((column) => column['name'] === 'title_source')) {
+        database.exec("ALTER TABLE agent_sessions ADD COLUMN title_source TEXT NOT NULL DEFAULT 'AUTO'");
+    }
+    if (!columns.some((column) => column['name'] === 'last_activity_at')) {
+        database.exec('ALTER TABLE agent_sessions ADD COLUMN last_activity_at INTEGER NOT NULL DEFAULT 0');
+    }
+    for (const column of ['model', 'effort', 'access']) {
+        if (!columns.some((value) => value['name'] === column)) {
+            database.exec(`ALTER TABLE agent_sessions ADD COLUMN ${column} TEXT`);
+        }
+    }
+    // Pre-existing projections did not retain a detail cursor stream. Seed one
+    // final snapshot event per item; native runner payload is never reconstructed.
+    database.exec(`INSERT INTO conversation_item_events (session_id, item_id, revision, created_at)
+     SELECT ci.session_id, ci.id, ci.revision, ci.updated_at
+     FROM conversation_items ci
+     WHERE NOT EXISTS (
+       SELECT 1 FROM conversation_item_events cie WHERE cie.item_id = ci.id
+     )`);
+    const terminalColumns = database
+        .prepare('PRAGMA table_info(terminal_sessions)')
+        .all();
+    if (!terminalColumns.some((column) => column['name'] === 'workspace_id')) {
+        database.exec('ALTER TABLE terminal_sessions ADD COLUMN workspace_id TEXT REFERENCES workspaces(id) ON DELETE SET NULL');
+    }
+    const approvalDefinition = database
+        .prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'approvals'")
+        .get();
+    if (approvalDefinition !== undefined &&
+        !stringValue(approvalDefinition, 'sql').includes("'EXPIRED'")) {
+        database.exec(`BEGIN IMMEDIATE;
+       CREATE TABLE approvals_next (
+         id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES agent_runs(id) ON DELETE CASCADE,
+         status TEXT NOT NULL CHECK (status IN ('PENDING', 'APPROVED', 'REJECTED', 'EXPIRED')), payload TEXT NOT NULL,
+         expires_at INTEGER NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, decided_at INTEGER
+       ) STRICT;
+       INSERT INTO approvals_next (id, run_id, status, payload, expires_at, created_at, updated_at, decided_at)
+         SELECT id, run_id, status, payload, expires_at, created_at, updated_at, decided_at FROM approvals;
+       DROP TABLE approvals;
+       ALTER TABLE approvals_next RENAME TO approvals;
+       COMMIT;`);
+    }
+}
+function workspace(row) {
+    const summary = nullableString(row, 'git_summary');
+    return {
+        id: stringValue(row, 'id'),
+        path: stringValue(row, 'path'),
+        kind: stringValue(row, 'kind'),
+        gitSummary: summary === null ? null : JSON.parse(summary)
+    };
+}
+function terminalSession(row) {
+    const state = stringValue(row, 'state');
+    if (state !== 'RUNNING' && state !== 'EXITED' && state !== 'CLOSED')
+        throw new Error('DATABASE_VALUE_INVALID:terminal_state');
+    return {
+        id: stringValue(row, 'id'),
+        workspaceId: nullableString(row, 'workspace_id'),
+        profileId: stringValue(row, 'profile_id'),
+        state,
+        exitCode: nullableNumber(row, 'exit_code'),
+        rows: numberValue(row, 'rows'),
+        cols: numberValue(row, 'cols'),
+        latestSequence: numberValue(row, 'latest_sequence'),
+        createdAt: numberValue(row, 'created_at'),
+        updatedAt: numberValue(row, 'updated_at')
+    };
+}
+function session(row, nodeId) {
+    return {
+        id: stringValue(row, 'id'),
+        nodeId,
+        workspaceId: stringValue(row, 'workspace_id'),
+        runner: stringValue(row, 'runner'),
+        externalSessionId: nullableString(row, 'external_session_id'),
+        nativeControl: stringValue(row, 'native_control') === 'MAR_MANAGED' ? 'MAR_MANAGED' : 'EXTERNAL',
+        channelToken: nullableString(row, 'channel_token'),
+        cwd: stringValue(row, 'cwd'),
+        model: nullableString(row, 'model'),
+        effort: nullableString(row, 'effort'),
+        access: nullableString(row, 'access'),
+        customTitle: nullableString(row, 'custom_title'),
+        runnerTitle: nullableString(row, 'runner_title'),
+        pinnedAt: row['pinned_at'] === null ? null : numberValue(row, 'pinned_at'),
+        titleSource: stringValue(row, 'title_source') === 'CUSTOM'
+            ? 'CUSTOM'
+            : stringValue(row, 'title_source') === 'RUNNER'
+                ? 'RUNNER'
+                : 'AUTO',
+        lastActivityAt: numberValue(row, 'last_activity_at'),
+        createdAt: numberValue(row, 'created_at')
+    };
+}
+function run(row, nodeId) {
+    const recovery = stringValue(row, 'recovery_state');
+    return {
+        id: stringValue(row, 'id'),
+        sessionId: stringValue(row, 'session_id'),
+        nodeId,
+        workspaceId: stringValue(row, 'workspace_id'),
+        runner: stringValue(row, 'runner'),
+        status: stringValue(row, 'status'),
+        recoveryState: recovery === 'SUSPECT' || recovery === 'LOST' ? recovery : 'ACTIVE',
+        version: numberValue(row, 'version'),
+        clientMessageId: stringValue(row, 'client_message_id'),
+        createdAt: numberValue(row, 'created_at'),
+        updatedAt: numberValue(row, 'updated_at')
+    };
+}
+function event(row) {
+    return {
+        id: numberValue(row, 'id'),
+        runId: stringValue(row, 'run_id'),
+        sequence: numberValue(row, 'sequence'),
+        eventType: stringValue(row, 'event_type'),
+        payload: JSON.parse(stringValue(row, 'payload')),
+        createdAt: numberValue(row, 'created_at')
+    };
+}
+function conversationItem(row) {
+    return {
+        id: stringValue(row, 'id'),
+        sessionId: stringValue(row, 'session_id'),
+        turnId: stringValue(row, 'turn_id'),
+        runId: nullableString(row, 'run_id'),
+        parentItemId: nullableString(row, 'parent_item_id'),
+        sourceSequence: nullableNumber(row, 'source_sequence'),
+        revision: numberValue(row, 'revision'),
+        kind: stringValue(row, 'kind'),
+        status: stringValue(row, 'status'),
+        payload: JSON.parse(stringValue(row, 'payload')),
+        startedAt: nullableNumber(row, 'started_at'),
+        completedAt: nullableNumber(row, 'completed_at')
+    };
+}
+function workspaceActivityEvent(row) {
+    return {
+        id: numberValue(row, 'id'),
+        workspaceId: stringValue(row, 'workspace_id'),
+        eventType: stringValue(row, 'event_type'),
+        payload: JSON.parse(stringValue(row, 'payload')),
+        createdAt: numberValue(row, 'created_at')
+    };
+}
+function pageLimit(value) {
+    if (value === undefined)
+        return 100;
+    if (!Number.isSafeInteger(value) || value < 1 || value > 500)
+        throw new Error('EVENT_CURSOR_INVALID');
+    return value;
+}
+function encodeCursor(scope, streamId, value, id) {
+    return Buffer.from(JSON.stringify({ scope, streamId, value, id }), 'utf8').toString('base64url');
+}
+function decodeCursor(token, scope, streamId) {
+    if (token === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(token, 'base64url').toString('utf8'));
+        if (value.scope !== scope ||
+            value.streamId !== streamId ||
+            typeof value.value !== 'number' ||
+            !Number.isSafeInteger(value.value) ||
+            value.value < 0 ||
+            typeof value.id !== 'string')
+            throw new Error('EVENT_CURSOR_INVALID');
+        return { value: value.value, id: value.id };
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}
+function approval(row, now) {
+    const expiresAt = numberValue(row, 'expires_at');
+    const stored = stringValue(row, 'status');
+    return {
+        id: stringValue(row, 'id'),
+        runId: stringValue(row, 'run_id'),
+        status: stored === 'PENDING' && expiresAt <= now ? 'EXPIRED' : stored,
+        payload: JSON.parse(stringValue(row, 'payload')),
+        expiresAt,
+        createdAt: numberValue(row, 'created_at'),
+        decidedAt: row['decided_at'] === null ? null : numberValue(row, 'decided_at')
+    };
+}
+function stringValue(row, key) {
+    const value = row[key];
+    if (typeof value !== 'string')
+        throw new Error(`DATABASE_VALUE_INVALID:${key}`);
+    return value;
+}
+function nullableString(row, key) {
+    const value = row[key];
+    if (value === null || typeof value === 'string')
+        return value;
+    throw new Error(`DATABASE_VALUE_INVALID:${key}`);
+}
+function optionValue(value) {
+    if (value === undefined)
+        return null;
+    const normalized = value.trim();
+    if (normalized.length === 0 || normalized.length > 120)
+        throw new Error('SESSION_OPTION_INVALID');
+    return normalized;
+}
+function normalizeAttachments(attachments) {
+    if (attachments.length > 5)
+        throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+    let total = 0;
+    return attachments.map((attachment) => {
+        if (attachment.name.trim().length === 0 ||
+            attachment.name.length > 255 ||
+            attachment.mime.length > 120 ||
+            !/^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9!#$&^_.+-]+$/.test(attachment.mime))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        if (attachment.dataBase64.length > 7 * 1024 * 1024 ||
+            attachment.dataBase64.length % 4 !== 0 ||
+            !/^[A-Za-z0-9+/]*={0,2}$/.test(attachment.dataBase64))
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        let data;
+        try {
+            data = Buffer.from(attachment.dataBase64, 'base64');
+        }
+        catch {
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        }
+        if (data.length === 0 || data.length > 5 * 1024 * 1024)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        total += data.length;
+        if (total > 10 * 1024 * 1024)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        return { name: attachment.name.trim(), mime: attachment.mime, data };
+    });
+}
+function nullableNumber(row, key) {
+    const value = row[key];
+    if (value === null || typeof value === 'number')
+        return value;
+    throw new Error(`DATABASE_VALUE_INVALID:${key}`);
+}
+function numberValue(row, key) {
+    const value = row[key];
+    if (typeof value !== 'number')
+        throw new Error(`DATABASE_VALUE_INVALID:${key}`);
+    return value;
+}
+function isConstraint(error) {
+    return error instanceof Error && /constraint/i.test(error.message);
+}
+function terminal(status) {
+    return (status === 'SUCCEEDED' ||
+        status === 'FAILED' ||
+        status === 'CANCELLED' ||
+        status === 'INTERRUPTED');
+}
+function transitionAllowed(current, next) {
+    if (current === next)
+        return true;
+    if (terminal(current))
+        return false;
+    return ((current === 'QUEUED' && (next === 'STARTING' || next === 'CANCELLED' || next === 'FAILED')) ||
+        (current === 'STARTING' &&
+            (next === 'RUNNING' || next === 'CANCELLING' || next === 'FAILED' || next === 'CANCELLED')) ||
+        (current === 'RUNNING' &&
+            (next === 'CANCELLING' ||
+                next === 'SUCCEEDED' ||
+                next === 'FAILED' ||
+                next === 'INTERRUPTED')) ||
+        (current === 'CANCELLING' &&
+            (next === 'CANCELLED' || next === 'FAILED' || next === 'INTERRUPTED')));
+}
+//# sourceMappingURL=database.js.map