@playcraft/cli 0.0.59 → 0.1.1

package/dist/workspace-runtime/persistence/sqlite-worker.js

@@ -0,0 +1,1025 @@
+/**
+ * Dedicated SQLite writer for the CLI platform state file.
+ * The main thread never opens runtime-state.sqlite.
+ *
+ * Binding pin: better-sqlite3@13.0.3 vendors SQLite 3.53.4, which includes the
+ * official WAL-reset fix (3.51.3). Node's built-in node:sqlite on Node 22.22.1
+ * reports 3.51.2 and must not be used for this file.
+ * Do not read Codex JSONL from this worker.
+ */
+import { randomBytes, randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { parentPort } from 'node:worker_threads';
+import Database from 'better-sqlite3-pinned';
+import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, checkpointRecordSchema, terminalRecordSchema, workspaceRegistrationSchema, transitionOperation, canTransitionTurn, } from '@playcraft/common/cloud-workspace/runtime';
+const SCHEMA_VERSION = 1;
+const MIN_SQLITE = [3, 51, 3];
+const BINDING = 'better-sqlite3@13.0.3';
+const MAX_PINS = 32;
+const MAX_PIN_MS = 120_000;
+let db;
+const port = parentPort;
+if (!port)
+    throw new Error('sqlite_worker_without_parent');
+port.on('message', (message) => {
+    try {
+        const result = dispatch(message.type, message.payload ?? {});
+        port.postMessage({ id: message.id, ok: true, result });
+    }
+    catch (error) {
+        port.postMessage({
+            id: message.id,
+            ok: false,
+            error: error instanceof Error ? error.message : 'sqlite_worker_failed',
+        });
+    }
+});
+function dispatch(type, payload) {
+    if (type === 'open')
+        return openDatabase(asRecord(payload));
+    if (type === 'close') {
+        db?.close();
+        db = undefined;
+        return { closed: true };
+    }
+    const database = requireDb();
+    const body = asRecord(payload);
+    const write = database.transaction(() => {
+        switch (type) {
+            case 'upsertRecord':
+                upsertRecord(database, String(body.bucket), String(body.key), body.body);
+                return;
+            case 'deleteRecord':
+                database.prepare('DELETE FROM records WHERE bucket = ? AND record_key = ?').run(body.bucket, body.key);
+                return;
+            case 'replaceBucket':
+                replaceBucket(database, String(body.bucket), Array.isArray(body.entries) ? body.entries : []);
+                return;
+            case 'forgetWorkspaces':
+                database.prepare(`DELETE FROM records WHERE bucket = 'workspaces'`).run();
+                return;
+            case 'putOperation':
+                putOperation(database, String(body.scopeKey), body.operation);
+                return;
+            case 'setAcceptedFence':
+                setMeta(database, 'accepted_lease_fence', String(Math.max(metaNumber(database, 'accepted_lease_fence'), Number(body.value) || 0)));
+                return;
+            case 'setDestroyed':
+                setMeta(database, 'destroyed', '1');
+                return;
+            case 'setCheckpointId':
+                setMeta(database, body.field === 'consistent' ? 'consistent_checkpoint_id' : 'file_checkpoint_id', String(body.id));
+                return;
+            case 'noteExecutionGroup':
+                setMeta(database, 'execution_group', JSON.stringify({ ...(executionGroup(database)), ...asRecord(body.group) }));
+                return;
+            case 'setStopConfirmed':
+                setMeta(database, 'execution_group', JSON.stringify({ ...executionGroup(database), stopConfirmed: body.stopConfirmed === true }));
+                return;
+            case 'writeExecutionEpoch':
+                writeExecutionEpoch(database, body);
+                return;
+            case 'bindRuntime':
+                bindRuntime(database, body);
+                return;
+            case 'allocateEvent':
+                return allocateEvent(database, body);
+            case 'commitIdentity':
+                commitIdentity(database, body.event);
+                return;
+            case 'ingest':
+                return ingest(database, body);
+            case 'bindTurn':
+                return bindTurn(database, body);
+            case 'ack':
+                acknowledge(database, body);
+                return;
+            case 'createPin':
+                return createPin(database, body);
+            case 'deletePin':
+                database.prepare('DELETE FROM replay_pins WHERE pin_id = ?').run(String(body.pinId));
+                return { deleted: true };
+            case 'reclaim':
+                reclaim(database, Number(body.minRetainMs) || 0);
+                return;
+            case 'maintain':
+                database.pragma('wal_checkpoint(PASSIVE)');
+                return;
+            default:
+                throw new Error(`unknown_sqlite_command:${type}`);
+        }
+    });
+    const extra = write();
+    return { ...dump(database), ...(extra && typeof extra === 'object' ? extra : {}) };
+}
+function openDatabase(payload) {
+    if (db)
+        throw new Error('sqlite_already_open');
+    const filePath = String(payload.filePath ?? '');
+    if (!filePath)
+        throw new Error('sqlite_path_missing');
+    mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+    const database = new Database(filePath);
+    db = database;
+    const version = String(database.prepare('select sqlite_version() as v').get().v);
+    if (!sqliteAtLeast(version, MIN_SQLITE)) {
+        database.close();
+        db = undefined;
+        throw new Error(`sqlite_engine_too_old:${version}`);
+    }
+    const existing = readSchemaVersion(database);
+    if (existing !== null && existing !== SCHEMA_VERSION) {
+        database.close();
+        db = undefined;
+        throw new Error(`unsupported_runtime_state:${existing}`);
+    }
+    database.pragma('journal_mode = WAL');
+    database.pragma('synchronous = FULL');
+    database.pragma('wal_autocheckpoint = 0');
+    database.pragma('busy_timeout = 2000');
+    const journalMode = String(database.pragma('journal_mode', { simple: true }));
+    const synchronous = Number(database.pragma('synchronous', { simple: true }));
+    if (journalMode !== 'wal')
+        throw new Error(`journal_mode_not_wal:${journalMode}`);
+    if (synchronous !== 2)
+        throw new Error(`synchronous_not_full:${synchronous}`);
+    chmodSync(filePath, 0o600);
+    let imported = false;
+    if (existing === null) {
+        createSchema(database);
+        if (payload.legacy && typeof payload.legacy === 'object') {
+            importLegacy(database, payload.legacy);
+            imported = true;
+        }
+        quarantineReservedTurns(database);
+    }
+    else {
+        quarantineReservedTurns(database);
+    }
+    return {
+        ...dump(database),
+        imported,
+        engine: { version, journalMode, synchronous, binding: BINDING },
+    };
+}
+function createSchema(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS library_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS source_epochs (
+      runtime_id TEXT NOT NULL,
+      generation INTEGER NOT NULL,
+      runtime_epoch INTEGER NOT NULL,
+      next_sequence INTEGER NOT NULL,
+      local_durable_through INTEGER NOT NULL,
+      cloud_ack_through INTEGER NOT NULL,
+      retained_from INTEGER NOT NULL,
+      PRIMARY KEY (runtime_id, generation, runtime_epoch)
+    );
+    CREATE TABLE IF NOT EXISTS source_events (
+      runtime_id TEXT NOT NULL,
+      generation INTEGER NOT NULL,
+      runtime_epoch INTEGER NOT NULL,
+      source_sequence INTEGER NOT NULL,
+      payload_hash TEXT NOT NULL,
+      workspace_id TEXT,
+      session_id TEXT,
+      operation_id TEXT,
+      thread_id TEXT,
+      turn_id TEXT,
+      item_id TEXT,
+      type TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      occurred_at TEXT NOT NULL,
+      PRIMARY KEY (runtime_id, generation, runtime_epoch, source_sequence)
+    );
+    CREATE TABLE IF NOT EXISTS native_inbox (
+      ingress_sequence INTEGER PRIMARY KEY,
+      runtime_epoch INTEGER NOT NULL,
+      kind TEXT NOT NULL,
+      method TEXT,
+      thread_id TEXT,
+      turn_id TEXT,
+      item_id TEXT,
+      payload_json TEXT NOT NULL,
+      converted INTEGER NOT NULL DEFAULT 0,
+      source_sequence INTEGER,
+      received_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS operation_intents (
+      scope_key TEXT PRIMARY KEY,
+      operation_json TEXT NOT NULL,
+      gateway_operation_id TEXT,
+      sandbox_operation_id TEXT NOT NULL,
+      payload_hash TEXT NOT NULL,
+      native_request_id TEXT,
+      thread_id TEXT,
+      turn_id TEXT,
+      reconcile_status TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS replay_pins (
+      pin_id TEXT PRIMARY KEY,
+      epochs_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS records (
+      bucket TEXT NOT NULL,
+      record_key TEXT NOT NULL,
+      body_json TEXT NOT NULL,
+      PRIMARY KEY (bucket, record_key)
+    );
+  `);
+    setMeta(database, 'schema_version', String(SCHEMA_VERSION));
+    setMeta(database, 'migration_status', 'complete');
+    setMeta(database, 'source_read_token', randomBytes(32).toString('base64url'));
+    setMeta(database, 'accepted_lease_fence', '0');
+    setMeta(database, 'destroyed', '0');
+    setMeta(database, 'runtime_epoch', '0');
+    setMeta(database, 'ingress_counter', '0');
+    setMeta(database, 'execution_group', JSON.stringify({ stopConfirmed: false, replaced: false }));
+}
+function readSchemaVersion(database) {
+    const table = database
+        .prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'library_meta'`)
+        .get();
+    if (!table)
+        return null;
+    const row = database.prepare(`SELECT value FROM library_meta WHERE key = 'schema_version'`).get();
+    if (!row?.value)
+        return null;
+    const parsed = Number(row.value);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+function importLegacy(database, legacy) {
+    const snapshot = asRecord(legacy);
+    const operations = asRecord(snapshot.operations);
+    for (const [scopeKey, value] of Object.entries(operations)) {
+        const parsed = operationRecordSchema.safeParse(value);
+        if (!parsed.success)
+            continue;
+        putOperation(database, scopeKey, parsed.data);
+    }
+    const events = asRecord(snapshot.events);
+    const sequences = [];
+    for (const value of Object.values(events)) {
+        const parsed = pendingSourceEventSchema.safeParse(value);
+        if (!parsed.success)
+            continue;
+        const hash = hashOperationPayload(parsed.data.payload);
+        if (hash !== parsed.data.payloadHash)
+            continue;
+        insertEventRow(database, parsed.data, {});
+        sequences.push(parsed.data.source.sourceSequence);
+    }
+    const declared = Number(snapshot.lastSourceSequence) || 0;
+    const maxImported = sequences.reduce((max, value) => Math.max(max, value), 0);
+    const counter = Math.max(declared, maxImported, 0);
+    const runtimeId = firstString(snapshot, 'runtimeId') || eventRuntime(events, 'runtimeId');
+    const generation = Number.isInteger(snapshot.generation) ? Number(snapshot.generation) : eventRuntimeNumber(events, 'generation');
+    const runtimeEpoch = Number.isInteger(snapshot.runtimeEpoch)
+        ? Number(snapshot.runtimeEpoch)
+        : eventRuntimeNumber(events, 'runtimeEpoch');
+    if (runtimeId) {
+        ensureEpoch(database, runtimeId, generation, runtimeEpoch);
+        database
+            .prepare(`UPDATE source_epochs SET next_sequence = ?, local_durable_through = ?
+         WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?`)
+            .run(counter, counter, runtimeId, generation, runtimeEpoch);
+        setMeta(database, 'runtime_id', runtimeId);
+        setMeta(database, 'generation', String(generation));
+    }
+    importBucket(database, 'workspaces', asRecord(snapshot.workspaces), (value) => workspaceRegistrationSchema.safeParse(value).success);
+    importBucket(database, 'sessions', asRecord(snapshot.sessions), (value) => {
+        const session = asRecord(value);
+        return typeof session.sessionId === 'string' && typeof session.threadId === 'string';
+    });
+    importBucket(database, 'terminals', asRecord(snapshot.terminals), (value) => terminalRecordSchema.safeParse(value).success);
+    importBucket(database, 'checkpoints', asRecord(snapshot.checkpoints), (value) => checkpointRecordSchema.safeParse(value).success);
+    importBucket(database, 'approvals', asRecord(snapshot.approvals), (value) => isApproval(value));
+    importBucket(database, 'managed_writes', asRecord(snapshot.managedWrites), () => true);
+    importBucket(database, 'file_revisions', asRecord(snapshot.fileRevisions), () => true);
+    importBucket(database, 'receipts', asRecord(snapshot.receipts), () => true);
+    const workspaceFiles = asRecord(snapshot.workspaceFileRevisions);
+    for (const [workspaceId, files] of Object.entries(workspaceFiles)) {
+        importBucket(database, `workspace_files:${workspaceId}`, asRecord(files), () => true);
+    }
+    if (typeof snapshot.fileCheckpointId === 'string')
+        setMeta(database, 'file_checkpoint_id', snapshot.fileCheckpointId);
+    if (typeof snapshot.consistentCheckpointId === 'string') {
+        setMeta(database, 'consistent_checkpoint_id', snapshot.consistentCheckpointId);
+    }
+    setMeta(database, 'accepted_lease_fence', String(Number(snapshot.acceptedLeaseFence) || 0));
+    setMeta(database, 'destroyed', snapshot.destroyed === true ? '1' : '0');
+    setMeta(database, 'runtime_epoch', String(runtimeEpoch));
+    if (snapshot.executionGroup && typeof snapshot.executionGroup === 'object') {
+        setMeta(database, 'execution_group', JSON.stringify(snapshot.executionGroup));
+    }
+    setMeta(database, 'migration_status', 'complete');
+}
+function quarantineReservedTurns(database) {
+    const rows = database.prepare('SELECT scope_key, operation_json FROM operation_intents').all();
+    for (const row of rows) {
+        const parsed = operationRecordSchema.safeParse(JSON.parse(row.operation_json));
+        if (!parsed.success)
+            continue;
+        const operation = parsed.data;
+        if (operation.kind !== 'session.turn' || operation.status !== 'dispatched')
+            continue;
+        if (!operation.nativeRequestId || operation.nativeTurnId)
+            continue;
+        const uncertain = transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' });
+        putOperation(database, row.scope_key, uncertain);
+        if (operation.sessionId) {
+            const session = readSession(database, operation.sessionId);
+            if (session) {
+                upsertRecord(database, 'sessions', operation.sessionId, { ...session, turnBlock: 'uncertain', turnStatus: 'starting' });
+            }
+        }
+    }
+}
+function allocateEvent(database, body) {
+    const runtimeId = String(body.runtimeId);
+    const generation = Number(body.generation);
+    const runtimeEpoch = Number(body.runtimeEpoch);
+    ensureEpoch(database, runtimeId, generation, runtimeEpoch);
+    const allocated = database
+        .prepare(`UPDATE source_epochs
+       SET next_sequence = next_sequence + 1,
+           local_durable_through = next_sequence + 1
+       WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?
+       RETURNING next_sequence`)
+        .get(runtimeId, generation, runtimeEpoch);
+    const payload = body.payload ?? {};
+    const event = pendingSourceEventSchema.parse({
+        source: { runtimeId, generation, runtimeEpoch, sourceSequence: allocated.next_sequence },
+        payloadHash: hashOperationPayload(payload),
+        type: String(body.type),
+        payload,
+        occurredAt: String(body.occurredAt),
+    });
+    insertEventRow(database, event, {
+        workspaceId: optionalString(body.workspaceId),
+        sessionId: optionalString(body.sessionId),
+        operationId: optionalString(body.operationId),
+        threadId: optionalString(body.threadId),
+        turnId: optionalString(body.turnId),
+        itemId: optionalString(body.itemId),
+    });
+    return { committedEvents: [event] };
+}
+function commitIdentity(database, value) {
+    const event = pendingSourceEventSchema.parse(value);
+    const existing = database
+        .prepare(`SELECT payload_hash, payload_json, type, occurred_at FROM source_events
+       WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ? AND source_sequence = ?`)
+        .get(event.source.runtimeId, event.source.generation, event.source.runtimeEpoch, event.source.sourceSequence);
+    if (existing) {
+        if (existing.payload_hash !== event.payloadHash)
+            throw new Error('source_payload_mismatch');
+        return { committedEvents: [] };
+    }
+    ensureEpoch(database, event.source.runtimeId, event.source.generation, event.source.runtimeEpoch);
+    insertEventRow(database, event, {});
+    database
+        .prepare(`UPDATE source_epochs
+       SET next_sequence = CASE WHEN next_sequence < ? THEN ? ELSE next_sequence END,
+           local_durable_through = CASE WHEN local_durable_through < ? THEN ? ELSE local_durable_through END
+       WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?`)
+        .run(event.source.sourceSequence, event.source.sourceSequence, event.source.sourceSequence, event.source.sourceSequence, event.source.runtimeId, event.source.generation, event.source.runtimeEpoch);
+    return { committedEvents: [event] };
+}
+function ingest(database, body) {
+    const native = nativeIds(body.params);
+    const threadId = optionalString(body.threadId) || native.threadId;
+    const turnId = optionalString(body.turnId) || native.turnId;
+    const itemId = optionalString(body.itemId) || native.itemId;
+    const ingress = nextIngress(database);
+    const kind = String(body.kind);
+    const method = optionalString(body.method);
+    const session = threadId ? sessionByThread(database, threadId) : undefined;
+    const hintedTurn = turnId || nativeIds(body.params).turnId;
+    const operation = hintedTurn ? operationByTurn(database, hintedTurn) : undefined;
+    const linked = canConvert(kind, threadId, hintedTurn, session, operation);
+    database
+        .prepare(`INSERT INTO native_inbox (
+        ingress_sequence, runtime_epoch, kind, method, thread_id, turn_id, item_id, payload_json, converted, received_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`)
+        .run(ingress, Number(body.runtimeEpoch) || 0, kind, method ?? null, threadId ?? null, hintedTurn ?? null, itemId ?? null, JSON.stringify(body.params ?? {}), String(body.occurredAt));
+    if (!linked)
+        return { committedEvents: [] };
+    const earlier = operation
+        ? releaseInbox(database, threadId ?? '', hintedTurn ?? '', { scopeKey: operation.scopeKey, operation: operation.operation }, ingress)
+        : [];
+    const event = convertInboxRow(database, ingress, {
+        runtimeId: String(body.runtimeId),
+        generation: Number(body.generation) || 0,
+        runtimeEpoch: Number(body.runtimeEpoch) || 0,
+        kind,
+        method,
+        threadId,
+        turnId: hintedTurn,
+        itemId,
+        occurredAt: String(body.occurredAt),
+        session,
+        operation,
+    });
+    return { committedEvents: event ? [...earlier, event] : earlier };
+}
+function bindTurn(database, body) {
+    const operation = operationRecordSchema.parse(body.operation);
+    putOperation(database, String(body.scopeKey), operation);
+    const sessionId = String(body.sessionId);
+    const session = readSession(database, sessionId);
+    if (session) {
+        upsertRecord(database, 'sessions', sessionId, {
+            ...session,
+            turnStatus: 'running',
+            turnBlock: undefined,
+            activeTurnId: String(body.turnId),
+            threadId: String(body.threadId),
+        });
+    }
+    const threadId = String(body.threadId);
+    const turnId = String(body.turnId);
+    const released = releaseInbox(database, threadId, turnId, { scopeKey: String(body.scopeKey), operation });
+    applyRecordedTurn(database, threadId, turnId);
+    return { committedEvents: released };
+}
+function releaseInbox(database, threadId, turnId, bound, beforeIngress) {
+    const rows = database
+        .prepare(`SELECT ingress_sequence FROM native_inbox
+       WHERE converted = 0
+         AND (? IS NULL OR ingress_sequence < ?)
+         AND (turn_id = ? OR (thread_id = ? AND turn_id IS NULL))
+       ORDER BY ingress_sequence`)
+        .all(beforeIngress ?? null, beforeIngress ?? null, turnId, threadId);
+    const events = [];
+    for (const row of rows) {
+        const stored = database.prepare('SELECT * FROM native_inbox WHERE ingress_sequence = ?').get(row.ingress_sequence);
+        if (stored.turn_id && stored.turn_id !== turnId)
+            continue;
+        const session = sessionByThread(database, threadId);
+        const operation = operationByTurn(database, turnId) ?? bound;
+        const event = convertInboxRow(database, row.ingress_sequence, {
+            runtimeId: metaString(database, 'runtime_id') || 'runtime',
+            generation: metaNumber(database, 'generation'),
+            runtimeEpoch: Number(stored.runtime_epoch) || metaNumber(database, 'runtime_epoch'),
+            kind: String(stored.kind),
+            method: optionalString(stored.method),
+            threadId,
+            turnId: optionalString(stored.turn_id) || turnId,
+            itemId: optionalString(stored.item_id),
+            occurredAt: String(stored.received_at),
+            session,
+            operation,
+            params: JSON.parse(String(stored.payload_json || '{}')),
+        });
+        if (event)
+            events.push(event);
+    }
+    return events;
+}
+function convertInboxRow(database, ingress, input) {
+    const row = database.prepare('SELECT payload_json, converted FROM native_inbox WHERE ingress_sequence = ?').get(ingress);
+    if (!row || row.converted)
+        return undefined;
+    const params = input.params ?? JSON.parse(row.payload_json || '{}');
+    const payload = linkedPayload(params, input.session);
+    const type = input.kind === 'process_exit' ? 'process.exited' : input.method || input.kind;
+    const allocated = allocateEvent(database, {
+        runtimeId: input.runtimeId || metaString(database, 'runtime_id'),
+        generation: input.generation,
+        runtimeEpoch: input.runtimeEpoch,
+        type,
+        payload,
+        occurredAt: input.occurredAt,
+        workspaceId: optionalString(input.session?.workspaceId),
+        sessionId: optionalString(input.session?.sessionId),
+        operationId: input.operation?.operation.operationId,
+        threadId: input.threadId,
+        turnId: input.turnId,
+        itemId: input.itemId,
+    });
+    const event = allocated.committedEvents[0];
+    if (!event)
+        return undefined;
+    database
+        .prepare(`UPDATE native_inbox
+       SET converted = 1, source_sequence = ?, payload_json = '{}'
+       WHERE ingress_sequence = ?`)
+        .run(event.source.sourceSequence, ingress);
+    applyNativeToState(database, { ...input, operation: resolveOperation(database, input, payload) }, payload);
+    return event;
+}
+function applyRecordedTurn(database, threadId, turnId) {
+    const rows = database
+        .prepare(`SELECT type, payload_json, thread_id, session_id FROM source_events
+       WHERE turn_id = ? OR payload_json LIKE ?
+       ORDER BY source_sequence`)
+        .all(turnId, `%"${turnId}"%`);
+    for (const row of rows) {
+        if (!row.type.includes('requestApproval') && !row.type.includes('requestUserInput') && !row.type.includes('completed') && !row.type.includes('interrupted') && row.type !== 'turn.failed' && row.type !== 'approval.resolved') {
+            continue;
+        }
+        const payload = asRecord(JSON.parse(row.payload_json));
+        const session = sessionByThread(database, threadId) ?? (row.session_id ? readSession(database, row.session_id) : undefined);
+        applyNativeToState(database, {
+            method: row.type,
+            kind: 'notification',
+            threadId: optionalString(row.thread_id) || threadId,
+            turnId,
+            session,
+            operation: operationByTurn(database, turnId),
+        }, payload);
+    }
+}
+function resolveOperation(database, input, payload) {
+    const turnId = input.turnId || nativeIds(payload).turnId;
+    if (turnId)
+        return operationByTurn(database, turnId) ?? input.operation;
+    return input.operation;
+}
+function applyNativeToState(database, input, payload) {
+    const method = input.method ?? '';
+    const session = input.session;
+    if (session?.sessionId) {
+        const next = { ...session };
+        const approval = method.includes('requestApproval') || method.includes('requestUserInput');
+        if (approval)
+            next.turnStatus = moveTurn(String(session.turnStatus ?? 'running'), 'waiting_for_user');
+        else if (method === 'approval.resolved')
+            next.turnStatus = moveTurn(String(session.turnStatus ?? 'waiting_for_user'), 'running');
+        else if (method.includes('delta') || method === 'turn/started' || method === 'turn.started') {
+            const current = String(session.turnStatus ?? 'starting');
+            if (current !== 'waiting_for_user')
+                next.turnStatus = moveTurn(current, 'running');
+        }
+        const terminal = terminalTurn(method, payload);
+        if (terminal) {
+            let status = String(next.turnStatus ?? session.turnStatus ?? 'running');
+            if (status === 'waiting_for_user')
+                status = moveTurn(status, 'running');
+            next.turnStatus = moveTurn(status, terminal);
+            next.turnBlock = undefined;
+        }
+        upsertRecord(database, 'sessions', String(session.sessionId), next);
+    }
+    if (!input.operation)
+        return;
+    let operation = input.operation.operation;
+    const approvalId = optionalString(payload.itemId) || optionalString(payload.approvalId) || input.itemId;
+    if ((method.includes('requestApproval') || method.includes('requestUserInput')) && approvalId && operation.sessionId) {
+        upsertRecord(database, 'approvals', `${operation.sessionId}:${approvalId}`, {
+            approvalId,
+            sessionId: operation.sessionId,
+            runtimeEpoch: operation.runtimeEpoch ?? 0,
+            nativeRequestId: operation.nativeRequestId ?? `approval:${approvalId}`,
+            status: 'pending',
+        });
+        operation = operationRecordSchema.parse({
+            ...operation,
+            nativeApprovalId: approvalId,
+            updatedAt: new Date().toISOString(),
+        });
+        putOperation(database, input.operation.scopeKey, operation);
+    }
+    const terminal = terminalTurn(method, payload);
+    if (terminal && operation.status === 'accepted') {
+        putOperation(database, input.operation.scopeKey, transitionOperation(operation, terminal, {
+            nativeTurnId: input.turnId ?? operation.nativeTurnId,
+            nativeThreadId: input.threadId ?? operation.nativeThreadId,
+        }));
+    }
+}
+function acknowledge(database, body) {
+    const leaseFence = Number(body.leaseFence);
+    const accepted = metaNumber(database, 'accepted_lease_fence');
+    if (!Number.isInteger(leaseFence) || leaseFence !== accepted)
+        throw new Error('lease_fence_mismatch');
+    const epochs = Array.isArray(body.epochs) ? body.epochs : [];
+    for (const value of epochs) {
+        const epoch = asRecord(value);
+        const row = epochRow(database, String(epoch.runtimeId), Number(epoch.generation), Number(epoch.runtimeEpoch));
+        if (!row)
+            throw new Error('unknown_source_epoch');
+        const next = Number(epoch.confirmedThrough);
+        if (!Number.isInteger(next) || next < row.cloud_ack_through)
+            throw new Error('ack_not_monotonic');
+        if (next > row.local_durable_through)
+            throw new Error('ack_ahead_of_local');
+        database
+            .prepare(`UPDATE source_epochs SET cloud_ack_through = ?
+         WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?`)
+            .run(next, epoch.runtimeId, epoch.generation, epoch.runtimeEpoch);
+    }
+}
+function createPin(database, body) {
+    const now = Date.now();
+    database.prepare('DELETE FROM replay_pins WHERE expires_at <= ?').run(new Date(now).toISOString());
+    const count = database.prepare('SELECT count(*) AS n FROM replay_pins').get().n;
+    if (count >= MAX_PINS)
+        throw new Error('pin_quota');
+    const ttl = Math.min(Number(body.ttlMs) || 60_000, MAX_PIN_MS);
+    const identity = asRecord(body.identity);
+    ensureEpoch(database, String(identity.runtimeId), Number(identity.generation), Number(identity.runtimeEpoch));
+    const epochs = database.prepare('SELECT * FROM source_epochs').all().map((row) => ({
+        runtimeId: row.runtime_id,
+        generation: row.generation,
+        runtimeEpoch: row.runtime_epoch,
+        retainedFrom: row.retained_from,
+        highWater: row.local_durable_through,
+    }));
+    const current = epochs.find((epoch) => epoch.runtimeId === identity.runtimeId &&
+        epoch.generation === Number(identity.generation) &&
+        epoch.runtimeEpoch === Number(identity.runtimeEpoch));
+    const pinId = `pin_${randomUUID()}`;
+    const createdAt = new Date(now).toISOString();
+    const expiresAt = new Date(now + ttl).toISOString();
+    database
+        .prepare('INSERT INTO replay_pins (pin_id, epochs_json, created_at, expires_at) VALUES (?, ?, ?, ?)')
+        .run(pinId, JSON.stringify(epochs), createdAt, expiresAt);
+    const highWater = current?.highWater ?? 0;
+    return {
+        pin: {
+            pinId,
+            epochs,
+            followBoundary: {
+                runtimeId: String(identity.runtimeId),
+                generation: Number(identity.generation),
+                runtimeEpoch: Number(identity.runtimeEpoch),
+                sourceSequence: Math.max(highWater, 1),
+            },
+        },
+    };
+}
+function reclaim(database, minRetainMs) {
+    const pins = activePins(database);
+    const epochs = database.prepare('SELECT * FROM source_epochs').all();
+    const now = Date.now();
+    for (const epoch of epochs) {
+        let retained = epoch.retained_from;
+        while (true) {
+            const row = database
+                .prepare(`SELECT source_sequence, occurred_at FROM source_events
+           WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ? AND source_sequence >= ?
+           ORDER BY source_sequence LIMIT 1`)
+                .get(epoch.runtime_id, epoch.generation, epoch.runtime_epoch, retained);
+            if (!row || row.source_sequence !== retained)
+                break;
+            if (row.source_sequence > epoch.cloud_ack_through)
+                break;
+            if (pins.some((pin) => row.source_sequence >= pin.retainedFrom && row.source_sequence <= pin.highWater && pin.runtimeId === epoch.runtime_id && pin.generation === epoch.generation && pin.runtimeEpoch === epoch.runtime_epoch)) {
+                break;
+            }
+            const age = now - Date.parse(row.occurred_at);
+            if (Number.isFinite(age) && age < minRetainMs)
+                break;
+            database
+                .prepare(`DELETE FROM source_events
+           WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ? AND source_sequence = ?`)
+                .run(epoch.runtime_id, epoch.generation, epoch.runtime_epoch, row.source_sequence);
+            retained = row.source_sequence + 1;
+        }
+        if (retained !== epoch.retained_from) {
+            database
+                .prepare(`UPDATE source_epochs SET retained_from = ?
+           WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?`)
+                .run(retained, epoch.runtime_id, epoch.generation, epoch.runtime_epoch);
+        }
+    }
+}
+function dump(database) {
+    const snapshot = {
+        workspaces: bucketObject(database, 'workspaces'),
+        workspaceFileRevisions: workspaceFiles(database),
+        operations: operationsObject(database),
+        receipts: bucketObject(database, 'receipts'),
+        events: eventsObject(database),
+        sessions: bucketObject(database, 'sessions'),
+        terminals: bucketObject(database, 'terminals'),
+        checkpoints: bucketObject(database, 'checkpoints'),
+        fileRevisions: bucketObject(database, 'file_revisions'),
+        approvals: bucketObject(database, 'approvals'),
+        managedWrites: bucketObject(database, 'managed_writes'),
+        fileCheckpointId: metaString(database, 'file_checkpoint_id') || undefined,
+        consistentCheckpointId: metaString(database, 'consistent_checkpoint_id') || undefined,
+        executionGroup: executionGroup(database),
+        runtimeEpoch: metaNumber(database, 'runtime_epoch'),
+        lastSourceSequence: currentCounter(database),
+        acceptedLeaseFence: metaNumber(database, 'accepted_lease_fence'),
+        destroyed: metaString(database, 'destroyed') === '1',
+    };
+    return {
+        snapshot,
+        epochs: database.prepare('SELECT * FROM source_epochs').all(),
+        sourceReadToken: metaString(database, 'source_read_token'),
+        pendingInbox: database.prepare('SELECT count(*) AS n FROM native_inbox WHERE converted = 0').get().n,
+    };
+}
+function eventsObject(database) {
+    const rows = database.prepare('SELECT * FROM source_events ORDER BY runtime_epoch, source_sequence').all();
+    const events = {};
+    for (const row of rows) {
+        const event = pendingSourceEventSchema.parse({
+            source: {
+                runtimeId: row.runtime_id,
+                generation: row.generation,
+                runtimeEpoch: row.runtime_epoch,
+                sourceSequence: row.source_sequence,
+            },
+            payloadHash: row.payload_hash,
+            type: row.type,
+            payload: JSON.parse(String(row.payload_json)),
+            occurredAt: row.occurred_at,
+        });
+        events[`${event.source.runtimeId}:${event.source.generation}:${event.source.runtimeEpoch}:${event.source.sourceSequence}`] = event;
+    }
+    return events;
+}
+function operationsObject(database) {
+    const rows = database.prepare('SELECT scope_key, operation_json FROM operation_intents').all();
+    const operations = {};
+    for (const row of rows) {
+        const parsed = operationRecordSchema.safeParse(JSON.parse(row.operation_json));
+        if (parsed.success)
+            operations[row.scope_key] = parsed.data;
+    }
+    return operations;
+}
+function putOperation(database, scopeKey, value) {
+    const operation = operationRecordSchema.parse(value);
+    database
+        .prepare(`INSERT INTO operation_intents (
+        scope_key, operation_json, gateway_operation_id, sandbox_operation_id, payload_hash,
+        native_request_id, thread_id, turn_id, reconcile_status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(scope_key) DO UPDATE SET
+        operation_json = excluded.operation_json,
+        gateway_operation_id = excluded.gateway_operation_id,
+        sandbox_operation_id = excluded.sandbox_operation_id,
+        payload_hash = excluded.payload_hash,
+        native_request_id = excluded.native_request_id,
+        thread_id = excluded.thread_id,
+        turn_id = excluded.turn_id,
+        reconcile_status = excluded.reconcile_status`)
+        .run(scopeKey, JSON.stringify(operation), null, operation.sandboxOperationId ?? operation.operationId, operation.payloadHash, operation.nativeRequestId ?? null, operation.nativeThreadId ?? null, operation.nativeTurnId ?? null, operation.status);
+}
+function insertEventRow(database, event, links) {
+    database
+        .prepare(`INSERT INTO source_events (
+        runtime_id, generation, runtime_epoch, source_sequence, payload_hash, workspace_id, session_id,
+        operation_id, thread_id, turn_id, item_id, type, payload_json, occurred_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(event.source.runtimeId, event.source.generation, event.source.runtimeEpoch, event.source.sourceSequence, event.payloadHash, links.workspaceId ?? null, links.sessionId ?? null, links.operationId ?? null, links.threadId ?? null, links.turnId ?? null, links.itemId ?? null, event.type, JSON.stringify(event.payload), event.occurredAt);
+}
+function ensureEpoch(database, runtimeId, generation, runtimeEpoch) {
+    database
+        .prepare(`INSERT INTO source_epochs (
+        runtime_id, generation, runtime_epoch, next_sequence, local_durable_through, cloud_ack_through, retained_from
+      ) VALUES (?, ?, ?, 0, 0, 0, 1)
+      ON CONFLICT DO NOTHING`)
+        .run(runtimeId, generation, runtimeEpoch);
+}
+function writeExecutionEpoch(database, body) {
+    const runtimeEpoch = Number(body.runtimeEpoch);
+    setMeta(database, 'runtime_epoch', String(runtimeEpoch));
+    setMeta(database, 'execution_group', JSON.stringify({
+        pid: body.pid,
+        startedAt: body.startedAt,
+        previousPid: body.previousPid,
+        stopConfirmed: body.stopConfirmed === true,
+        replaced: true,
+    }));
+    const approvals = database.prepare(`SELECT record_key, body_json FROM records WHERE bucket = 'approvals'`).all();
+    for (const row of approvals) {
+        const approval = asRecord(JSON.parse(row.body_json));
+        if (approval.status === 'pending') {
+            upsertRecord(database, 'approvals', row.record_key, { ...approval, status: 'expired' });
+        }
+    }
+    const runtimeId = metaString(database, 'runtime_id');
+    const generation = metaNumber(database, 'generation');
+    if (runtimeId)
+        ensureEpoch(database, runtimeId, generation, runtimeEpoch);
+}
+function bindRuntime(database, body) {
+    setMeta(database, 'runtime_id', String(body.runtimeId));
+    setMeta(database, 'generation', String(Number(body.generation) || 0));
+    const current = metaNumber(database, 'runtime_epoch');
+    const next = Math.max(current, Number(body.runtimeEpoch) || 0);
+    setMeta(database, 'runtime_epoch', String(next));
+    ensureEpoch(database, String(body.runtimeId), Number(body.generation) || 0, next);
+}
+function upsertRecord(database, bucket, key, body) {
+    database
+        .prepare(`INSERT INTO records (bucket, record_key, body_json) VALUES (?, ?, ?)
+       ON CONFLICT(bucket, record_key) DO UPDATE SET body_json = excluded.body_json`)
+        .run(bucket, key, JSON.stringify(body));
+}
+function replaceBucket(database, bucket, entries) {
+    database.prepare('DELETE FROM records WHERE bucket = ?').run(bucket);
+    for (const entry of entries) {
+        const record = asRecord(entry);
+        upsertRecord(database, bucket, String(record.key), record.body);
+    }
+}
+function importBucket(database, bucket, records, accept) {
+    for (const [key, value] of Object.entries(records)) {
+        if (accept(value))
+            upsertRecord(database, bucket, key, value);
+    }
+}
+function bucketObject(database, bucket) {
+    const rows = database.prepare('SELECT record_key, body_json FROM records WHERE bucket = ? ORDER BY rowid').all(bucket);
+    return Object.fromEntries(rows.map((row) => [row.record_key, JSON.parse(row.body_json)]));
+}
+function workspaceFiles(database) {
+    const rows = database
+        .prepare(`SELECT bucket, record_key, body_json FROM records WHERE bucket LIKE 'workspace_files:%'`)
+        .all();
+    const files = {};
+    for (const row of rows) {
+        const workspaceId = row.bucket.slice('workspace_files:'.length);
+        (files[workspaceId] ??= {})[row.record_key] = JSON.parse(row.body_json);
+    }
+    return files;
+}
+function readSession(database, sessionId) {
+    const row = database
+        .prepare(`SELECT body_json FROM records WHERE bucket = 'sessions' AND record_key = ?`)
+        .get(sessionId);
+    return row ? asRecord(JSON.parse(row.body_json)) : undefined;
+}
+function sessionByThread(database, threadId) {
+    const rows = database.prepare(`SELECT body_json FROM records WHERE bucket = 'sessions'`).all();
+    const matches = rows.map((row) => asRecord(JSON.parse(row.body_json))).filter((session) => session.threadId === threadId);
+    if (matches.length !== 1)
+        return undefined;
+    return matches[0];
+}
+function operationByTurn(database, turnId) {
+    const row = database
+        .prepare('SELECT scope_key, operation_json FROM operation_intents WHERE turn_id = ?')
+        .get(turnId);
+    if (!row)
+        return undefined;
+    const parsed = operationRecordSchema.safeParse(JSON.parse(row.operation_json));
+    if (!parsed.success)
+        return undefined;
+    return { scopeKey: row.scope_key, operation: parsed.data };
+}
+function canConvert(kind, threadId, turnId, session, operation) {
+    if (kind === 'process_exit')
+        return true;
+    if (turnId && !operation)
+        return false;
+    if (turnId && operation)
+        return true;
+    if (!session || !threadId)
+        return false;
+    return true;
+}
+function linkedPayload(params, session) {
+    const payload = asRecord(params);
+    delete payload.workspaceId;
+    if (typeof session?.workspaceId === 'string')
+        payload.workspaceId = session.workspaceId;
+    if (typeof session?.sessionId === 'string')
+        payload.sessionId = session.sessionId;
+    return payload;
+}
+function nativeIds(params) {
+    const record = asRecord(params);
+    const turn = asRecord(record.turn);
+    const thread = asRecord(record.thread);
+    return {
+        threadId: optionalString(record.threadId) || optionalString(thread.id),
+        turnId: optionalString(record.turnId) || optionalString(turn.id),
+        itemId: optionalString(record.itemId) || optionalString(record.approvalId),
+    };
+}
+function terminalTurn(method, payload) {
+    if (method !== 'turn/completed' && method !== 'turn.completed' && method !== 'turn.interrupted' && method !== 'turn.failed') {
+        return undefined;
+    }
+    if (method === 'turn.interrupted')
+        return 'interrupted';
+    if (method === 'turn.failed')
+        return 'failed';
+    const status = String(asRecord(payload.turn).status ?? payload.status ?? 'completed');
+    if (status === 'interrupted')
+        return 'interrupted';
+    if (status === 'failed')
+        return 'failed';
+    return 'completed';
+}
+function moveTurn(current, to) {
+    if (current === to)
+        return to;
+    if (current === 'starting' || current === 'running' || current === 'waiting_for_user' || current === 'completed' || current === 'failed' || current === 'interrupted') {
+        return canTransitionTurn(current, to) ? to : current;
+    }
+    return to;
+}
+function nextIngress(database) {
+    const next = metaNumber(database, 'ingress_counter') + 1;
+    setMeta(database, 'ingress_counter', String(next));
+    return next;
+}
+function epochRow(database, runtimeId, generation, runtimeEpoch) {
+    return database
+        .prepare('SELECT * FROM source_epochs WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?')
+        .get(runtimeId, generation, runtimeEpoch);
+}
+function activePins(database) {
+    const now = new Date().toISOString();
+    const rows = database.prepare('SELECT epochs_json, expires_at FROM replay_pins').all();
+    const pins = [];
+    for (const row of rows) {
+        if (row.expires_at <= now)
+            continue;
+        const epochs = JSON.parse(row.epochs_json);
+        for (const epoch of epochs)
+            pins.push(epoch);
+    }
+    return pins;
+}
+function currentCounter(database) {
+    const row = epochRow(database, metaString(database, 'runtime_id'), metaNumber(database, 'generation'), metaNumber(database, 'runtime_epoch'));
+    return row?.next_sequence ?? 0;
+}
+function executionGroup(database) {
+    const raw = metaString(database, 'execution_group');
+    if (!raw)
+        return { stopConfirmed: false, replaced: false };
+    try {
+        return asRecord(JSON.parse(raw));
+    }
+    catch {
+        return { stopConfirmed: false, replaced: false };
+    }
+}
+function setMeta(database, key, value) {
+    database
+        .prepare(`INSERT INTO library_meta (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`)
+        .run(key, value);
+}
+function metaString(database, key) {
+    const row = database.prepare('SELECT value FROM library_meta WHERE key = ?').get(key);
+    return row?.value ?? '';
+}
+function metaNumber(database, key) {
+    const parsed = Number(metaString(database, key));
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function requireDb() {
+    if (!db)
+        throw new Error('sqlite_not_open');
+    return db;
+}
+function sqliteAtLeast(version, minimum) {
+    const parts = version.split('.').map((item) => Number(item));
+    for (let index = 0; index < minimum.length; index += 1) {
+        const left = parts[index] ?? 0;
+        const right = minimum[index] ?? 0;
+        if (left > right)
+            return true;
+        if (left < right)
+            return false;
+    }
+    return true;
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : {};
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function firstString(snapshot, key) {
+    return typeof snapshot[key] === 'string' ? String(snapshot[key]) : undefined;
+}
+function eventRuntime(events, key) {
+    for (const value of Object.values(events)) {
+        const source = asRecord(asRecord(value).source);
+        if (typeof source[key] === 'string')
+            return String(source[key]);
+    }
+    return undefined;
+}
+function eventRuntimeNumber(events, key) {
+    for (const value of Object.values(events)) {
+        const source = asRecord(asRecord(value).source);
+        if (Number.isInteger(source[key]))
+            return Number(source[key]);
+    }
+    return 0;
+}
+function isApproval(value) {
+    const record = asRecord(value);
+    return typeof record.approvalId === 'string' && typeof record.sessionId === 'string' && typeof record.nativeRequestId === 'string';
+}