@playcraft/cli 0.1.17 → 0.1.19

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

@@ -1,9 +1,8 @@
 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 { z } from 'zod';
-import { PLATFORM_ROUTES, platformEndpoint, checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { PLATFORM_ROUTES, platformEndpoint, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials } from '../workspaces/cli-credentials.js';
 import { resolveWorkspaceAttachments } from '../workspaces/attachments.js';
 import { readWorkspaceSkillSnapshot, readWorkspaceSkills } from '../workspaces/skills.js';
@@ -12,15 +11,12 @@ import { enableLocalProjectSkill, syncLocalProjectSkills } from '../../project-s
 import { NativePreparationError } from '../codex/native-adapter.js';
 import { disposeTerminalHost } from './terminal-host.js';
 import { disposeDesktopHost } from './desktop-host.js';
-import { captureWorkspaceTree, liveTreeDigest, materializeSnapshot, publishFileSnapshot, } from '../workspaces/file-snapshot.js';
-import { objectStoreHeaders, oneSaveAtATime, rememberFileCheckpoint, unchangedCheckpoint, workspaceSaves, } from '../workspaces/checkpoint-saves.js';
-import { InvalidWorkspacePathError, resolveWorkspaceFile, restoreWorkspaceFiles, snapshotWorkspaceFiles, writeWorkspaceFile, } from '../workspaces/files.js';
-import { GitWorkspaceError, bundleUnpushedCommits, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
+import { InvalidWorkspacePathError, resolveWorkspaceFile, writeWorkspaceFile, } from '../workspaces/files.js';
+import { GitWorkspaceError, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, saveWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
 import { ParameterEditError } from '../workspaces/json5-edit.js';
 import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces/parameters.js';
 import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPreviewPublish, } from '../previews/publish.js';
-import { executionGroupRestarted } from './execution-group.js';
-import { probeProcess, spawnBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
+import { spawnBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -30,14 +26,13 @@ const CONVERSATION_KINDS = new Set([
 const LOCAL_KINDS = new Set([
     'runtime.ensure',
     'runtime.destroy',
-    'checkpoint.create',
-    'checkpoint.restore',
     'file.write',
     'git.commit',
     'git.push',
     'git.stage',
     'git.unstage',
     'git.discard',
+    'workspace.save',
     'terminal.create',
     'parameter.patch',
     'preview.publish',
@@ -46,34 +41,23 @@ const LOCAL_KINDS = new Set([
 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) {
+export async function executeOperation(state, scopeKey, operation, payload, recovery) {
     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);
+        return executeScopedOperation(state, scopeKey, operation, payload, recovery);
     };
-    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', 'preview.publish'].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;
+    return state.journal.exclusive(`workspace:${revisionScope(state, operation.workspaceId) ?? 'single'}`, run);
 }
-async function executeScopedOperation(state, scopeKey, operation, payload) {
+async function executeScopedOperation(state, scopeKey, operation, payload, recovery) {
     let current = await persist(state, scopeKey, transitionOperation(operation, 'dispatched'));
     if (operation.kind === 'runtime.ensure') {
         current = await persist(state, scopeKey, transitionOperation(current, 'accepted'));
@@ -85,16 +69,6 @@ async function executeScopedOperation(state, scopeKey, operation, payload) {
     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') {
-        const workspaceId = current.workspaceId ?? String(asRecord(payload).workspaceId ?? 'workspace');
-        return oneSaveAtATime(state, workspaceId, () => 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);
     }
@@ -110,6 +84,9 @@ async function executeScopedOperation(state, scopeKey, operation, payload) {
     if (operation.kind === 'git.stage' || operation.kind === 'git.unstage' || operation.kind === 'git.discard') {
         return executeGitIndex(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'workspace.save') {
+        return executeWorkspaceSave(state, scopeKey, current, payload);
+    }
     if (operation.kind === 'terminal.create') {
         return executeTerminalCreate(state, scopeKey, current, payload);
     }
@@ -127,7 +104,7 @@ async function executeScopedOperation(state, scopeKey, operation, payload) {
             return executeCreate(state, scopeKey, current, payload);
         }
         if (operation.kind === 'session.turn') {
-            return executeTurn(state, scopeKey, current, payload);
+            return executeTurn(state, scopeKey, current, payload, recovery);
         }
         if (operation.kind === 'session.interrupt') {
             return executeInterrupt(state, scopeKey, current);
@@ -212,9 +189,23 @@ async function executeCreate(state, scopeKey, operation, payload) {
     ]);
     return persist(state, scopeKey, transitionOperation(accepted, 'completed', { nativeThreadId: started.threadId }));
 }
-async function executeTurn(state, scopeKey, operation, payload) {
+async function executeTurn(state, scopeKey, operation, payload, recovery) {
     const sessionId = required(operation.sessionId, 'sessionId');
-    const binding = state.journal.getSession(sessionId);
+    const body = asRecord(payload);
+    const selected = z.string().uuid().optional().safeParse(body.modelConfigId);
+    if (!selected.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'model_config_denied' }));
+    let found = state.journal.getSession(sessionId);
+    if (recovery && found?.recoverability !== 'native') {
+        const rebound = await rebindSession(state, operation, found, selected.data ?? recovery.modelConfigId);
+        if (typeof rebound === 'string') {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: rebound }));
+        }
+        found = rebound;
+    }
+    const binding = found;
+    // Also covers a new thread whose first turn failed before starting: the next turn still carries it.
+    const context = recovery && binding?.recoveryContextPending ? recovery.context : '';
     if (!binding) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
@@ -224,10 +215,6 @@ async function executeTurn(state, scopeKey, operation, payload) {
     if (sessionTurnBusy(binding)) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
     }
-    const body = asRecord(payload);
-    const selected = z.string().uuid().optional().safeParse(body.modelConfigId);
-    if (!selected.success)
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'model_config_denied' }));
     let attachments;
     try {
         attachments = await resolveWorkspaceAttachments(await workspaceRoot(state, operation.workspaceId), body.attachmentIds);
@@ -240,7 +227,7 @@ async function executeTurn(state, scopeKey, operation, payload) {
     const result = await native(state).startTurn({
         sessionId,
         threadId: binding.threadId,
-        text: String(body.text ?? '') + attachmentText,
+        text: context + String(body.text ?? '') + attachmentText,
         images: attachments.filter((file) => file.mimeType.startsWith('image/')).map((file) => file.path),
         clientRequestId: operation.clientRequestId,
         modelConfigId: selected.data ?? binding.modelConfigId,
@@ -310,6 +297,60 @@ async function executeTurn(state, scopeKey, operation, payload) {
     }
     return state.journal.getOperation(scopeKey) ?? latest;
 }
+/**
+ * Gives a session whose native thread was lost a thread in this process. It keeps its own thread
+ * when Codex still has that record, but only once the previous execution group is confirmed
+ * stopped, so two processes never drive one thread. Otherwise it gets a new thread, marked to
+ * carry the earlier conversation until a turn starts on it.
+ * Returns an error code when the thread cannot be prepared.
+ */
+async function rebindSession(state, operation, binding, modelConfigId) {
+    const sessionId = required(operation.sessionId, 'sessionId');
+    const adapter = native(state);
+    const cwd = await workspaceRoot(state, operation.workspaceId);
+    const group = state.journal.executionGroup();
+    try {
+        if (binding && adapter.resumeThread && (!group.replaced || group.stopConfirmed)) {
+            const resumed = await adapter.resumeThread({
+                sessionId,
+                threadId: binding.threadId,
+                cwd,
+                modelConfigId: modelConfigId ?? binding.modelConfigId,
+            });
+            if (resumed) {
+                const next = {
+                    ...binding,
+                    cwd,
+                    recoverability: 'native',
+                    modelConfigId: resumed.modelConfigId ?? binding.modelConfigId,
+                    turnStatus: undefined,
+                    turnBlock: undefined,
+                    activeTurnId: undefined,
+                    recoveryContextPending: undefined,
+                };
+                await state.journal.putSession(next);
+                return next;
+            }
+        }
+        const started = await adapter.startThread({ sessionId, cwd, modelConfigId: modelConfigId ?? binding?.modelConfigId });
+        const next = {
+            sessionId,
+            workspaceId: operation.workspaceId,
+            threadId: started.threadId,
+            cwd,
+            recoverability: 'native',
+            modelConfigId: started.modelConfigId,
+            recoveryContextPending: true,
+        };
+        await state.journal.putSession(next);
+        return next;
+    }
+    catch (error) {
+        if (error instanceof NativePreparationError)
+            return error.message;
+        throw error;
+    }
+}
 async function executeInterrupt(state, scopeKey, operation) {
     const sessionId = required(operation.sessionId, 'sessionId');
     const binding = state.journal.getSession(sessionId);
@@ -351,257 +392,6 @@ async function executeApproval(state, scopeKey, operation, payload) {
         error: terminal === 'failed' ? 'native_failed' : undefined,
     }));
 }
-async function executeCheckpoint(state, scopeKey, operation, payload) {
-    const body = asRecord(payload);
-    // Only a save without a requested identity may answer with an earlier, unchanged checkpoint.
-    const requested = typeof body.checkpointId === 'string' && body.checkpointId.trim() !== '';
-    const checkpointId = requested ? String(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,
-            modelConfigId: item.modelConfigId,
-            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;
-    // A standalone workspace has no remote, so all of its `.git` is kept. A project workspace's packs
-    // come back with a new clone; what the remote lacks goes into the unpushed bundle.
-    const standalone = state.journal.getWorkspace(workspaceId)?.targetKind === 'standalone';
-    if (!standalone) {
-        // Without a fresh bundle the loose objects still hold commits made since the last repack.
-        await bundleUnpushedCommits(root).catch(() => undefined);
-    }
-    const tree = await captureWorkspaceTree(root, previousFilePaths(state), revisions, undefined, {
-        git: standalone ? 'full' : 'local',
-    });
-    // Transcripts only matter where another instance can read them back.
-    const transcripts = state.config.checkpointObjects ? await captureTranscripts(state, operation.workspaceId) : [];
-    const digest = liveTreeDigest(tree, transcripts);
-    if (!requested && tree.status === 'complete') {
-        const stillActive = await activeManagedWrites(state, workspaceId);
-        if (stillActive.length === 0) {
-            const captured = await captureNativeSessions(state, operation.workspaceId);
-            const previous = unchangedCheckpoint(state, workspaceId, digest, captured.sessions);
-            if (previous)
-                return finishUnchanged(state, scopeKey, operation, previous);
-        }
-    }
-    if (state.config.checkpointObjects) {
-        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: platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.checkpointStore),
-                snapshotId: checkpointId,
-                workspaceId,
-                generation: state.config.generation,
-                tree,
-                native: transcripts,
-                uploaded: workspaceSaves(state, workspaceId).uploaded,
-                uploadedTranscripts: workspaceSaves(state, workspaceId).transcripts,
-                headers: objectStoreHeaders(state),
-            });
-        }
-        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,
-                modelConfigId: item.modelConfigId,
-                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);
-    if (tree.status === 'complete') {
-        await rememberFileCheckpoint(state, workspaceId, { checkpointId, digest, sessions: captured.sessions });
-    }
-    return finishCheckpoint(state, scopeKey, operation, checkpoint, []);
-}
-/**
- * Nothing changed since the last file checkpoint: the save reports that checkpoint again and
- * writes no new one, so periodic saves of an idle workspace cost one read of the tree.
- */
-async function finishUnchanged(state, scopeKey, operation, checkpoint) {
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { checkpointId: checkpoint.checkpointId }));
-    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 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,
-                modelConfigId: snap.modelConfigId ?? item.modelConfigId,
-                threadId,
-                recoverability: restarted ? 'history_only' : item.recoverability,
-            };
-        }
-        if (restarted)
-            return { ...item, modelConfigId: snap.modelConfigId ?? item.modelConfigId, threadId, recoverability: 'history_only' };
-        return { ...item, modelConfigId: snap.modelConfigId ?? item.modelConfigId, 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}`,
-                modelConfigId: snap.modelConfigId,
-                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,
-                modelConfigId: found.modelConfigId,
-            });
-            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();
     await closeCliCredentials(state);
@@ -730,6 +520,37 @@ async function executeGitCommit(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
     }
 }
+/**
+ * Saves the workspace to Git: commit everything that changed, then push a Remix branch. A
+ * standalone workspace has no remote, and the Git gateway never lets a workspace write its
+ * project's main branch, so those two only commit.
+ */
+async function executeWorkspaceSave(state, scopeKey, operation, payload) {
+    const parsed = workspaceSavePayloadSchema.safeParse(payload ?? {});
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_save' }));
+    }
+    const binding = operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId) : undefined;
+    try {
+        const saved = await saveWorkspaceGit(await workspaceRoot(state, operation.workspaceId), {
+            message: parsed.data.trigger === 'auto' ? 'Autosave workspace' : 'Save workspace',
+            push: binding?.targetKind === 'remix',
+            boundBranch: boundBranch(state, operation),
+        });
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+        await recordNativeEvents(state, accepted, [
+            {
+                type: 'workspace.saved',
+                payload: { ...(saved.commit ? { sha: saved.commit } : {}), pushed: saved.pushed, withheld: saved.withheld },
+                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) {
@@ -898,95 +719,6 @@ function parameterPatchError(error) {
         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 } : {}),
-    }));
-}
-/** Transcripts of the workspace's resumable threads. A thread whose file cannot be read is left out. */
-async function captureTranscripts(state, workspaceId) {
-    const native = state.native;
-    if (!native?.exportThread)
-        return [];
-    const captured = [];
-    for (const session of workspaceSessions(state, workspaceId)) {
-        if (session.recoverability !== 'native')
-            continue;
-        const capturedAt = new Date().toISOString();
-        const file = await native.exportThread({ threadId: session.threadId }).catch(() => undefined);
-        if (file)
-            captured.push({ sessionId: session.sessionId, threadId: session.threadId, capturedAt, ...file });
-    }
-    return captured;
-}
-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,
-                modelConfigId: item.modelConfigId,
-                nativeDurableTurnId: durable,
-                recoverability: 'native',
-            }
-            : {
-                sessionId: item.sessionId,
-                nativeThreadId: item.threadId,
-                modelConfigId: item.modelConfigId,
-                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)
@@ -999,36 +731,6 @@ async function releaseManagedWrite(state, writeId, workspaceId) {
     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,
-        modelConfigId: item.modelConfigId,
-        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 function attachNativeCollector(state) {
     state.native?.onCollected?.((event) => {
         void ingestCollected(state, event);

package/dist/workspace-runtime/server/execution-group.js

@@ -34,9 +34,6 @@ async function advanceEpoch(state, input) {
     state.runtimeEpoch = runtimeEpoch;
     await demoteSessions(state);
 }
-export function executionGroupRestarted(state, checkpointEpoch) {
-    return state.runtimeEpoch !== checkpointEpoch;
-}
 export async function replaceExecutionGroup(state, options) {
     return enqueue(state, async () => {
         const native = requireRestartable(state);