@playcraft/cli 0.1.54 → 0.1.56-beta

package/dist/workspace-runtime/codex/ui-tools.js

@@ -0,0 +1,203 @@
+import { randomUUID } from 'node:crypto';
+import { workspaceUiCommandSchema, workspaceUiResultSchema, WORKSPACE_UI_COMMAND_EVENT, WORKSPACE_UI_RESULT_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool } from './tool-response.js';
+export const WORKSPACE_UI_TOOLS = [
+    { type: 'function', name: 'playcraft_get_ui_context',
+        description: 'Read the PlayCraft browser view captured when the user sent this turn. This is a turn-start snapshot, not a live browser observation or visual verification. Only the visible panel target is returned by default; request open tabs only when needed.',
+        inputSchema: { type: 'object', properties: { includeOpenTabs: { type: 'boolean' } }, additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_file',
+        description: 'Open a file in the current PlayCraft workspace browser view. Use a workspace-relative path and an optional line range. The result confirms selection, not visual verification.',
+        inputSchema: { type: 'object', properties: { path: { type: 'string' }, range: { type: 'object',
+                    properties: { startLine: { type: 'integer', minimum: 1 }, endLine: { type: 'integer', minimum: 1 } },
+                    required: ['startLine', 'endLine'], additionalProperties: false } }, required: ['path'], additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_preview',
+        description: 'Open an existing preview in the current PlayCraft workspace browser view. Omit identifiers for the latest available preview. Opening does not start a build or verify the rendered appearance.',
+        inputSchema: { type: 'object', properties: { artifactId: { type: 'string' }, versionId: { type: 'string' },
+                previewId: { type: 'string' } }, additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_delivery',
+        description: 'Open the delivery panel in the current PlayCraft workspace browser view. Opening does not start or verify a build.',
+        inputSchema: { type: 'object', properties: { channel: { type: 'string' }, buildId: { type: 'string' } },
+            additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_task',
+        description: 'Open the task panel in the current PlayCraft workspace browser view. Opening does not change task state.',
+        inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, additionalProperties: false } },
+];
+/** Read the saved view locally; browser commands have a separate receipt lifecycle. */
+export class WorkspaceUiTools {
+    emit;
+    timeoutMs;
+    pending = new Map();
+    settled = new Map();
+    constructor(emit, timeoutMs = 20_000) {
+        this.emit = emit;
+        this.timeoutMs = timeoutMs;
+    }
+    request(requestId, params, client, snapshot) {
+        const threadId = typeof params.threadId === 'string' ? params.threadId : '';
+        const turnId = typeof params.turnId === 'string' ? params.turnId : '';
+        if (!snapshot || !threadId || !turnId) {
+            void this.reject(client, requestId, 'ui_view_unavailable');
+            return;
+        }
+        const args = params.arguments;
+        if (params.namespace || !args || typeof args !== 'object' || Array.isArray(args)) {
+            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
+            return;
+        }
+        if (params.tool === 'playcraft_get_ui_context') {
+            const input = args;
+            if (Object.keys(input).some(key => key !== 'includeOpenTabs')
+                || (input.includeOpenTabs !== undefined && typeof input.includeOpenTabs !== 'boolean')) {
+                void this.reject(client, requestId, 'invalid_ui_tool_arguments');
+                return;
+            }
+            void client.respond(requestId, { success: true, contentItems: [{ type: 'inputText',
+                        text: JSON.stringify(viewContext(snapshot, input.includeOpenTabs === true)) }] }).catch(() => undefined);
+            return;
+        }
+        const kind = params.tool === 'playcraft_open_file' ? 'open_file'
+            : params.tool === 'playcraft_open_preview' ? 'open_preview'
+                : params.tool === 'playcraft_open_delivery' ? 'open_delivery'
+                    : params.tool === 'playcraft_open_task' ? 'open_task' : undefined;
+        const allowed = kind === 'open_file' ? ['path', 'range']
+            : kind === 'open_preview' ? ['artifactId', 'versionId', 'previewId']
+                : kind === 'open_delivery' ? ['channel', 'buildId'] : ['taskId'];
+        if (!kind || Object.keys(args).some(key => !allowed.includes(key))) {
+            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
+            return;
+        }
+        if (this.pending.size >= 32) {
+            void this.reject(client, requestId, 'ui_commands_busy');
+            return;
+        }
+        const commandId = randomUUID();
+        const envelope = { commandId, viewId: snapshot.viewId, workspaceId: snapshot.workspaceId,
+            directoryName: snapshot.directoryName, sessionId: snapshot.sessionId,
+            expiresAt: new Date(Date.now() + this.timeoutMs).toISOString() };
+        const parsed = workspaceUiCommandSchema.safeParse({ ...args, ...envelope, kind });
+        if (!parsed.success) {
+            void this.reject(client, requestId, 'invalid_ui_tool_arguments');
+            return;
+        }
+        const command = parsed.data;
+        const timer = setTimeout(() => {
+            void this.finish(commandId, { commandId, viewId: command.viewId, status: 'failed', reason: 'ui_command_timeout' });
+        }, this.timeoutMs);
+        timer.unref?.();
+        this.pending.set(commandId, { requestId, threadId, turnId, command, client, timer });
+        this.emit({ kind: 'notification', method: WORKSPACE_UI_COMMAND_EVENT, occurredAt: new Date().toISOString(),
+            params: { ...command, threadId, turnId } });
+    }
+    async respond(sessionId, value) {
+        const parsed = workspaceUiResultSchema.safeParse(value);
+        if (!parsed.success)
+            return { outcome: 'failed', error: 'invalid_ui_result' };
+        const result = parsed.data;
+        const fingerprint = JSON.stringify(result);
+        const done = this.settled.get(result.commandId);
+        if (done)
+            return done.sessionId === sessionId && done.viewId === result.viewId && done.fingerprint === fingerprint
+                ? done.result : { outcome: 'failed', error: 'ui_command_expired' };
+        const pending = this.pending.get(result.commandId);
+        if (!pending || pending.command.sessionId !== sessionId || pending.command.viewId !== result.viewId)
+            return { outcome: 'failed', error: 'ui_command_unavailable' };
+        if (Date.now() >= Date.parse(pending.command.expiresAt)) {
+            await this.finish(result.commandId, { commandId: result.commandId, viewId: result.viewId, status: 'failed', reason: 'ui_command_timeout' });
+            return { outcome: 'failed', error: 'ui_command_expired' };
+        }
+        const snapshot = result.snapshot;
+        const command = pending.command;
+        if (snapshot && (snapshot.viewId !== command.viewId || snapshot.sessionId !== command.sessionId
+            || snapshot.workspaceId !== command.workspaceId || snapshot.directoryName !== command.directoryName))
+            return { outcome: 'failed', error: 'ui_result_scope_mismatch' };
+        const targetTab = command.kind === 'open_file' ? 'files'
+            : command.kind === 'open_preview' ? 'preview' : command.kind;
+        if (result.status === 'opened' && (!snapshot?.panelOpen
+            || (command.kind === 'open_file' && (!isAssetTab(snapshot.activeTab) || snapshot.activeFile?.path !== command.path
+                || (command.range && (snapshot.activeFile.range?.startLine !== command.range.startLine
+                    || snapshot.activeFile.range?.endLine !== command.range.endLine))))
+            || (command.kind === 'open_preview' && (snapshot.activeTab !== 'preview' || !snapshot.activePreview
+                || (command.artifactId && snapshot.activePreview.artifactId !== command.artifactId)
+                || (command.versionId && snapshot.activePreview.versionId !== command.versionId)
+                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))
+            || (command.kind !== 'open_file' && command.kind !== 'open_preview' && snapshot.activeTab !== targetTab)
+            || (command.kind === 'open_delivery' && ((command.channel !== undefined && snapshot.activeDelivery?.channel !== command.channel)
+                || (command.buildId !== undefined && snapshot.activeDelivery?.buildId !== command.buildId)))
+            || (command.kind === 'open_task' && command.taskId !== undefined && snapshot.activeTask?.taskId !== command.taskId)))
+            return { outcome: 'failed', error: 'ui_result_target_mismatch' };
+        return this.finish(result.commandId, result, fingerprint);
+    }
+    async cancel(threadId, reason = 'ui_command_cancelled') {
+        await Promise.all([...this.pending].filter(([, pending]) => !threadId || pending.threadId === threadId)
+            .map(([commandId, pending]) => this.finish(commandId, { commandId, viewId: pending.command.viewId, status: 'failed', reason })));
+    }
+    async reject(client, requestId, reason) {
+        await rejectTool(client, requestId, reason);
+    }
+    async finish(commandId, result, fingerprint) {
+        const pending = this.pending.get(commandId);
+        if (!pending)
+            return { outcome: 'failed', error: 'ui_command_expired' };
+        this.pending.delete(commandId);
+        clearTimeout(pending.timer);
+        const saved = { sessionId: pending.command.sessionId, viewId: pending.command.viewId,
+            fingerprint, result: { outcome: 'uncertain', turnId: pending.turnId } };
+        this.settled.set(commandId, saved);
+        if (this.settled.size > 256)
+            this.settled.delete(this.settled.keys().next().value);
+        try {
+            await pending.client.respond(pending.requestId, { success: result.status === 'opened',
+                contentItems: [{ type: 'inputText', text: JSON.stringify(openedContext(pending.command, result)) }] });
+            saved.result = { outcome: 'accepted', turnId: pending.turnId };
+        }
+        catch { /* A closed transport cannot confirm delivery. */ }
+        this.emit({ kind: 'notification', method: WORKSPACE_UI_RESULT_EVENT, occurredAt: new Date().toISOString(),
+            params: { ...result, sessionId: pending.command.sessionId, threadId: pending.threadId, turnId: pending.turnId } });
+        return saved.result;
+    }
+}
+function isAssetTab(tab) {
+    return tab === 'files' || Boolean(tab?.startsWith('files:'));
+}
+function viewContext(snapshot, includeOpenTabs) {
+    const file = snapshot.panelOpen && isAssetTab(snapshot.activeTab) ? snapshot.activeFile : undefined;
+    const preview = snapshot.panelOpen && snapshot.activeTab === 'preview' ? snapshot.activePreview : undefined;
+    return {
+        source: 'turn_start',
+        panelOpen: snapshot.panelOpen,
+        activeTab: snapshot.activeTab,
+        ...(file ? { activeFile: { path: file.path, ...(file.range ? { range: file.range } : {}),
+                dirty: file.dirty, loadState: file.loadState } } : {}),
+        ...(preview ? { activePreview: previewContext(preview) } : {}),
+        ...(includeOpenTabs ? { openTabs: snapshot.openTabs.slice(0, 32) } : {}),
+    };
+}
+function previewContext(preview) {
+    return {
+        ...(preview.artifactId ? { artifactId: preview.artifactId } : {}),
+        ...(preview.versionId ? { versionId: preview.versionId } : {}),
+        ...(preview.previewId ? { previewId: preview.previewId } : {}),
+        ...(preview.name ? { name: preview.name } : {}),
+        ...(preview.path ? { path: preview.path } : {}),
+        ...(preview.kind ? { kind: preview.kind } : {}),
+        ...(preview.versionCreatedAt ? { versionCreatedAt: preview.versionCreatedAt } : {}),
+        ...(preview.isCurrentVersion !== undefined ? { isCurrentVersion: preview.isCurrentVersion } : {}),
+        loadState: preview.loadState,
+        ...(preview.viewport ? { viewport: preview.viewport } : {}),
+    };
+}
+function openedContext(command, result) {
+    const file = result.status === 'opened' && command.kind === 'open_file' ? result.snapshot?.activeFile : undefined;
+    const preview = result.status === 'opened' && command.kind === 'open_preview' ? result.snapshot?.activePreview : undefined;
+    return {
+        status: result.status,
+        ...(result.reason ? { reason: result.reason } : {}),
+        ...(file ? { file: { path: file.path, ...(file.range ? { range: file.range } : {}), loadState: file.loadState } } : {}),
+        ...(preview ? { preview: {
+                ...(preview.artifactId ? { artifactId: preview.artifactId } : {}),
+                ...(preview.versionId ? { versionId: preview.versionId } : {}),
+                ...(preview.previewId ? { previewId: preview.previewId } : {}),
+                loadState: preview.loadState,
+            } } : {}),
+    };
+}

package/dist/workspace-runtime/codex/work-mode.js

@@ -0,0 +1,15 @@
+export function workModeExecution(execution, workMode) {
+    return workMode === 'plan' ? {
+        ...execution, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false },
+    } : execution;
+}
+export function nativeCollaborationMode(model, effort, workMode) {
+    return {
+        mode: workMode === 'plan' ? 'plan' : 'default',
+        settings: {
+            model,
+            reasoning_effort: effort === 'max' ? 'xhigh' : effort ?? null,
+            developer_instructions: null,
+        },
+    };
+}

package/dist/workspace-runtime/main.js

@@ -0,0 +1,10 @@
+import { runWorkspaceRuntimeServe } from '../commands/workspace-runtime.js';
+const flag = process.argv.indexOf('--config');
+const configPath = flag >= 0 ? process.argv[flag + 1] : undefined;
+if (!configPath) {
+    console.error('workspace-runtime: missing --config');
+    process.exitCode = 2;
+}
+else {
+    await runWorkspaceRuntimeServe(configPath);
+}

package/dist/workspace-runtime/persistence/journal.js

@@ -0,0 +1,365 @@
+import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { workspaceRegistrationSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { SqliteWorkerClient } from './sqlite-client.js';
+export const RUNTIME_STATE_FILE = 'runtime-state.sqlite';
+export const LEGACY_JOURNAL_FILE = 'journal.json';
+export const LEGACY_JOURNAL_SENTINEL = 'PLAYCRAFT_RUNTIME_STATE_SQLITE\n';
+export class RuntimeJournal {
+    filePath;
+    legacyPath;
+    client;
+    listeners = new Set();
+    maintenance;
+    engineInfo;
+    epochs = [];
+    readToken = '';
+    inboxPending = 0;
+    locks = new Map();
+    snapshot = emptySnapshot();
+    constructor(stateDir) {
+        this.filePath = join(stateDir, RUNTIME_STATE_FILE);
+        this.legacyPath = join(stateDir, LEGACY_JOURNAL_FILE);
+    }
+    async exclusive(key, action) {
+        const previous = this.locks.get(key) ?? Promise.resolve();
+        let release;
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        this.locks.set(key, current);
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+            if (this.locks.get(key) === current)
+                this.locks.delete(key);
+        }
+    }
+    async load() {
+        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        const legacy = await readLegacy(this.legacyPath, this.filePath);
+        const started = await SqliteWorkerClient.open(this.filePath, legacy?.value ?? null);
+        this.client = started.client;
+        this.apply(started.opened);
+        if (legacy?.readable)
+            await writeFile(this.legacyPath, LEGACY_JOURNAL_SENTINEL, { mode: 0o600 });
+        this.maintenance = setInterval(() => {
+            void this.client?.request('maintain').catch(() => undefined);
+        }, 30_000);
+        this.maintenance.unref?.();
+    }
+    async close() {
+        if (this.maintenance)
+            clearInterval(this.maintenance);
+        await this.client?.close();
+        this.client = undefined;
+    }
+    engine() {
+        if (!this.engineInfo)
+            throw new Error('sqlite_engine_unavailable');
+        return this.engineInfo;
+    }
+    sourceReadToken() {
+        return this.readToken;
+    }
+    pendingInbox() {
+        return this.inboxPending;
+    }
+    epochsSnapshot() {
+        return this.epochs.map((epoch) => ({ ...epoch }));
+    }
+    onSourceEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    getWorkspace(workspaceId) {
+        return this.snapshot.workspaces[workspaceId];
+    }
+    async putWorkspace(binding) {
+        const parsed = workspaceRegistrationSchema.parse(binding);
+        await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });
+    }
+    async forgetWorkspaces() {
+        await this.run('forgetWorkspaces', {});
+    }
+    findSessionCreation(sessionId) {
+        return Object.values(this.snapshot.operations).find((item) => item.kind === 'session.create' && item.sessionId === sessionId);
+    }
+    findTerminalCreation(terminalId) {
+        return Object.values(this.snapshot.operations).find((item) => item.kind === 'terminal.create' && item.terminalId === terminalId);
+    }
+    getOperation(scopeKey) {
+        return this.snapshot.operations[scopeKey];
+    }
+    getOperationById(operationId) {
+        return Object.values(this.snapshot.operations).find((operation) => operation.operationId === operationId);
+    }
+    listOperations() {
+        return Object.entries(this.snapshot.operations).map(([scopeKey, operation]) => ({ scopeKey, operation }));
+    }
+    getReceipt(key) {
+        return this.snapshot.receipts[key];
+    }
+    getSession(sessionId) {
+        return this.snapshot.sessions[sessionId];
+    }
+    listSessions() {
+        return Object.values(this.snapshot.sessions);
+    }
+    getTerminal(terminalId) {
+        return this.snapshot.terminals[terminalId];
+    }
+    listTerminals(workspaceId) {
+        return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
+    }
+    listManagedWrites(workspaceId) {
+        return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
+    }
+    getManagedWrite(writeId) {
+        return this.snapshot.managedWrites[writeId];
+    }
+    async putManagedWrite(record) {
+        await this.run('upsertRecord', { bucket: 'managed_writes', key: record.writeId, body: record });
+    }
+    getWorkspaceDependencies(workspaceId) {
+        return this.snapshot.workspaceDependencies[workspaceId];
+    }
+    listWorkspaceDependencies() {
+        return Object.values(this.snapshot.workspaceDependencies);
+    }
+    async putWorkspaceDependencies(record) {
+        await this.run('upsertRecord', {
+            bucket: 'workspace_dependencies',
+            key: record.workspaceId,
+            body: record,
+        });
+    }
+    fileRevisions(workspaceId) {
+        return { ...(workspaceId ? this.snapshot.workspaceFileRevisions[workspaceId] ?? {} : this.snapshot.fileRevisions) };
+    }
+    fileRevision(path, workspaceId) {
+        return this.fileRevisions(workspaceId)[path]?.revision ?? 0;
+    }
+    destroyed() {
+        return this.snapshot.destroyed;
+    }
+    lastSourceSequence() {
+        return this.snapshot.lastSourceSequence;
+    }
+    acceptedLeaseFence() {
+        return this.snapshot.acceptedLeaseFence;
+    }
+    storedRuntimeEpoch() {
+        return this.snapshot.runtimeEpoch;
+    }
+    executionGroup() {
+        return { ...this.snapshot.executionGroup };
+    }
+    stoppedRuntimeEpochs() {
+        return [...(this.snapshot.stoppedRuntimeEpochs ?? [])];
+    }
+    getApproval(sessionId, approvalId) {
+        return this.snapshot.approvals[`${sessionId}:${approvalId}`];
+    }
+    listApprovals() {
+        return Object.values(this.snapshot.approvals);
+    }
+    async putApproval(approval) {
+        await this.run('upsertRecord', { bucket: 'approvals', key: `${approval.sessionId}:${approval.approvalId}`, body: approval });
+    }
+    async noteExecutionGroup(group) {
+        await this.run('noteExecutionGroup', { group });
+    }
+    async writeExecutionEpoch(input) {
+        await this.run('writeExecutionEpoch', input);
+    }
+    async setExecutionStopConfirmed(stopConfirmed) {
+        await this.run('setStopConfirmed', { stopConfirmed });
+    }
+    async bindRuntime(input) {
+        await this.run('bindRuntime', input);
+    }
+    listEvents(afterSequence = 0) {
+        return Object.values(this.snapshot.events)
+            .filter((event) => event.source.sourceSequence > afterSequence)
+            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence || left.source.runtimeEpoch - right.source.runtimeEpoch);
+    }
+    readSourcePage(input) {
+        const epoch = this.epochs.find((item) => item.runtime_id === input.runtimeId && item.generation === input.generation && item.runtime_epoch === input.runtimeEpoch);
+        const retainedFrom = epoch?.retained_from ?? 1;
+        const highWater = epoch?.local_durable_through ?? 0;
+        const coveredThrough = input.after;
+        if (retainedRangeHasGap(retainedFrom, coveredThrough)) {
+            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
+        }
+        const matched = Object.values(this.snapshot.events)
+            .filter((event) => event.source.runtimeId === input.runtimeId &&
+            event.source.generation === input.generation &&
+            event.source.runtimeEpoch === input.runtimeEpoch &&
+            event.source.sourceSequence > input.after)
+            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence);
+        const first = matched[0];
+        if (first && first.source.sourceSequence > input.after + 1) {
+            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
+        }
+        const events = matched.slice(0, input.limit ?? 100);
+        const nextAfter = events.at(-1)?.source.sourceSequence ?? input.after;
+        return { ok: true, events, retainedFrom, highWater, nextAfter, ...identity(input) };
+    }
+    async allocateSourceEvent(input) {
+        const result = await this.run('allocateEvent', input);
+        const event = result.committedEvents?.[0];
+        if (!event)
+            throw new Error('source_event_missing');
+        return event;
+    }
+    async commitSourceIdentity(event) {
+        await this.run('commitIdentity', { event: pendingSourceEventSchema.parse(event) });
+    }
+    async ingestNative(input) {
+        const result = await this.run('ingest', input);
+        return result.committedEvents ?? [];
+    }
+    async bindTurn(input) {
+        const result = await this.run('bindTurn', input);
+        return result.committedEvents ?? [];
+    }
+    async acknowledgeSource(ack) {
+        await this.run('ack', sourceAckSchema.parse(ack));
+    }
+    async createReplayPin(input) {
+        const result = await this.run('createPin', { identity: input, ttlMs: input.ttlMs });
+        return replayPinResultSchema.parse(result.pin);
+    }
+    async deleteReplayPin(pinId) {
+        await this.run('deletePin', { pinId });
+    }
+    async reclaimSourceEvents(minRetainMs = 0) {
+        await this.run('reclaim', { minRetainMs });
+    }
+    async putOperation(scopeKey, operation) {
+        const parsed = operationRecordSchema.parse(operation);
+        await this.run('putOperation', { scopeKey, operation: parsed });
+        return this.snapshot.operations[scopeKey] ?? parsed;
+    }
+    async putSession(binding) {
+        await this.run('upsertRecord', { bucket: 'sessions', key: binding.sessionId, body: binding });
+    }
+    async putTerminal(record) {
+        const parsed = terminalRecordSchema.parse(record);
+        await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
+        return parsed;
+    }
+    async putFileRevision(path, record, workspaceId) {
+        if (workspaceId) {
+            await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
+            return;
+        }
+        await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
+    }
+    async markDestroyed() {
+        await this.run('setDestroyed', {});
+    }
+    async replaceSessions(sessions) {
+        await this.run('replaceBucket', {
+            bucket: 'sessions',
+            entries: sessions.map((session) => ({ key: session.sessionId, body: session })),
+        });
+    }
+    async setAcceptedLeaseFence(value) {
+        await this.run('setAcceptedFence', { value });
+    }
+    async putReceipt(receipt, sourceSequence) {
+        const parsed = sourceEventReceiptSchema.parse(receipt);
+        await this.run('upsertRecord', { bucket: 'receipts', key: sourceEventKey(parsed.source), body: parsed });
+        void sourceSequence;
+    }
+    async appendEvent(event) {
+        const parsed = pendingSourceEventSchema.parse(event);
+        await this.commitSourceIdentity(parsed);
+        return this.snapshot.events[sourceEventKey(parsed.source)] ?? parsed;
+    }
+    async run(type, payload) {
+        if (!this.client)
+            throw new Error('sqlite_not_open');
+        const result = await this.client.request(type, payload);
+        this.apply(result);
+        for (const event of result.committedEvents ?? []) {
+            for (const listener of this.listeners)
+                listener(event);
+        }
+        return result;
+    }
+    apply(dump) {
+        const group = dump.snapshot.executionGroup;
+        const events = dump.snapshot.events ?? this.snapshot.events;
+        // Keep history in place: copying it on every streamed delta grows quadratically.
+        for (const event of dump.committedEvents ?? [])
+            events[sourceEventKey(event.source)] = event;
+        for (const event of dump.eventChanges ?? [])
+            events[sourceEventKey(event.source)] = event;
+        this.snapshot = {
+            ...emptySnapshot(),
+            ...dump.snapshot,
+            events,
+            executionGroup: {
+                stopConfirmed: group?.stopConfirmed === true,
+                replaced: group?.replaced === true,
+                pid: group?.pid,
+                startedAt: group?.startedAt,
+                previousPid: group?.previousPid,
+            },
+        };
+        this.epochs = dump.epochs ?? [];
+        this.readToken = dump.sourceReadToken ?? this.readToken;
+        this.inboxPending = dump.pendingInbox ?? 0;
+        if (dump.engine)
+            this.engineInfo = dump.engine;
+    }
+}
+async function readLegacy(legacyPath, sqlitePath) {
+    if (!existsSync(legacyPath))
+        return null;
+    const text = await readFile(legacyPath, 'utf8');
+    if (text.startsWith(LEGACY_JOURNAL_SENTINEL.trim())) {
+        if (!existsSync(sqlitePath))
+            throw new Error('runtime_state_missing');
+        return null;
+    }
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error('legacy_journal_unreadable');
+    }
+    if (!existsSync(`${legacyPath}.bak`))
+        await copyFile(legacyPath, `${legacyPath}.bak`);
+    return { value, readable: true };
+}
+function identity(input) {
+    return { runtimeId: input.runtimeId, generation: input.generation, runtimeEpoch: input.runtimeEpoch };
+}
+function emptySnapshot() {
+    return {
+        workspaces: {},
+        workspaceFileRevisions: {},
+        operations: {},
+        receipts: {},
+        events: {},
+        sessions: {},
+        terminals: {},
+        fileRevisions: {},
+        approvals: {},
+        managedWrites: {},
+        workspaceDependencies: {},
+        executionGroup: { stopConfirmed: false, replaced: false },
+        lastSourceSequence: 0,
+        acceptedLeaseFence: 0,
+        destroyed: false,
+    };
+}