@playcraft/cli 0.1.53-beta → 0.1.54

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

@@ -1,1161 +0,0 @@
-/**
- * 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 { createHash, 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 { clearPendingNativeFollowups, learnNativeSubagents, nativeEventOwner, nativeSubagentThreads } from './native-subagents.js';
-import { settleStoppedExecution, stoppedExecutionEpochs } from './stopped-execution.js';
-import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, 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 'noteExecutionGroup':
-                setMeta(database, 'execution_group', JSON.stringify({ ...(executionGroup(database)), ...asRecord(body.group) }));
-                return;
-            case 'setStopConfirmed':
-                return confirmExecutionStop(database, body.stopConfirmed === true);
-            case 'writeExecutionEpoch':
-                return writeExecutionEpoch(database, body);
-            case 'bindRuntime':
-                bindRuntime(database, body);
-                return;
-            case 'allocateEvent':
-                return allocateEvent(database, body);
-            case 'commitIdentity':
-                return { eventChanges: commitIdentity(database, body.event).committedEvents };
-            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, type === 'reclaim'), ...(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);
-    }
-    database.exec(`
-    CREATE INDEX IF NOT EXISTS native_inbox_pending_thread
-      ON native_inbox(thread_id, ingress_sequence) WHERE converted = 0;
-    CREATE INDEX IF NOT EXISTS records_native_session_thread
-      ON records(json_extract(body_json, '$.threadId')) WHERE bucket = 'sessions';
-    CREATE INDEX IF NOT EXISTS native_inbox_pending_parent
-      ON native_inbox(COALESCE(json_extract(payload_json, '$.thread.parentThreadId'),
-        json_extract(payload_json, '$.thread.source.subAgent.thread_spawn.parent_thread_id')))
-      WHERE converted = 0 AND method = 'thread/started';
-  `);
-    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, '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);
-    }
-    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 (!['session.turn', 'session.review', 'session.compact', 'session.steer'].includes(operation.kind) || operation.status !== 'dispatched')
-            continue;
-        if (!operation.nativeRequestId || (operation.kind !== 'session.steer' && operation.nativeTurnId))
-            continue;
-        const uncertain = transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' });
-        putOperation(database, row.scope_key, uncertain);
-        if (operation.sessionId && operation.kind !== 'session.steer') {
-            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 hintedTurn = turnId || nativeIds(body.params).turnId;
-    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));
-    return { committedEvents: releaseInbox(database, { ingress }, { runtimeId: String(body.runtimeId), generation: Number(body.generation) || 0 }) };
-}
-function bindTurn(database, body) {
-    const operation = operationRecordSchema.parse(body.operation);
-    putOperation(database, String(body.scopeKey), operation);
-    if (operation.generation === metaNumber(database, 'generation') && operation.runtimeEpoch !== undefined &&
-        stoppedExecutionEpochs(database, metaString(database, 'runtime_id'), operation.generation).includes(operation.runtimeEpoch)) {
-        const released = releaseInbox(database, { rootThreadId: String(body.threadId), turnId: String(body.turnId) });
-        applyRecordedTurn(database, String(body.threadId), String(body.turnId));
-        return { committedEvents: [...released, ...settleStoppedExecution(database, {
-                    runtimeId: metaString(database, 'runtime_id'), generation: operation.generation, runtimeEpoch: operation.runtimeEpoch,
-                }, Number(executionGroup(database).previousPid ?? executionGroup(database).pid), new Date().toISOString(), stopWriter(database))] };
-    }
-    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),
-            recoveryContextPending: undefined,
-        });
-    }
-    const threadId = String(body.threadId);
-    const turnId = String(body.turnId);
-    const released = releaseInbox(database, { rootThreadId: threadId, turnId });
-    applyRecordedTurn(database, threadId, turnId);
-    return { committedEvents: released };
-}
-function releaseInbox(database, selection, identity) {
-    const events = [];
-    const stoppedProcesses = [];
-    const rows = [];
-    const queued = new Set();
-    const enqueue = (pending) => {
-        for (const row of pending) {
-            const ingress = Number(row.ingress_sequence);
-            if (!queued.has(ingress)) {
-                queued.add(ingress);
-                rows.push(row);
-            }
-        }
-    };
-    const enqueueChildren = (parentId) => enqueue(database.prepare(`
-    SELECT * FROM native_inbox WHERE converted = 0 AND method = 'thread/started'
-      AND COALESCE(json_extract(payload_json, '$.thread.parentThreadId'),
-        json_extract(payload_json, '$.thread.source.subAgent.thread_spawn.parent_thread_id')) = ?
-      ORDER BY ingress_sequence
-  `).all(parentId));
-    const enqueueThread = (threadId) => {
-        enqueue(database.prepare('SELECT * FROM native_inbox WHERE converted = 0 AND thread_id = ? ORDER BY ingress_sequence').all(threadId));
-        enqueueChildren(threadId);
-    };
-    if ('ingress' in selection) {
-        const current = database.prepare('SELECT * FROM native_inbox WHERE converted = 0 AND ingress_sequence = ?').get(selection.ingress);
-        if (current) {
-            const threadId = optionalString(current.thread_id), turnId = optionalString(current.turn_id);
-            if (nativeEventOwner(database, threadId, turnId)) {
-                // A receipt can bind between notifications. Drain that thread's earlier events first.
-                enqueue(database.prepare('SELECT * FROM native_inbox WHERE converted = 0 AND thread_id = ? AND (turn_id = ? OR turn_id IS NULL) AND ingress_sequence <= ? ORDER BY ingress_sequence')
-                    .all(threadId, turnId ?? null, selection.ingress));
-            }
-            else
-                enqueue([current]);
-        }
-    }
-    else {
-        enqueue(database.prepare('SELECT * FROM native_inbox WHERE converted = 0 AND thread_id = ? AND (turn_id = ? OR turn_id IS NULL) ORDER BY ingress_sequence')
-            .all(selection.rootThreadId, selection.turnId));
-        enqueueChildren(selection.rootThreadId);
-        for (const threadId of nativeSubagentThreads(database, selection.rootThreadId))
-            enqueueThread(threadId);
-    }
-    for (const stored of rows) {
-        const threadId = optionalString(stored.thread_id);
-        const turnId = optionalString(stored.turn_id);
-        const method = optionalString(stored.method);
-        const params = JSON.parse(String(stored.payload_json || '{}'));
-        const stopped = stored.kind === 'process_exit' && Number(asRecord(params).pid) === executionGroup(database).pid &&
-            Number(stored.runtime_epoch) === metaNumber(database, 'runtime_epoch') &&
-            (!identity || (identity.runtimeId === metaString(database, 'runtime_id') && identity.generation === metaNumber(database, 'generation')));
-        if (stopped)
-            for (const child of clearPendingNativeFollowups(database))
-                enqueueThread(child);
-        for (const child of learnNativeSubagents(database, method ?? '', params, threadId, turnId))
-            enqueueThread(child);
-        const owner = nativeEventOwner(database, threadId, turnId);
-        if (stored.kind !== 'process_exit' && !owner) {
-            queued.delete(Number(stored.ingress_sequence));
-            continue;
-        }
-        const event = convertInboxRow(database, Number(stored.ingress_sequence), {
-            runtimeId: identity?.runtimeId ?? (metaString(database, 'runtime_id') || 'runtime'),
-            generation: identity?.generation ?? metaNumber(database, 'generation'),
-            runtimeEpoch: Number(stored.runtime_epoch),
-            kind: String(stored.kind), method, threadId, turnId,
-            itemId: optionalString(stored.item_id), occurredAt: String(stored.received_at),
-            session: owner?.session, operation: owner?.operation, subAgent: owner?.subAgent, params,
-        });
-        if (event)
-            events.push(event);
-        if (stopped)
-            stoppedProcesses.push({ runtimeEpoch: Number(stored.runtime_epoch), pid: Number(asRecord(params).pid), occurredAt: String(stored.received_at) });
-        if (!owner?.subAgent && threadId && terminalTurn(method ?? '', asRecord(params)))
-            for (const child of nativeSubagentThreads(database, threadId))
-                enqueueThread(child);
-    }
-    // Release captured child events first so their real final messages precede synthetic interruption.
-    for (const stopped of stoppedProcesses)
-        events.push(...settleStoppedExecution(database, {
-            runtimeId: metaString(database, 'runtime_id'), generation: metaNumber(database, 'generation'), runtimeEpoch: stopped.runtimeEpoch,
-        }, stopped.pid, stopped.occurredAt, stopWriter(database)));
-    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, input.subAgent);
-    const nativeApprovalId = optionalString(payload.approvalId) || optionalString(payload.itemId) || input.itemId;
-    const approvalRequest = input.method?.includes('requestApproval') || input.method === 'item/tool/requestUserInput';
-    const stoppedEpoch = stoppedExecutionEpochs(database, input.runtimeId, input.generation).includes(input.runtimeEpoch);
-    const ownerOperation = input.operation?.operation;
-    const currentSource = input.runtimeId === metaString(database, 'runtime_id') && input.generation === metaNumber(database, 'generation') && input.runtimeEpoch === metaNumber(database, 'runtime_epoch');
-    const ownerMatchesSource = ownerOperation && (ownerOperation.generation === undefined || ownerOperation.generation === input.generation) &&
-        (ownerOperation.runtimeEpoch === undefined || ownerOperation.runtimeEpoch === input.runtimeEpoch) &&
-        (currentSource || (ownerOperation.generation !== undefined && ownerOperation.runtimeEpoch !== undefined));
-    const childApproval = input.subAgent && nativeApprovalId && approvalRequest && !stoppedEpoch && ownerMatchesSource;
-    if (input.subAgent && nativeApprovalId && (approvalRequest || input.method === 'approval.resolved' || input.method === 'serverRequest/resolved')) {
-        payload.approvalId = `subagent_${createHash('sha256').update(JSON.stringify([input.subAgent.threadId, nativeApprovalId])).digest('hex')}`;
-    }
-    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);
-    if (childApproval && input.operation?.operation.sessionId) {
-        upsertRecord(database, 'approvals', `${input.operation.operation.sessionId}:${String(payload.approvalId)}`, {
-            approvalId: payload.approvalId,
-            sessionId: input.operation.operation.sessionId,
-            runtimeId: input.runtimeId,
-            generation: input.generation,
-            runtimeEpoch: input.runtimeEpoch,
-            nativeRequestId: optionalString(payload.requestId) ?? `approval:${nativeApprovalId}`,
-            nativeApprovalId,
-            nativeThreadId: input.subAgent.threadId,
-            nativeTurnId: input.turnId,
-            rootThreadId: input.subAgent.rootThreadId,
-            rootTurnId: input.operation.operation.nativeTurnId,
-            method: input.method,
-            request: payload,
-            status: 'pending',
-        });
-    }
-    settleNativeApprovals(database, input, payload);
-    if (!input.subAgent)
-        applyNativeToState(database, { ...input, operation: resolveOperation(database, input, payload) }, payload);
-    return event;
-}
-/** An ended native request must never reappear as a pending approval after reconnect. */
-function settleNativeApprovals(database, input, payload) {
-    const resolved = input.method === 'approval.resolved' || input.method === 'serverRequest/resolved';
-    const terminal = Boolean(terminalTurn(input.method ?? '', payload));
-    if (!resolved && !terminal)
-        return;
-    const rows = database.prepare("SELECT record_key, body_json FROM records WHERE bucket = 'approvals'").all();
-    for (const row of rows) {
-        const approval = asRecord(JSON.parse(row.body_json));
-        if (approval.status !== 'pending')
-            continue;
-        if (!input.runtimeId || input.generation === undefined || input.runtimeEpoch === undefined ||
-            approval.runtimeId !== input.runtimeId || approval.generation !== input.generation || approval.runtimeEpoch !== input.runtimeEpoch)
-            continue;
-        const matchesThread = approval.nativeThreadId === input.threadId;
-        const matchesRequest = (payload.approvalId && approval.approvalId === payload.approvalId)
-            || (payload.requestId !== undefined && String(approval.nativeRequestId) === String(payload.requestId));
-        const endedParent = terminal && approval.rootThreadId === input.threadId && approval.rootTurnId === input.turnId;
-        if (!endedParent && (!matchesThread || (resolved ? !matchesRequest
-            : input.turnId && approval.nativeTurnId && approval.nativeTurnId !== input.turnId)))
-            continue;
-        upsertRecord(database, 'approvals', row.record_key, { ...approval,
-            status: input.method === 'approval.resolved' ? payload.accepted === false ? 'rejected' : 'approved' : 'expired' });
-    }
-}
-function applyRecordedTurn(database, threadId, turnId) {
-    const rows = database
-        .prepare(`SELECT type, payload_json, thread_id, session_id, runtime_id, generation, runtime_epoch FROM source_events
-       WHERE (thread_id = ? OR thread_id IS NULL) AND (turn_id = ? OR payload_json LIKE ?)
-       ORDER BY source_sequence`)
-        .all(threadId, 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' && row.type !== 'serverRequest/resolved') {
-            continue;
-        }
-        const payload = asRecord(JSON.parse(row.payload_json));
-        if (payload.subAgent)
-            continue;
-        const session = sessionByThread(database, threadId) ?? (row.session_id ? readSession(database, row.session_id) : undefined);
-        applyNativeToState(database, {
-            method: row.type,
-            kind: 'notification',
-            runtimeId: row.runtime_id,
-            generation: row.generation,
-            runtimeEpoch: row.runtime_epoch,
-            threadId: optionalString(row.thread_id) || threadId,
-            turnId,
-            session,
-            operation: operationByTurn(database, turnId, threadId),
-        }, payload);
-    }
-}
-function resolveOperation(database, input, payload) {
-    const turnId = input.turnId || nativeIds(payload).turnId;
-    if (turnId)
-        return input.operation ?? operationByTurn(database, turnId, input.threadId ?? nativeIds(payload).threadId);
-    return input.operation;
-}
-function applyNativeToState(database, input, payload) {
-    const method = input.method ?? '';
-    settleNativeApprovals(database, input, payload);
-    const currentSource = input.runtimeId === metaString(database, 'runtime_id') && input.generation === metaNumber(database, 'generation') &&
-        input.runtimeEpoch === metaNumber(database, 'runtime_epoch');
-    const operation = input.operation?.operation;
-    const operationMatchesSource = !operation || ((operation.generation === undefined || operation.generation === input.generation) &&
-        (operation.runtimeEpoch === undefined || operation.runtimeEpoch === input.runtimeEpoch) &&
-        (currentSource || (operation.generation !== undefined && operation.runtimeEpoch !== undefined)));
-    if (!operationMatchesSource)
-        return;
-    const session = input.session;
-    // A late old-turn notification is history, not the state of a newer turn on this thread.
-    if (currentSource && session?.sessionId && (!input.turnId || !session.activeTurnId || input.turnId === session.activeTurnId)) {
-        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' || method === 'serverRequest/resolved') {
-            const waiting = database.prepare("SELECT 1 FROM records WHERE bucket = 'approvals' AND json_extract(body_json, '$.sessionId') = ? AND json_extract(body_json, '$.status') = 'pending' AND json_extract(body_json, '$.nativeThreadId') = ? LIMIT 1")
-                .get(session.sessionId, session.threadId);
-            if (!waiting)
-                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 ownedOperation = input.operation.operation;
-    const approvalId = optionalString(payload.approvalId) || optionalString(payload.itemId) || input.itemId;
-    if ((method.includes('requestApproval') || method.includes('requestUserInput')) && approvalId && ownedOperation.sessionId && currentSource &&
-        !['completed', 'failed', 'interrupted'].includes(ownedOperation.status)) {
-        upsertRecord(database, 'approvals', `${ownedOperation.sessionId}:${approvalId}`, {
-            approvalId,
-            sessionId: ownedOperation.sessionId,
-            runtimeId: input.runtimeId,
-            generation: input.generation,
-            runtimeEpoch: input.runtimeEpoch,
-            nativeRequestId: optionalString(payload.requestId) ?? `approval:${approvalId}`,
-            nativeThreadId: input.threadId,
-            nativeTurnId: input.turnId,
-            nativeApprovalId: approvalId,
-            method,
-            request: payload,
-            status: 'pending',
-        });
-        ownedOperation = operationRecordSchema.parse({
-            ...ownedOperation,
-            nativeApprovalId: approvalId,
-            updatedAt: new Date().toISOString(),
-        });
-        putOperation(database, input.operation.scopeKey, ownedOperation);
-    }
-    const terminal = terminalTurn(method, payload);
-    if (terminal && ownedOperation.status === 'accepted') {
-        putOperation(database, input.operation.scopeKey, transitionOperation(ownedOperation, terminal, {
-            nativeTurnId: input.turnId ?? ownedOperation.nativeTurnId,
-            nativeThreadId: input.threadId ?? ownedOperation.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);
-        if (epoch.runtimeId !== metaString(database, 'runtime_id') || Number(epoch.generation) !== metaNumber(database, 'generation'))
-            throw new Error('source_identity_mismatch');
-        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);
-    }
-    // An archive acknowledgement is a control-authenticated write; adopting its fence creates no task.
-    setMeta(database, 'accepted_lease_fence', String(leaseFence));
-}
-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, includeEvents = true) {
-    const snapshot = {
-        workspaces: bucketObject(database, 'workspaces'),
-        workspaceFileRevisions: workspaceFiles(database),
-        operations: operationsObject(database),
-        receipts: bucketObject(database, 'receipts'),
-        // Startup and reclamation replace history; ordinary writes return only their new events.
-        ...(includeEvents ? { events: eventsObject(database) } : {}),
-        sessions: bucketObject(database, 'sessions'),
-        terminals: bucketObject(database, 'terminals'),
-        fileRevisions: bucketObject(database, 'file_revisions'),
-        approvals: bucketObject(database, 'approvals'),
-        managedWrites: bucketObject(database, 'managed_writes'),
-        workspaceDependencies: bucketObject(database, 'workspace_dependencies'),
-        executionGroup: executionGroup(database),
-        stoppedRuntimeEpochs: stoppedExecutionEpochs(database, metaString(database, 'runtime_id'), metaNumber(database, 'generation')),
-        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);
-    if (metaString(database, 'runtime_id') && operation.generation === metaNumber(database, 'generation') && operation.runtimeEpoch === metaNumber(database, 'runtime_epoch')) {
-        const key = JSON.stringify([scopeKey, operation.operationId]);
-        database.prepare("INSERT INTO records (bucket, record_key, body_json) VALUES ('operation_execution_scopes', ?, ?) ON CONFLICT DO NOTHING")
-            .run(key, JSON.stringify({ runtimeId: metaString(database, 'runtime_id'), generation: operation.generation, runtimeEpoch: operation.runtimeEpoch }));
-    }
-    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);
-    const previousRuntimeEpoch = Number(body.previousRuntimeEpoch);
-    const committedEvents = body.stopConfirmed === true && Number.isInteger(previousRuntimeEpoch) && previousRuntimeEpoch < runtimeEpoch && Number(body.previousPid) > 0
-        ? settleStoppedExecution(database, { runtimeId: metaString(database, 'runtime_id'), generation: metaNumber(database, 'generation'), runtimeEpoch: previousRuntimeEpoch }, Number(body.previousPid), new Date().toISOString(), stopWriter(database)) : [];
-    setMeta(database, 'runtime_epoch', String(runtimeEpoch));
-    setMeta(database, 'execution_group', JSON.stringify({
-        pid: body.pid,
-        startedAt: body.startedAt,
-        previousPid: body.previousPid,
-        previousRuntimeEpoch: body.previousRuntimeEpoch,
-        stopConfirmed: body.stopConfirmed === true,
-        replaced: true,
-    }));
-    const runtimeId = metaString(database, 'runtime_id');
-    const generation = metaNumber(database, 'generation');
-    if (runtimeId)
-        ensureEpoch(database, runtimeId, generation, runtimeEpoch);
-    return { committedEvents };
-}
-function confirmExecutionStop(database, stopConfirmed) {
-    const group = executionGroup(database);
-    const epoch = Number(group.previousRuntimeEpoch);
-    const confirmed = stopConfirmed && group.replaced === true && Number.isInteger(epoch) && epoch < metaNumber(database, 'runtime_epoch') && Number(group.previousPid) > 0;
-    setMeta(database, 'execution_group', JSON.stringify({ ...group, stopConfirmed: confirmed }));
-    return { committedEvents: confirmed
-            ? settleStoppedExecution(database, { runtimeId: metaString(database, 'runtime_id'), generation: metaNumber(database, 'generation'), runtimeEpoch: epoch }, Number(group.previousPid), new Date().toISOString(), stopWriter(database)) : [] };
-}
-function stopWriter(database) {
-    return { allocate: (input) => allocateEvent(database, input), putOperation: (key, operation) => putOperation(database, key, operation) };
-}
-function bindRuntime(database, body) {
-    if (metaString(database, 'runtime_id') !== String(body.runtimeId) || metaNumber(database, 'generation') !== Number(body.generation))
-        setMeta(database, 'execution_group', JSON.stringify({ stopConfirmed: false, replaced: false }));
-    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, threadId) {
-    const row = database
-        .prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE turn_id = ?${threadId ? ' AND thread_id = ?' : ''} AND json_extract(operation_json, '$.kind') IN ('session.turn', 'session.review', 'session.compact')`)
-        .get(...(threadId ? [turnId, threadId] : [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 linkedPayload(params, session, subAgent) {
-    const payload = { ...asRecord(params) };
-    delete payload.workspaceId;
-    delete payload.sessionId;
-    delete payload.subAgent;
-    if (typeof session?.workspaceId === 'string')
-        payload.workspaceId = session.workspaceId;
-    if (typeof session?.sessionId === 'string')
-        payload.sessionId = session.sessionId;
-    if (subAgent)
-        payload.subAgent = subAgent;
-    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) || optionalString(asRecord(record.item).id),
-    };
-}
-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';
-}