@playcraft/cli 0.1.18 → 0.1.20

package/dist/workspace-runtime/codex/app-server.js

@@ -369,44 +369,6 @@ export function createCodexAppServerAdapter(options) {
                 throw new Error('codex_not_started');
             return { pid: next.pid, startedAt: next.startedAt };
         },
-        async canContinueThread(input) {
-            return withPreparation(async () => {
-                await ensureStarted();
-                if (!rpc)
-                    return false;
-                try {
-                    const existing = threads.get(input.threadId);
-                    if (existing && existing.sessionId !== input.sessionId)
-                        return false;
-                    if (existing?.turnActive)
-                        return false;
-                    const prepared = await lockedThreadConfig(input.cwd ?? '', input.modelConfigId, input.sessionId);
-                    if (existing?.needsRecreate)
-                        return false;
-                    if (existing?.loaded) {
-                        if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
-                            if (!existing.hasNativeHistory)
-                                return false;
-                            await restartForSkills(input.threadId, prepared.modelConfigId);
-                        }
-                        prepared.activate();
-                        return threads.get(input.threadId)?.sessionId === input.sessionId;
-                    }
-                    const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
-                        ...prepared.params }, 30_000);
-                    const resumedId = result.thread?.id ?? result.threadId;
-                    if (resumedId !== input.threadId)
-                        return false;
-                    prepared.activate();
-                    threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                        discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            });
-        },
         async readThread(input) {
             try {
                 await ensureStarted();
@@ -423,14 +385,6 @@ export function createCodexAppServerAdapter(options) {
                 return undefined;
             }
         },
-        async captureNativeCheckpoint(input) {
-            const thread = threads.get(input.threadId);
-            if (!thread || thread.sessionId !== input.sessionId)
-                return undefined;
-            if (!thread.lastTurnId)
-                return { threadId: input.threadId };
-            return { threadId: input.threadId, nativeDurableTurnId: thread.lastTurnId };
-        },
         async start() {
             await ensureStarted();
         },
@@ -454,6 +408,30 @@ export function createCodexAppServerAdapter(options) {
                 return { threadId, modelConfigId: prepared.modelConfigId };
             });
         },
+        async resumeThread(input) {
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
+                let resumedId;
+                try {
+                    const resumed = await rpc.request('thread/resume', {
+                        threadId: input.threadId, cwd: input.cwd, ...prepared.params,
+                    }, 30_000);
+                    resumedId = resumed.thread?.id;
+                }
+                catch {
+                    return undefined;
+                }
+                if (resumedId !== input.threadId)
+                    return undefined;
+                prepared.activate();
+                threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
+                return { modelConfigId: prepared.modelConfigId };
+            });
+        },
         async startTurn(input) {
             return withPreparation(async () => {
                 await ensureStarted();

package/dist/workspace-runtime/codex/loopback.js

@@ -26,6 +26,9 @@ export function createLoopbackNativeAdapter() {
             threads.set(threadId, { sessionId: input.sessionId, items: [] });
             return { threadId };
         },
+        async resumeThread(input) {
+            return threads.get(input.threadId)?.sessionId === input.sessionId ? {} : undefined;
+        },
         async startTurn(input) {
             const thread = threads.get(input.threadId);
             if (!thread || thread.sessionId !== input.sessionId)

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

@@ -1,7 +1,7 @@
 import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { workspaceRegistrationSchema, checkpointRecordSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
+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';
@@ -116,21 +116,6 @@ export class RuntimeJournal {
     listTerminals(workspaceId) {
         return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
     }
-    getCheckpoint(checkpointId) {
-        return this.snapshot.checkpoints[checkpointId];
-    }
-    fileCheckpointId() {
-        return this.snapshot.fileCheckpointId;
-    }
-    consistentCheckpointId() {
-        return this.snapshot.consistentCheckpointId;
-    }
-    async setFileCheckpointId(checkpointId) {
-        await this.run('setCheckpointId', { field: 'file', id: checkpointId });
-    }
-    async setConsistentCheckpointId(checkpointId) {
-        await this.run('setCheckpointId', { field: 'consistent', id: checkpointId });
-    }
     listManagedWrites(workspaceId) {
         return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
     }
@@ -266,11 +251,6 @@ export class RuntimeJournal {
         await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
         return parsed;
     }
-    async putCheckpoint(checkpoint) {
-        const parsed = checkpointRecordSchema.parse(checkpoint);
-        await this.run('upsertRecord', { bucket: 'checkpoints', key: parsed.checkpointId, body: parsed });
-        return parsed;
-    }
     async putFileRevision(path, record, workspaceId) {
         if (workspaceId) {
             await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
@@ -278,10 +258,6 @@ export class RuntimeJournal {
         }
         await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
     }
-    async replaceFileRevisions(records, workspaceId) {
-        const entries = Object.entries(records).map(([key, body]) => ({ key, body }));
-        await this.run('replaceBucket', { bucket: workspaceId ? `workspace_files:${workspaceId}` : 'file_revisions', entries });
-    }
     async markDestroyed() {
         await this.run('setDestroyed', {});
     }
@@ -367,7 +343,6 @@ function emptySnapshot() {
         events: {},
         sessions: {},
         terminals: {},
-        checkpoints: {},
         fileRevisions: {},
         approvals: {},
         managedWrites: {},

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

@@ -12,7 +12,7 @@ import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { parentPort } from 'node:worker_threads';
 import Database from 'better-sqlite3-pinned';
-import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, checkpointRecordSchema, terminalRecordSchema, workspaceRegistrationSchema, transitionOperation, canTransitionTurn, } from '@playcraft/common/cloud-workspace/runtime';
+import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, terminalRecordSchema, workspaceRegistrationSchema, transitionOperation, canTransitionTurn, } from '@playcraft/common/cloud-workspace/runtime';
 const SCHEMA_VERSION = 1;
 const MIN_SQLITE = [3, 51, 3];
 const BINDING = 'better-sqlite3@13.0.3';
@@ -68,9 +68,6 @@ function dispatch(type, payload) {
             case 'setDestroyed':
                 setMeta(database, 'destroyed', '1');
                 return;
-            case 'setCheckpointId':
-                setMeta(database, body.field === 'consistent' ? 'consistent_checkpoint_id' : 'file_checkpoint_id', String(body.id));
-                return;
             case 'noteExecutionGroup':
                 setMeta(database, 'execution_group', JSON.stringify({ ...(executionGroup(database)), ...asRecord(body.group) }));
                 return;
@@ -298,7 +295,6 @@ function importLegacy(database, legacy) {
         return typeof session.sessionId === 'string' && typeof session.threadId === 'string';
     });
     importBucket(database, 'terminals', asRecord(snapshot.terminals), (value) => terminalRecordSchema.safeParse(value).success);
-    importBucket(database, 'checkpoints', asRecord(snapshot.checkpoints), (value) => checkpointRecordSchema.safeParse(value).success);
     importBucket(database, 'approvals', asRecord(snapshot.approvals), (value) => isApproval(value));
     importBucket(database, 'managed_writes', asRecord(snapshot.managedWrites), () => true);
     importBucket(database, 'file_revisions', asRecord(snapshot.fileRevisions), () => true);
@@ -307,11 +303,6 @@ function importLegacy(database, legacy) {
     for (const [workspaceId, files] of Object.entries(workspaceFiles)) {
         importBucket(database, `workspace_files:${workspaceId}`, asRecord(files), () => true);
     }
-    if (typeof snapshot.fileCheckpointId === 'string')
-        setMeta(database, 'file_checkpoint_id', snapshot.fileCheckpointId);
-    if (typeof snapshot.consistentCheckpointId === 'string') {
-        setMeta(database, 'consistent_checkpoint_id', snapshot.consistentCheckpointId);
-    }
     setMeta(database, 'accepted_lease_fence', String(Number(snapshot.acceptedLeaseFence) || 0));
     setMeta(database, 'destroyed', snapshot.destroyed === true ? '1' : '0');
     setMeta(database, 'runtime_epoch', String(runtimeEpoch));
@@ -441,6 +432,7 @@ function bindTurn(database, body) {
             turnBlock: undefined,
             activeTurnId: String(body.turnId),
             threadId: String(body.threadId),
+            recoveryContextPending: undefined,
         });
     }
     const threadId = String(body.threadId);
@@ -701,13 +693,10 @@ function dump(database) {
         events: eventsObject(database),
         sessions: bucketObject(database, 'sessions'),
         terminals: bucketObject(database, 'terminals'),
-        checkpoints: bucketObject(database, 'checkpoints'),
         fileRevisions: bucketObject(database, 'file_revisions'),
         approvals: bucketObject(database, 'approvals'),
         managedWrites: bucketObject(database, 'managed_writes'),
         workspaceDependencies: bucketObject(database, 'workspace_dependencies'),
-        fileCheckpointId: metaString(database, 'file_checkpoint_id') || undefined,
-        consistentCheckpointId: metaString(database, 'consistent_checkpoint_id') || undefined,
         executionGroup: executionGroup(database),
         runtimeEpoch: metaNumber(database, 'runtime_epoch'),
         lastSourceSequence: currentCounter(database),

package/dist/workspace-runtime/previews/single-file.js

@@ -1,11 +1,19 @@
 const LOCAL_ATTR = /<(?:script|img|link|source|video|audio|iframe)\b[^>]*?\b(?:src|href)\s*=\s*["']([^"']+)["']/gi;
-const CSS_URL = /url\(\s*["']?([^"')]+)["']?\s*\)/gi;
-/** A reference the sealed document would load from the local build, not from the network or inline data. */
+/** A CSS `url(`, not the tail of a name such as `createObjectURL(` or `getAudioURL(`. */
+const CSS_URL = /(?<![\w$.-])url\(\s*["']?([^"')]+)["']?\s*\)/gi;
+/** An inline script's body, kept apart from its tag so `<script src>` is still checked. */
+const SCRIPT_BODY = /(<script\b[^>]*>)[\s\S]*?(<\/script\s*>)/gi;
+/**
+ * A reference the sealed document would load from the local build, not from the network or inline
+ * data. Inline script code is not read: inlined libraries call functions named `…URL(` and build
+ * `"url(" + src + ")"` strings at run time, and neither is a file the document loads.
+ */
 export function findExternalLocalReferences(html) {
+    const markup = html.replace(SCRIPT_BODY, '$1$2');
     const found = new Set();
     for (const expression of [LOCAL_ATTR, CSS_URL]) {
         expression.lastIndex = 0;
-        for (const match of html.matchAll(expression)) {
+        for (const match of markup.matchAll(expression)) {
             const value = (match[1] ?? '').trim();
             if (isLocalReference(value))
                 found.add(value);

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, workspaceSavePayloadSchema, 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,14 +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, materializeSnapshot, publishFileSnapshot, } from '../workspaces/file-snapshot.js';
-import { InvalidWorkspacePathError, resolveWorkspaceFile, restoreWorkspaceFiles, snapshotWorkspaceFiles, writeWorkspaceFile, } from '../workspaces/files.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',
@@ -29,8 +26,6 @@ const CONVERSATION_KINDS = new Set([
 const LOCAL_KINDS = new Set([
     'runtime.ensure',
     'runtime.destroy',
-    'checkpoint.create',
-    'checkpoint.restore',
     'file.write',
     'git.commit',
     'git.push',
@@ -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,15 +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') {
-        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);
     }
@@ -129,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);
@@ -214,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' }));
     }
@@ -226,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);
@@ -242,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,
@@ -312,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);
@@ -353,215 +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);
-    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,
-            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;
-    if (state.config.checkpointObjects) {
-        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: platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.checkpointStore),
-                snapshotId: checkpointId,
-                workspaceId,
-                generation: state.config.generation,
-                tree,
-                headers: checkpointStoreHeaders(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);
-    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,
-                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);
@@ -889,79 +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 } : {}),
-    }));
-}
-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)
@@ -974,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);
@@ -1068,16 +795,6 @@ function nativeIds(params) {
         itemId: typeof record.itemId === 'string' ? record.itemId : typeof record.approvalId === 'string' ? record.approvalId : undefined,
     };
 }
-/** The checkpoint route is on this deployment, so uploads carry the control credential. */
-function checkpointStoreHeaders(state) {
-    return {
-        authorization: `Bearer ${state.config.controlToken}`,
-        'playcraft-env': state.config.environment,
-        'x-playcraft-runtime-id': state.config.runtimeId,
-        'x-playcraft-generation': String(state.config.generation),
-        'x-playcraft-runtime-epoch': String(state.runtimeEpoch),
-    };
-}
 async function notifyCallback(state, events) {
     await fetch(platformEndpoint(state.config.publicBaseUrl, PLATFORM_ROUTES.events), {
         method: 'POST',

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);

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

@@ -1,12 +1,11 @@
 import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
 import { registerWorkspace, revisionScope, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
 import { randomUUID } from 'node:crypto';
-import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, instanceRebuildRequestSchema, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, hashOperationPayload, sourceAckSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
 import { applyRuntimeEndpointPatch } from './endpoints.js';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { InvalidWorkspacePathError, listWorkspaceFiles, } from '../workspaces/files.js';
-import { materializeRemoteSnapshot } from '../workspaces/file-snapshot.js';
 import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWorkspaceGitGraph, readWorkspaceGitStatus, } from '../workspaces/git.js';
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
 import { readDependencies } from '../workspaces/dependencies.js';
@@ -107,24 +106,6 @@ export async function handleRuntimeRequest(state, request, response) {
             writeError(response, runtimeError('capability_unavailable', 'capability_not_implemented'));
             return;
         }
-        if (request.method === 'POST' && url.pathname === '/runtime/instance/rebuild') {
-            await rebuildInstanceFiles(state, request, response);
-            return;
-        }
-        if (request.method === 'GET' && url.pathname === '/runtime/checkpoint') {
-            const checkpointId = url.searchParams.get('checkpointId') ?? '';
-            const checkpoint = state.journal.getCheckpoint(checkpointId);
-            if (!checkpoint) {
-                writeJson(response, 404, { error: 'unknown_checkpoint' });
-                return;
-            }
-            writeJson(response, 200, {
-                checkpoint,
-                fileCheckpointId: state.journal.fileCheckpointId() ?? null,
-                consistentCheckpointId: state.journal.consistentCheckpointId() ?? null,
-            });
-            return;
-        }
         if (url.pathname === '/runtime/events' || url.pathname.startsWith('/runtime/events/')) {
             await handleSourceEvents(state, request, response, url);
             return;
@@ -440,7 +421,9 @@ async function acceptOperation(state, request, response) {
         }
         else if (parsed.data.kind.startsWith('session.') && state.config.workspaceMode === 'multi') {
             const session = state.journal.getSession(parsed.data.sessionId);
-            if (!session || session.workspaceId !== parsed.data.workspaceId) {
+            // A replaced sandbox has no binding yet; the recovering turn creates it.
+            const rebinding = !session && parsed.data.kind === 'session.turn' && parsed.data.sessionRecovery;
+            if (!rebinding && (!session || session.workspaceId !== parsed.data.workspaceId)) {
                 writeJson(response, 409, { error: 'session_workspace_mismatch' });
                 return;
             }
@@ -482,7 +465,7 @@ async function acceptOperation(state, request, response) {
         state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, incomingFence);
         await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
         const queued = await state.journal.putOperation(scopeKey, operation);
-        const executed = await executeOperation(state, scopeKey, queued, parsed.data.payload);
+        const executed = await executeOperation(state, scopeKey, queued, parsed.data.payload, parsed.data.sessionRecovery);
         if (executed.status === 'uncertain') {
             writeError(response, runtimeError('uncertain_operation', executed.error ?? 'native_receipt_lost', {
                 operationId: executed.operationId,
@@ -524,42 +507,6 @@ async function writeGitRead(state, response, read) {
         writeError(response, runtimeError('capability_unavailable', reason));
     }
 }
-async function rebuildInstanceFiles(state, request, response) {
-    if (writeDestroyed(state, response))
-        return;
-    if (state.journal.fileCheckpointId() || state.journal.listSessions().length > 0) {
-        writeJson(response, 409, { status: 'failed', error: 'instance_still_alive', nativeContinuable: false });
-        return;
-    }
-    const parsed = instanceRebuildRequestSchema.safeParse(await readJson(request));
-    if (!parsed.success) {
-        writeJson(response, 400, { status: 'failed', error: 'snapshot_mismatch', nativeContinuable: false });
-        return;
-    }
-    try {
-        const root = await workspaceRoot(state, parsed.data.workspaceId);
-        const materialized = await materializeRemoteSnapshot(root, parsed.data.entries);
-        state.rebuildGate = {
-            directoryReady: materialized.directoryReady,
-            repositoryReady: materialized.repositoryReady,
-            environmentReady: materialized.environmentReady,
-        };
-        writeJson(response, 200, {
-            status: 'completed',
-            snapshotId: parsed.data.snapshotId,
-            nativeContinuable: false,
-            filesRestored: true,
-            skipped: materialized.skipped,
-            directoryReady: materialized.directoryReady,
-            repositoryReady: materialized.repositoryReady,
-            environmentReady: materialized.environmentReady,
-        });
-    }
-    catch (error) {
-        const reason = error instanceof Error && error.message === 'snapshot_mismatch' ? 'snapshot_mismatch' : 'snapshot_mismatch';
-        writeJson(response, 409, { status: 'failed', error: reason, nativeContinuable: false });
-    }
-}
 async function readJson(request) {
     const chunks = [];
     for await (const chunk of request) {

package/dist/workspace-runtime/workspaces/files.js

@@ -1,6 +1,6 @@
-import { mkdir, readdir, readFile, realpath, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, realpath, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { hashWorkspaceFileContent, hashSnapshotBytes, isWorkspaceAttachmentPath, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
 export class InvalidWorkspacePathError extends Error {
     code = 'invalid_workspace_path';
@@ -66,37 +66,6 @@ export async function listWorkspaceFiles(root, revisions) {
     files.sort((left, right) => left.path.localeCompare(right.path));
     return workspaceFileListSchema.parse({ files });
 }
-export async function snapshotWorkspaceFiles(root, snapshotDir, revisions) {
-    const listed = await listWorkspaceFiles(root, revisions);
-    await rm(snapshotDir, { recursive: true, force: true });
-    const records = [];
-    for (const file of listed.files) {
-        const content = await readFile(await resolveWorkspaceFile(root, file.path));
-        const target = join(snapshotDir, ...file.path.split('/'));
-        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-        await writeFile(target, content, { mode: 0o600 });
-        records.push({ path: file.path, contentHash: hashSnapshotBytes(content), revision: file.revision });
-    }
-    return records;
-}
-export async function restoreWorkspaceFiles(root, snapshotDir, files) {
-    const rootReal = await ensureWorkspaceRoot(root);
-    const keep = new Set(files.map((item) => item.path));
-    for (const relativePath of await walkWorkspaceFiles(rootReal, rootReal)) {
-        if (!keep.has(relativePath) && !isWorkspaceAttachmentPath(relativePath)) {
-            await rm(join(rootReal, ...relativePath.split('/')), { force: true });
-        }
-    }
-    const next = {};
-    for (const file of files) {
-        const source = join(snapshotDir, ...file.path.split('/'));
-        const content = await readFile(source);
-        const target = await resolveWorkspaceFile(root, file.path);
-        await writeFile(target, content, { mode: isWorkspaceAttachmentPath(file.path) ? 0o644 : 0o600 });
-        next[file.path] = { revision: file.revision, contentHash: hashSnapshotBytes(content) };
-    }
-    return next;
-}
 async function walkWorkspaceFiles(rootReal, current) {
     const entries = await readdir(current, { withFileTypes: true });
     const paths = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "private": false,
   "type": "module",
   "engines": {
@@ -48,8 +48,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.18",
-    "@playcraft/common": "^0.1.18",
+    "@playcraft/build": "^0.1.20",
+    "@playcraft/common": "^0.1.20",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

package/dist/workspace-runtime/workspaces/file-snapshot.js

@@ -1,213 +0,0 @@
-import { chmod, lstat, mkdir, readdir, readFile, readlink, realpath, rm, symlink, writeFile } from 'node:fs/promises';
-import { dirname, join, relative, resolve, sep } from 'node:path';
-import { fileSnapshotDigest, fileSnapshotManifestKey, fileSnapshotManifestSchema, fileSnapshotObjectKey, hashSnapshotBytes, isDisposableBackupPath, isWorkspaceAttachmentPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
-const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
-const READ_ATTEMPTS = 3;
-const realIo = {
-    async readdir(path) {
-        return readdir(path, { withFileTypes: true });
-    },
-    async lstat(path) {
-        return lstat(path);
-    },
-    readFile,
-    readlink,
-};
-export async function captureWorkspaceTree(root, previousPaths, revisions, io = realIo) {
-    const entries = [];
-    const files = [];
-    const bodies = new Map();
-    const seen = new Set();
-    let status = 'complete';
-    await walk(root, root, io, revisions, entries, files, bodies, seen, () => {
-        status = 'incomplete';
-    });
-    for (const path of [...previousPaths].sort((left, right) => left.localeCompare(right))) {
-        if (seen.has(path) || !workspaceRelativePathSchema.safeParse(path).success)
-            continue;
-        entries.push({ path, kind: 'deleted' });
-    }
-    entries.sort((left, right) => left.path.localeCompare(right.path) || left.kind.localeCompare(right.kind));
-    return { status, entries, files, bodies };
-}
-export async function materializeSnapshot(snapshotDir, tree) {
-    await rm(snapshotDir, { recursive: true, force: true });
-    for (const file of tree.files) {
-        const body = tree.bodies.get(file.path);
-        if (!body || hashSnapshotBytes(body) !== file.contentHash)
-            throw new Error('snapshot_body_missing');
-        const target = join(snapshotDir, ...file.path.split('/'));
-        await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-        await writeFile(target, body, { mode: 0o600 });
-    }
-}
-export async function materializeRemoteSnapshot(root, entries) {
-    await mkdir(root, { recursive: true, mode: 0o700 });
-    const rootReal = await realpath(root);
-    const skipped = [];
-    const applicable = [];
-    for (const entry of entries) {
-        if (isDisposableBackupPath(entry.path)) {
-            skipped.push(entry.path);
-            continue;
-        }
-        applicable.push(entry);
-    }
-    for (const entry of applicable) {
-        if (entry.kind !== 'file')
-            continue;
-        if (!entry.contentBase64 || !entry.contentHash)
-            throw new Error('snapshot_mismatch');
-        const body = Buffer.from(entry.contentBase64, 'base64');
-        if (hashSnapshotBytes(body) !== entry.contentHash)
-            throw new Error('snapshot_mismatch');
-    }
-    for (const entry of applicable) {
-        const target = resolve(rootReal, ...entry.path.split('/'));
-        const rel = relative(rootReal, target);
-        if (rel === '' || rel.startsWith(`..${sep}`) || rel === '..' || rel.startsWith('..')) {
-            throw new Error('snapshot_mismatch');
-        }
-        if (entry.kind === 'deleted') {
-            await rm(target, { force: true });
-            continue;
-        }
-        await mkdir(dirname(target), { recursive: true, mode: isWorkspaceAttachmentPath(entry.path) ? 0o755 : 0o700 });
-        if (entry.kind === 'symlink') {
-            if (!entry.target)
-                throw new Error('snapshot_mismatch');
-            await rm(target, { force: true });
-            await symlink(entry.target, target);
-            continue;
-        }
-        const body = Buffer.from(entry.contentBase64 ?? '', 'base64');
-        await writeFile(target, body, { mode: entry.mode ?? 0o600 });
-        if (entry.mode !== undefined)
-            await chmod(target, entry.mode);
-    }
-    let repositoryReady = false;
-    try {
-        const git = await lstat(join(rootReal, '.git'));
-        repositoryReady = git.isDirectory() && !git.isSymbolicLink();
-    }
-    catch {
-        repositoryReady = false;
-    }
-    return {
-        skipped,
-        directoryReady: true,
-        repositoryReady,
-        environmentReady: false,
-    };
-}
-export async function publishFileSnapshot(input) {
-    for (const entry of input.tree.entries) {
-        if (entry.kind !== 'file' || !entry.contentHash)
-            continue;
-        const body = input.tree.bodies.get(entry.path);
-        if (!body || hashSnapshotBytes(body) !== entry.contentHash)
-            throw new Error('snapshot_body_missing');
-        await putObjectBytes(input.baseUrl, fileSnapshotObjectKey(input.workspaceId, input.generation, input.snapshotId, entry.contentHash), body, 'cli', input.headers);
-    }
-    const digest = fileSnapshotDigest(input.tree.entries);
-    const manifest = fileSnapshotManifestSchema.parse({
-        snapshotId: input.snapshotId,
-        workspaceId: input.workspaceId,
-        generation: input.generation,
-        status: input.tree.status,
-        entries: input.tree.entries,
-        digest,
-    });
-    const manifestKey = fileSnapshotManifestKey(input.workspaceId, input.generation, input.snapshotId);
-    await putObjectBytes(input.baseUrl, manifestKey, Buffer.from(JSON.stringify(manifest)), 'cli', input.headers);
-    return { manifestKey, checksum: digest, status: input.tree.status };
-}
-async function walk(rootReal, current, io, revisions, entries, files, bodies, seen, markIncomplete) {
-    const listed = await io.readdir(current);
-    for (const entry of listed) {
-        if (entry.name === '.' || entry.name === '..' || SKIP_DIRECTORY_NAMES.has(entry.name))
-            continue;
-        const child = join(current, entry.name);
-        const relativePath = toPosixRelative(rootReal, child);
-        if (!workspaceRelativePathSchema.safeParse(relativePath).success) {
-            markIncomplete();
-            continue;
-        }
-        if (entry.isSymbolicLink()) {
-            const sampled = await sampleLink(child, io);
-            seen.add(relativePath);
-            if (!sampled) {
-                markIncomplete();
-                entries.push({ path: relativePath, kind: 'symlink' });
-                continue;
-            }
-            entries.push({ path: relativePath, kind: 'symlink', mode: sampled.mode, target: sampled.target });
-            continue;
-        }
-        if (entry.isDirectory()) {
-            await walk(rootReal, child, io, revisions, entries, files, bodies, seen, markIncomplete);
-            continue;
-        }
-        if (!entry.isFile())
-            continue;
-        const sampled = await sampleFile(child, io);
-        seen.add(relativePath);
-        if (!sampled) {
-            markIncomplete();
-            entries.push({ path: relativePath, kind: 'file' });
-            continue;
-        }
-        const record = {
-            path: relativePath,
-            contentHash: sampled.hash,
-            revision: revisions[relativePath]?.revision ?? 0,
-        };
-        entries.push({
-            path: relativePath,
-            kind: 'file',
-            mode: sampled.mode,
-            contentHash: sampled.hash,
-            size: sampled.body.byteLength,
-        });
-        files.push(record);
-        bodies.set(relativePath, sampled.body);
-    }
-}
-async function sampleFile(path, io) {
-    let previous;
-    for (let attempt = 0; attempt < READ_ATTEMPTS; attempt += 1) {
-        try {
-            const body = await io.readFile(path);
-            const mode = (await io.lstat(path)).mode & 0o777;
-            const hash = hashSnapshotBytes(body);
-            if (previous && previous.hash === hash && previous.mode === mode)
-                return { body, mode, hash };
-            previous = { hash, mode, body };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return undefined;
-}
-async function sampleLink(path, io) {
-    let previous;
-    for (let attempt = 0; attempt < READ_ATTEMPTS; attempt += 1) {
-        try {
-            const target = await io.readlink(path);
-            const mode = (await io.lstat(path)).mode & 0o777;
-            if (target.includes('\0') || target.length === 0 || target.length > 512)
-                return undefined;
-            if (previous && previous.target === target && previous.mode === mode)
-                return { mode, target };
-            previous = { mode, target };
-        }
-        catch {
-            return undefined;
-        }
-    }
-    return undefined;
-}
-function toPosixRelative(rootReal, target) {
-    return relative(rootReal, target).split(sep).join('/');
-}