@playcraft/cli 0.0.57 → 0.0.58

package/dist/workspace-runtime/server/dispatch.js

@@ -0,0 +1,861 @@
+import { withObservedFile } from '../workspaces/revisions.js';
+import { revisionScope, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPushPayloadSchema, hashOperationPayload, nextSourceSequence, parameterPatchPayloadSchema, pendingSourceEventSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { captureWorkspaceTree, materializeSnapshot, publishFileSnapshot, } from '../workspaces/file-snapshot.js';
+import { InvalidWorkspacePathError, resolveWorkspaceFile, restoreWorkspaceFiles, snapshotWorkspaceFiles, writeWorkspaceFile, } from '../workspaces/files.js';
+import { GitWorkspaceError, commitWorkspaceGit, pushWorkspaceGit } from '../workspaces/git.js';
+import { ParameterEditError } from '../workspaces/json5-edit.js';
+import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces/parameters.js';
+import { executionGroupRestarted } from './execution-group.js';
+import { probeProcess, spawnBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
+const CONVERSATION_KINDS = new Set([
+    'session.create',
+    'session.turn',
+    'session.interrupt',
+    'session.approval.respond',
+]);
+const LOCAL_KINDS = new Set([
+    'runtime.ensure',
+    'runtime.destroy',
+    'checkpoint.create',
+    'checkpoint.restore',
+    'file.write',
+    'git.commit',
+    'git.push',
+    'terminal.create',
+    'parameter.patch',
+]);
+export function canExecuteKind(state, kind) {
+    if (LOCAL_KINDS.has(kind))
+        return true;
+    if (kind === 'session.turn' && !workspaceTurnAllowed(state))
+        return true;
+    if (state.journal.destroyed() && CONVERSATION_KINDS.has(kind))
+        return false;
+    return Boolean(state.native?.ready()) && CONVERSATION_KINDS.has(kind);
+}
+export async function executeOperation(state, scopeKey, operation, payload) {
+    const run = async () => {
+        if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed()) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: state.journal.destroyed() ? 'runtime_destroyed' : 'stale_lease' }));
+        }
+        return executeScopedOperation(state, scopeKey, operation, payload);
+    };
+    const checkpointId = asRecord(payload).checkpointId;
+    const checkpointRun = () => operation.kind.startsWith('checkpoint.') && typeof checkpointId === 'string'
+        ? state.journal.exclusive(`checkpoint:${checkpointId}`, run) : run();
+    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond'].includes(operation.kind))
+        return run();
+    return state.journal.exclusive(`workspace:${revisionScope(state, operation.workspaceId) ?? 'single'}`, checkpointRun);
+}
+function workspaceTurnAllowed(state) {
+    const gate = state.rebuildGate;
+    if (!gate)
+        return true;
+    return gate.directoryReady && gate.repositoryReady && gate.environmentReady;
+}
+async function executeScopedOperation(state, scopeKey, operation, payload) {
+    let current = await persist(state, scopeKey, transitionOperation(operation, 'dispatched'));
+    if (operation.kind === 'runtime.ensure') {
+        current = await persist(state, scopeKey, transitionOperation(current, 'accepted'));
+        return persist(state, scopeKey, transitionOperation(current, 'completed'));
+    }
+    if (operation.kind === 'runtime.destroy') {
+        return executeDestroy(state, scopeKey, current);
+    }
+    if (state.journal.destroyed()) {
+        return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'runtime_destroyed' }));
+    }
+    if (operation.kind === 'session.turn' && !workspaceTurnAllowed(state)) {
+        return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'workspace_not_ready' }));
+    }
+    if (operation.kind === 'checkpoint.create') {
+        return executeCheckpoint(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'checkpoint.restore') {
+        return executeRestore(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'file.write') {
+        return executeFileWrite(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'git.commit') {
+        return executeGitCommit(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'git.push') {
+        return executeGitPush(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'terminal.create') {
+        return executeTerminalCreate(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'parameter.patch') {
+        return executeParameterPatch(state, scopeKey, current, payload);
+    }
+    if (!state.native?.ready()) {
+        return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
+    }
+    try {
+        if (operation.kind === 'session.create') {
+            return executeCreate(state, scopeKey, current);
+        }
+        if (operation.kind === 'session.turn') {
+            return executeTurn(state, scopeKey, current, payload);
+        }
+        if (operation.kind === 'session.interrupt') {
+            return executeInterrupt(state, scopeKey, current);
+        }
+        if (operation.kind === 'session.approval.respond') {
+            return executeApproval(state, scopeKey, current, payload);
+        }
+        return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
+    }
+    catch {
+        return persist(state, scopeKey, transitionOperation(current, 'uncertain', { error: 'native_receipt_lost' }));
+    }
+}
+async function executeCreate(state, scopeKey, operation) {
+    const sessionId = required(operation.sessionId, 'sessionId');
+    const started = await native(state).startThread({
+        sessionId,
+        cwd: await workspaceRoot(state, operation.workspaceId),
+    });
+    if (!started.threadId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' }));
+    }
+    await state.journal.putSession({
+        sessionId,
+        workspaceId: operation.workspaceId,
+        threadId: started.threadId,
+        cwd: await workspaceRoot(state, operation.workspaceId),
+        recoverability: 'native',
+    });
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', {
+        nativeRequestId: `thread/start:${sessionId}`,
+        nativeThreadId: started.threadId,
+    }));
+    await recordNativeEvents(state, accepted, [
+        { type: 'session.created', payload: { sessionId, threadId: started.threadId }, occurredAt: new Date().toISOString() },
+    ]);
+    return persist(state, scopeKey, transitionOperation(accepted, 'completed', { nativeThreadId: started.threadId }));
+}
+async function executeTurn(state, scopeKey, operation, payload) {
+    const sessionId = required(operation.sessionId, 'sessionId');
+    const binding = state.journal.getSession(sessionId);
+    if (!binding) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
+    }
+    if (binding.recoverability !== 'native') {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'native_not_recoverable' }));
+    }
+    const body = asRecord(payload);
+    let result = await native(state).startTurn({
+        sessionId,
+        threadId: binding.threadId,
+        text: String(body.text ?? ''),
+        clientRequestId: operation.clientRequestId,
+        simulateLostReceipt: body.simulateLostReceipt === true,
+    });
+    if (result.outcome === 'uncertain') {
+        await recordNativeEvents(state, operation, result.events);
+        return persist(state, scopeKey, transitionOperation(operation, 'uncertain', {
+            error: 'native_receipt_lost',
+            nativeThreadId: binding.threadId,
+        }));
+    }
+    if (result.outcome === 'failed' || !result.turnId) {
+        await recordNativeEvents(state, operation, result.events);
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', {
+            error: 'native_failed',
+            nativeThreadId: binding.threadId,
+        }));
+    }
+    if (!result.approvalId &&
+        process.env.PLAYCRAFT_RECORD_PENDING_APPROVAL === '1' &&
+        String(body.text ?? '').includes('[approval]')) {
+        result = { ...result, approvalId: `approval_${result.turnId}` };
+    }
+    if (result.approvalId) {
+        await state.journal.putApproval({
+            approvalId: result.approvalId,
+            sessionId,
+            runtimeEpoch: state.runtimeEpoch,
+            nativeRequestId: `turn/start:${result.turnId}`,
+            status: 'pending',
+        });
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', {
+        nativeRequestId: `turn/start:${result.turnId}`,
+        nativeThreadId: binding.threadId,
+        nativeTurnId: result.turnId,
+        nativeApprovalId: result.approvalId,
+    }));
+    await recordNativeEvents(state, accepted, result.events);
+    const terminal = result.outcome === 'interrupted' ? 'interrupted' : 'completed';
+    return persist(state, scopeKey, transitionOperation(accepted, terminal, {
+        nativeTurnId: result.turnId,
+        nativeApprovalId: result.approvalId,
+    }));
+}
+async function executeInterrupt(state, scopeKey, operation) {
+    const sessionId = required(operation.sessionId, 'sessionId');
+    const binding = state.journal.getSession(sessionId);
+    if (!binding) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
+    }
+    const result = await native(state).interrupt({ sessionId, threadId: binding.threadId });
+    if (result.outcome === 'uncertain') {
+        return persist(state, scopeKey, transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' }));
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { nativeThreadId: binding.threadId }));
+    await recordNativeEvents(state, accepted, result.events);
+    return persist(state, scopeKey, transitionOperation(accepted, 'interrupted', { nativeThreadId: binding.threadId }));
+}
+async function executeApproval(state, scopeKey, operation, payload) {
+    const sessionId = required(operation.sessionId, 'sessionId');
+    const body = asRecord(payload);
+    const approvalId = String(body.approvalId ?? operation.nativeApprovalId ?? '');
+    if (!approvalId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'missing_approval' }));
+    }
+    const stored = state.journal.getApproval(sessionId, approvalId);
+    if (stored && (stored.status === 'expired' || stored.runtimeEpoch !== state.runtimeEpoch)) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'approval_expired' }));
+    }
+    const result = await native(state).respondApproval({
+        sessionId,
+        approvalId,
+        accepted: body.accepted !== false,
+    });
+    if (stored && result.outcome !== 'failed') {
+        await state.journal.putApproval({
+            ...stored,
+            status: body.accepted === false ? 'rejected' : 'approved',
+        });
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { nativeApprovalId: approvalId }));
+    await recordNativeEvents(state, accepted, result.events);
+    const terminal = result.outcome === 'failed' ? 'failed' : 'completed';
+    return persist(state, scopeKey, transitionOperation(accepted, terminal, {
+        nativeApprovalId: approvalId,
+        error: terminal === 'failed' ? 'native_failed' : undefined,
+    }));
+}
+async function executeCheckpoint(state, scopeKey, operation, payload) {
+    const body = asRecord(payload);
+    const checkpointId = typeof body.checkpointId === 'string' && body.checkpointId.trim()
+        ? body.checkpointId.trim()
+        : `ckpt_${randomUUID()}`;
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(checkpointId) || state.journal.getCheckpoint(checkpointId)) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'checkpoint_id_conflict' }));
+    }
+    const workspaceId = operation.workspaceId ?? String(body.workspaceId ?? 'workspace');
+    const active = await activeManagedWrites(state, workspaceId);
+    const createdAt = new Date().toISOString();
+    if (active.length > 0) {
+        const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
+            sessionId: item.sessionId,
+            nativeThreadId: item.threadId,
+            recoverability: 'history_only',
+        }));
+        const checkpoint = checkpointRecordSchema.parse({
+            checkpointId,
+            kind: 'best_effort',
+            workspaceId,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            sessions,
+            createdAt,
+            nativeRecoverable: false,
+            consistent: false,
+        });
+        await state.journal.putCheckpoint(checkpoint);
+        return finishCheckpoint(state, scopeKey, operation, checkpoint, active.map((item) => item.source));
+    }
+    const root = await workspaceRoot(state, operation.workspaceId);
+    const revisions = state.journal.fileRevisions(revisionScope(state, operation.workspaceId));
+    let files;
+    let published;
+    if (state.config.fileObjectStoreUrl) {
+        const tree = await captureWorkspaceTree(root, previousFilePaths(state), revisions);
+        const stillActive = await activeManagedWrites(state, workspaceId);
+        if (stillActive.length > 0) {
+            return finishBestEffort(state, scopeKey, operation, checkpointId, workspaceId, createdAt, stillActive.map((item) => item.source));
+        }
+        try {
+            published = await publishFileSnapshot({
+                baseUrl: state.config.fileObjectStoreUrl,
+                snapshotId: checkpointId,
+                workspaceId,
+                generation: state.config.generation,
+                tree,
+            });
+        }
+        catch {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'snapshot_upload_failed' }));
+        }
+        if (tree.status === 'incomplete') {
+            const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
+                sessionId: item.sessionId,
+                nativeThreadId: item.threadId,
+                recoverability: 'history_only',
+            }));
+            const checkpoint = checkpointRecordSchema.parse({
+                checkpointId,
+                kind: 'file',
+                workspaceId,
+                generation: state.config.generation,
+                runtimeEpoch: state.runtimeEpoch,
+                sessions,
+                createdAt,
+                nativeRecoverable: false,
+                consistent: false,
+                manifestKey: published.manifestKey,
+                checksum: published.checksum,
+                snapshotStatus: 'incomplete',
+            });
+            await state.journal.putCheckpoint(checkpoint);
+            return finishCheckpoint(state, scopeKey, operation, checkpoint, []);
+        }
+        await materializeSnapshot(fileCheckpointDir(state, checkpointId), tree);
+        files = tree.files;
+    }
+    else {
+        files = await snapshotWorkspaceFiles(root, fileCheckpointDir(state, checkpointId), revisions);
+        const stillActive = await activeManagedWrites(state, workspaceId);
+        if (stillActive.length > 0) {
+            return finishBestEffort(state, scopeKey, operation, checkpointId, workspaceId, createdAt, stillActive.map((item) => item.source));
+        }
+    }
+    const captured = await captureNativeSessions(state, operation.workspaceId);
+    const nativeReady = captured.nativeReady;
+    const checkpoint = checkpointRecordSchema.parse({
+        checkpointId,
+        kind: nativeReady ? 'coordinated' : 'file',
+        workspaceId,
+        generation: state.config.generation,
+        runtimeEpoch: state.runtimeEpoch,
+        sessions: captured.sessions,
+        files,
+        createdAt,
+        nativeRecoverable: nativeReady,
+        consistent: nativeReady,
+        ...(published
+            ? { manifestKey: published.manifestKey, checksum: published.checksum, snapshotStatus: published.status }
+            : {}),
+    });
+    await state.journal.putCheckpoint(checkpoint);
+    await state.journal.setFileCheckpointId(checkpointId);
+    if (nativeReady)
+        await state.journal.setConsistentCheckpointId(checkpointId);
+    return finishCheckpoint(state, scopeKey, operation, checkpoint, []);
+}
+async function executeRestore(state, scopeKey, operation, payload) {
+    const body = asRecord(payload);
+    const checkpointId = String(body.checkpointId ?? operation.checkpointId ?? '');
+    const checkpoint = state.journal.getCheckpoint(checkpointId);
+    if (!checkpoint || checkpoint.workspaceId !== (operation.workspaceId ?? 'workspace')) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_checkpoint' }));
+    }
+    if (checkpoint.snapshotStatus === 'incomplete') {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'snapshot_incomplete' }));
+    }
+    const restarted = executionGroupRestarted(state, checkpoint.runtimeEpoch);
+    const stopConfirmed = state.journal.executionGroup().stopConfirmed;
+    const cwd = await workspaceRoot(state, operation.workspaceId);
+    const next = workspaceSessions(state, operation.workspaceId).map((item) => {
+        const snap = checkpoint.sessions.find((session) => session.sessionId === item.sessionId);
+        if (!snap)
+            return { ...item, recoverability: 'history_only' };
+        const threadId = item.threadId;
+        const threadReplaced = Boolean(snap.nativeThreadId && snap.nativeThreadId !== item.threadId);
+        if (!checkpoint.nativeRecoverable || threadReplaced) {
+            return {
+                ...item,
+                threadId,
+                recoverability: restarted ? 'history_only' : item.recoverability,
+            };
+        }
+        if (restarted)
+            return { ...item, threadId, recoverability: 'history_only' };
+        return { ...item, threadId: snap.nativeThreadId ?? item.threadId, recoverability: 'native' };
+    });
+    for (const snap of checkpoint.sessions) {
+        if (!next.some((item) => item.sessionId === snap.sessionId)) {
+            next.push({
+                sessionId: snap.sessionId,
+                workspaceId: operation.workspaceId,
+                threadId: snap.nativeThreadId ?? `thread_${snap.sessionId}`,
+                cwd,
+                recoverability: checkpoint.nativeRecoverable && !restarted ? 'native' : 'history_only',
+            });
+        }
+    }
+    let nativeContinuable = checkpoint.nativeRecoverable
+        ? next.some((item) => item.recoverability === 'native')
+        : false;
+    if (checkpoint.nativeRecoverable && restarted && stopConfirmed) {
+        for (const snap of checkpoint.sessions) {
+            const threadId = snap.nativeThreadId;
+            const found = next.find((item) => item.sessionId === snap.sessionId);
+            if (!threadId || !found || !state.native?.canContinueThread)
+                continue;
+            const continued = await state.native.canContinueThread({
+                threadId,
+                sessionId: snap.sessionId,
+                cwd: found.cwd,
+            });
+            if (!continued || found.threadId !== threadId)
+                continue;
+            found.recoverability = 'native';
+            nativeContinuable = true;
+        }
+    }
+    if (!checkpoint.nativeRecoverable || (restarted && !stopConfirmed))
+        nativeContinuable = false;
+    const others = state.config.workspaceMode === 'multi'
+        ? state.journal.listSessions().filter((item) => item.workspaceId !== operation.workspaceId) : [];
+    if (others.some((item) => next.some((restored) => restored.sessionId === item.sessionId))) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'session_workspace_mismatch' }));
+    }
+    await state.journal.replaceSessions([...others, ...next]);
+    let filesRestored = false;
+    if (checkpoint.files) {
+        const restoredFiles = await restoreWorkspaceFiles(cwd, fileCheckpointDir(state, checkpointId), checkpoint.files);
+        await state.journal.replaceFileRevisions(restoredFiles, revisionScope(state, operation.workspaceId));
+        filesRestored = true;
+    }
+    const historyVisible = state.journal.getCheckpoint(checkpointId) !== undefined &&
+        state.journal.listEvents().some((event) => event.type === 'checkpoint.created' || event.type === 'session.created');
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { checkpointId }));
+    await recordNativeEvents(state, accepted, [
+        {
+            type: 'checkpoint.restored',
+            payload: {
+                checkpointId,
+                historyVisible,
+                filesRestored,
+                nativeContinuable,
+                nativeSessionCount: next.filter((item) => item.recoverability === 'native').length,
+                historyOnlyCount: next.filter((item) => item.recoverability === 'history_only').length,
+            },
+            occurredAt: new Date().toISOString(),
+        },
+    ]);
+    return persist(state, scopeKey, transitionOperation(accepted, 'completed', { checkpointId }));
+}
+async function executeDestroy(state, scopeKey, operation) {
+    await state.journal.markDestroyed();
+    try {
+        await state.native?.close?.();
+    }
+    catch {
+        /* Codex process shutdown is best-effort once the runtime is destroyed */
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    await recordNativeEvents(state, accepted, [
+        {
+            type: 'runtime.destroyed',
+            payload: { runtimeId: state.config.runtimeId },
+            occurredAt: new Date().toISOString(),
+        },
+    ]);
+    return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+}
+async function executeFileWrite(state, scopeKey, operation, payload) {
+    const parsed = fileWritePayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+        const message = parsed.error.issues[0]?.message;
+        const error = message === 'write_id_required' || message === 'write_hold_conflict' || message === 'background_write_unmanaged'
+            ? message
+            : 'invalid_workspace_path';
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error }));
+    }
+    const workspaceId = operation.workspaceId ?? 'workspace';
+    const writer = parsed.data.writer ?? 'manual';
+    if (parsed.data.release) {
+        const lease = state.journal.getManagedWrite(parsed.data.writeId);
+        if (!lease || lease.stoppedAt || lease.workspaceId !== workspaceId) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'write_unknown' }));
+        }
+    }
+    if (parsed.data.hold) {
+        const existing = state.journal.getManagedWrite(parsed.data.writeId);
+        if (existing && !existing.stoppedAt) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'write_still_active' }));
+        }
+    }
+    if (parsed.data.release) {
+        const stopped = await releaseManagedWrite(state, parsed.data.writeId, workspaceId);
+        if (!stopped) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'write_not_stopped' }));
+        }
+    }
+    const expected = parsed.data.expectedRevision ?? operation.expectedRevision;
+    return withObservedFile(state, operation.workspaceId, parsed.data.path, async ({ revision: currentRevision }) => {
+        if (expected !== undefined && expected !== currentRevision) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'revision_conflict' }));
+        }
+        try {
+            const root = await workspaceRoot(state, operation.workspaceId);
+            const written = await writeWorkspaceFile(root, parsed.data.path, parsed.data.content);
+            const revision = currentRevision + 1;
+            await state.journal.putFileRevision(parsed.data.path, {
+                revision,
+                contentHash: written.contentHash,
+            }, revisionScope(state, operation.workspaceId));
+            if (parsed.data.hold && parsed.data.writeId) {
+                let pid;
+                if (writer === 'background') {
+                    pid = spawnBackgroundWriter(await resolveWorkspaceFile(root, parsed.data.path));
+                }
+                await state.journal.putManagedWrite({
+                    writeId: parsed.data.writeId,
+                    workspaceId,
+                    source: writer,
+                    startedAt: new Date().toISOString(),
+                    pid,
+                });
+            }
+            const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { expectedRevision: revision }));
+            await recordNativeEvents(state, accepted, [
+                {
+                    type: 'file.written',
+                    payload: {
+                        path: parsed.data.path,
+                        revision,
+                        contentHash: written.contentHash,
+                        size: written.size,
+                        writer,
+                        writeId: parsed.data.writeId,
+                    },
+                    occurredAt: new Date().toISOString(),
+                },
+            ]);
+            return persist(state, scopeKey, transitionOperation(accepted, 'completed', { expectedRevision: revision }));
+        }
+        catch (error) {
+            const code = error instanceof InvalidWorkspacePathError ? 'invalid_workspace_path' : 'file_write_failed';
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: code }));
+        }
+    }).catch((error) => {
+        const code = error instanceof InvalidWorkspacePathError ? 'invalid_workspace_path' : 'file_write_failed';
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: code }));
+    });
+}
+async function executeGitCommit(state, scopeKey, operation, payload) {
+    const parsed = gitCommitPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_git_commit' }));
+    }
+    try {
+        const sha = await commitWorkspaceGit(await workspaceRoot(state, operation.workspaceId), parsed.data);
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+        await recordNativeEvents(state, accepted, [
+            {
+                type: 'git.committed',
+                payload: { sha, message: parsed.data.message, paths: parsed.data.paths ?? [] },
+                occurredAt: new Date().toISOString(),
+            },
+        ]);
+        return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+    }
+    catch (error) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
+    }
+}
+async function executeGitPush(state, scopeKey, operation, payload) {
+    const parsed = gitPushPayloadSchema.safeParse(payload ?? {});
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'remote_not_configurable' }));
+    }
+    try {
+        await pushWorkspaceGit(await workspaceRoot(state, operation.workspaceId));
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+        await recordNativeEvents(state, accepted, [
+            {
+                type: 'git.pushed',
+                payload: { remote: 'origin' },
+                occurredAt: new Date().toISOString(),
+            },
+        ]);
+        return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+    }
+    catch (error) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
+    }
+}
+async function executeParameterPatch(state, scopeKey, operation, payload) {
+    const parsed = parameterPatchPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_parameter_patch' }));
+    }
+    const root = await workspaceRoot(state, operation.workspaceId);
+    const scope = revisionScope(state, operation.workspaceId);
+    const document = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    if (document.status === 'missing' || document.status === 'schema_only' || !document.dataPath) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_data_missing' }));
+    }
+    if (document.status === 'invalid') {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_document_invalid' }));
+    }
+    const dataPath = document.dataPath;
+    return withObservedFile(state, operation.workspaceId, dataPath, async ({ revision: currentRevision }) => {
+        if (parsed.data.expectedRevision !== currentRevision) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'revision_conflict' }));
+        }
+        try {
+            const written = await patchWorkspaceParameters(root, state.journal.fileRevisions(scope), parsed.data);
+            const revision = currentRevision + 1;
+            await state.journal.putFileRevision(dataPath, { revision, contentHash: written.contentHash }, scope);
+            const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { expectedRevision: revision }));
+            await recordNativeEvents(state, accepted, [
+                {
+                    type: 'file.written',
+                    payload: {
+                        path: dataPath,
+                        revision,
+                        contentHash: written.contentHash,
+                        size: written.size,
+                        fieldPath: parsed.data.fieldPath,
+                    },
+                    occurredAt: new Date().toISOString(),
+                },
+            ]);
+            return persist(state, scopeKey, transitionOperation(accepted, 'completed', { expectedRevision: revision }));
+        }
+        catch (error) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: parameterPatchError(error) }));
+        }
+    }).catch((error) => persist(state, scopeKey, transitionOperation(operation, 'failed', { error: parameterPatchError(error) })));
+}
+async function executeTerminalCreate(state, scopeKey, operation, payload) {
+    const parsed = terminalCreatePayloadSchema.safeParse(payload ?? {});
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_terminal_create' }));
+    }
+    const workspaceId = operation.workspaceId;
+    if (!workspaceId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_terminal_create' }));
+    }
+    const terminalId = parsed.data.terminalId ?? operation.terminalId;
+    if (!terminalId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_terminal_create' }));
+    }
+    const existing = state.journal.getTerminal(terminalId);
+    if (existing && existing.workspaceId !== workspaceId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'terminal_already_bound' }));
+    }
+    if (existing?.status === 'destroyed') {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'terminal_destroyed' }));
+    }
+    const cwd = parsed.data.cwd ?? existing?.cwd ?? '';
+    const createdAt = existing?.createdAt ?? new Date().toISOString();
+    const record = await state.journal.putTerminal({
+        terminalId,
+        workspaceId,
+        environment: state.config.environment,
+        userId: state.config.userId,
+        runtimeId: state.config.runtimeId,
+        generation: state.config.generation,
+        runtimeEpoch: state.runtimeEpoch,
+        processIdentity: terminalProcessIdentity(workspaceId, terminalId, cwd),
+        cwd,
+        status: 'active',
+        createdAt,
+    });
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { terminalId, cwd: record.cwd }));
+    await recordNativeEvents(state, accepted, [
+        {
+            type: 'terminal.created',
+            payload: { terminalId, cwd: record.cwd, processIdentity: record.processIdentity },
+            occurredAt: new Date().toISOString(),
+        },
+    ]);
+    return persist(state, scopeKey, transitionOperation(accepted, 'completed', { terminalId, cwd: record.cwd }));
+}
+function gitErrorCode(error) {
+    return error instanceof GitWorkspaceError ? error.code : 'git_command_failed';
+}
+function parameterPatchError(error) {
+    if (error instanceof ParameterEditError)
+        return error.code;
+    if (error instanceof InvalidWorkspacePathError)
+        return 'invalid_workspace_path';
+    return 'parameter_patch_failed';
+}
+async function finishCheckpoint(state, scopeKey, operation, checkpoint, activeWriters) {
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { checkpointId: checkpoint.checkpointId }));
+    await recordNativeEvents(state, accepted, [
+        {
+            type: 'checkpoint.created',
+            payload: {
+                checkpointId: checkpoint.checkpointId,
+                workspaceId: checkpoint.workspaceId,
+                kind: checkpoint.kind,
+                consistent: checkpoint.consistent === true,
+                fileCheckpointId: state.journal.fileCheckpointId(),
+                consistentCheckpointId: state.journal.consistentCheckpointId(),
+                nativeRecoverable: checkpoint.nativeRecoverable,
+                sessionCount: checkpoint.sessions.length,
+                fileCount: checkpoint.files?.length ?? 0,
+                activeWriters,
+            },
+            occurredAt: checkpoint.createdAt,
+        },
+    ]);
+    return persist(state, scopeKey, transitionOperation(accepted, 'completed', {
+        checkpointId: checkpoint.checkpointId,
+        checkpointKind: checkpoint.kind,
+        checkpointConsistent: checkpoint.consistent === true,
+        ...(checkpoint.manifestKey ? { snapshotManifestKey: checkpoint.manifestKey } : {}),
+        ...(checkpoint.checksum ? { snapshotChecksum: checkpoint.checksum } : {}),
+        ...(checkpoint.snapshotStatus ? { snapshotStatus: checkpoint.snapshotStatus } : {}),
+    }));
+}
+async function captureNativeSessions(state, workspaceId) {
+    const live = workspaceSessions(state, workspaceId);
+    const sessions = [];
+    let nativeReady = live.length > 0;
+    for (const item of live) {
+        const captured = await state.native?.captureNativeCheckpoint?.({
+            threadId: item.threadId,
+            sessionId: item.sessionId,
+        });
+        const durable = captured?.threadId === item.threadId && typeof captured.nativeDurableTurnId === 'string'
+            ? captured.nativeDurableTurnId
+            : undefined;
+        if (!durable)
+            nativeReady = false;
+        sessions.push(durable
+            ? {
+                sessionId: item.sessionId,
+                nativeThreadId: item.threadId,
+                nativeDurableTurnId: durable,
+                recoverability: 'native',
+            }
+            : {
+                sessionId: item.sessionId,
+                nativeThreadId: item.threadId,
+                recoverability: 'history_only',
+            });
+    }
+    return { sessions, nativeReady };
+}
+async function activeManagedWrites(state, workspaceId) {
+    const active = [];
+    for (const lease of state.journal.listManagedWrites(workspaceId)) {
+        if (lease.stoppedAt)
+            continue;
+        if (lease.pid !== undefined && probeProcess(lease.pid) === false) {
+            await state.journal.putManagedWrite({ ...lease, stoppedAt: new Date().toISOString() });
+            continue;
+        }
+        active.push(lease);
+    }
+    return active;
+}
+async function releaseManagedWrite(state, writeId, workspaceId) {
+    const lease = state.journal.getManagedWrite(writeId);
+    if (!lease || lease.stoppedAt || lease.workspaceId !== workspaceId)
+        return false;
+    if (lease.pid !== undefined) {
+        const stopped = await stopBackgroundWriter(lease.pid);
+        if (!stopped)
+            return false;
+    }
+    await state.journal.putManagedWrite({ ...lease, stoppedAt: new Date().toISOString() });
+    return true;
+}
+async function finishBestEffort(state, scopeKey, operation, checkpointId, workspaceId, createdAt, activeWriters) {
+    const sessions = workspaceSessions(state, operation.workspaceId).map((item) => ({
+        sessionId: item.sessionId,
+        nativeThreadId: item.threadId,
+        recoverability: 'history_only',
+    }));
+    const checkpoint = checkpointRecordSchema.parse({
+        checkpointId,
+        kind: 'best_effort',
+        workspaceId,
+        generation: state.config.generation,
+        runtimeEpoch: state.runtimeEpoch,
+        sessions,
+        createdAt,
+        nativeRecoverable: false,
+        consistent: false,
+    });
+    await state.journal.putCheckpoint(checkpoint);
+    return finishCheckpoint(state, scopeKey, operation, checkpoint, activeWriters);
+}
+function previousFilePaths(state) {
+    const checkpointId = state.journal.fileCheckpointId();
+    if (!checkpointId)
+        return [];
+    return state.journal.getCheckpoint(checkpointId)?.files?.map((file) => file.path) ?? [];
+}
+function fileCheckpointDir(state, checkpointId) {
+    return join(state.config.stateDir, 'file-checkpoints', checkpointId);
+}
+export async function recordNativeEvents(state, operation, events) {
+    const recorded = [];
+    for (const event of events) {
+        const sourceSequence = nextSourceSequence(state.journal.lastSourceSequence());
+        const payload = {
+            ...(asRecord(event.payload)),
+            ...(operation.sessionId ? { sessionId: operation.sessionId } : {}),
+            ...(operation.workspaceId ? { workspaceId: operation.workspaceId } : {}),
+        };
+        const pending = pendingSourceEventSchema.parse({
+            source: {
+                runtimeId: state.config.runtimeId,
+                generation: state.config.generation,
+                runtimeEpoch: state.runtimeEpoch,
+                sourceSequence,
+            },
+            payloadHash: hashOperationPayload(payload),
+            type: event.type,
+            payload,
+            occurredAt: event.occurredAt,
+        });
+        recorded.push(await state.journal.appendEvent(pending));
+    }
+    if (recorded.length > 0) {
+        await notifyCallback(state, recorded).catch(() => undefined);
+    }
+    void operation;
+    return recorded;
+}
+async function notifyCallback(state, events) {
+    await fetch(state.config.callbackUrl, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${state.config.controlToken}`,
+            'x-playcraft-control-token': state.config.controlToken,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            runtimeId: state.config.runtimeId,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            events,
+        }),
+    });
+}
+async function persist(state, scopeKey, operation) {
+    return state.journal.putOperation(scopeKey, operation);
+}
+function native(state) {
+    if (!state.native)
+        throw new Error('native_adapter_missing');
+    return state.native;
+}
+function required(value, name) {
+    if (!value)
+        throw new Error(`missing_${name}`);
+    return value;
+}
+function asRecord(payload) {
+    return payload && typeof payload === 'object' && !Array.isArray(payload)
+        ? payload
+        : {};
+}