@playcraft/cli 0.1.9 → 0.1.11

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

@@ -5,9 +5,10 @@ import { randomUUID } from 'node:crypto';
 import { checkpointRecordSchema, fileWritePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, parameterPatchPayloadSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
 import { NativePreparationError } from '../codex/native-adapter.js';
 import { disposeTerminalHost } from './terminal-host.js';
-import { captureWorkspaceTree, materializeSnapshot, publishFileSnapshot, } from '../workspaces/file-snapshot.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, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
+import { GitWorkspaceError, bundleUnpushedCommits, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, 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';
@@ -80,7 +81,8 @@ async function executeScopedOperation(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'workspace_not_ready' }));
     }
     if (operation.kind === 'checkpoint.create') {
-        return executeCheckpoint(state, scopeKey, current, payload);
+        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);
@@ -288,9 +290,9 @@ async function executeApproval(state, scopeKey, operation, payload) {
 }
 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()}`;
+    // 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' }));
     }
@@ -321,8 +323,29 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
     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.fileObjectStoreUrl ? 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.fileObjectStoreUrl) {
-        const tree = await captureWorkspaceTree(root, previousFilePaths(state), revisions);
         const stillActive = await activeManagedWrites(state, workspaceId);
         if (stillActive.length > 0) {
             return finishBestEffort(state, scopeKey, operation, checkpointId, workspaceId, createdAt, stillActive.map((item) => item.source));
@@ -334,6 +357,10 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
                 workspaceId,
                 generation: state.config.generation,
                 tree,
+                native: transcripts,
+                uploaded: workspaceSaves(state, workspaceId).uploaded,
+                uploadedTranscripts: workspaceSaves(state, workspaceId).transcripts,
+                headers: objectStoreHeaders(state, state.config.fileObjectStoreUrl),
             });
         }
         catch {
@@ -393,8 +420,26 @@ async function executeCheckpoint(state, scopeKey, operation, payload) {
     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 ?? '');
@@ -767,7 +812,7 @@ async function executeTerminalCreate(state, scopeKey, operation, payload) {
 }
 /** The branch a registered workspace is bound to; the single-workspace mode has none. */
 function boundBranch(state, operation) {
-    return operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId)?.branchName : undefined;
+    return operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId)?.branchName ?? undefined : undefined;
 }
 function gitErrorCode(error) {
     return error instanceof GitWorkspaceError ? error.code : 'git_command_failed';
@@ -808,6 +853,22 @@ async function finishCheckpoint(state, scopeKey, operation, checkpoint, activeWr
         ...(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 = [];

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

@@ -0,0 +1,19 @@
+import { chmod, rename, writeFile } from 'node:fs/promises';
+import { applySandboxEndpointPatch } from '@playcraft/common/cloud-workspace/runtime';
+/** Persist the new addresses, then publish them to the running process. A restart is not required. */
+export async function applyRuntimeEndpointPatch(state, patch) {
+    const next = applySandboxEndpointPatch(state.config, patch);
+    const changed = next.callbackUrl !== state.config.callbackUrl || next.modelProxyUrl !== state.config.modelProxyUrl;
+    const result = { changed, callbackUrl: next.callbackUrl, modelProxyUrl: next.modelProxyUrl };
+    if (!changed)
+        return result;
+    if (!state.configPath) {
+        throw new Error('endpoint_config_path_missing');
+    }
+    const temporary = `${state.configPath}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(next)}\n`, { mode: 0o600 });
+    await chmod(temporary, 0o600);
+    await rename(temporary, state.configPath);
+    state.config = next;
+    return result;
+}

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

@@ -3,6 +3,7 @@ import { registerWorkspace, revisionScope, workspaceRoot, WorkspaceContextError
 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, 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';
@@ -61,6 +62,15 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, 200, { workspaceId: binding.workspaceId, status: 'registered' });
             return;
         }
+        if (request.method === 'POST' && url.pathname === '/runtime/endpoints') {
+            try {
+                writeJson(response, 200, await applyRuntimeEndpointPatch(state, await readJson(request)));
+            }
+            catch {
+                writeError(response, runtimeError('invalid_config', 'endpoint_patch_rejected'));
+            }
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/handshake') {
             writeJson(response, 200, handshake(state));
             return;
@@ -101,7 +111,11 @@ export async function handleRuntimeRequest(state, request, response) {
         if (request.method === 'GET' && url.pathname === '/runtime/files') {
             if (writeDestroyed(state, response))
                 return;
-            writeJson(response, 200, await listWorkspaceFiles(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined), state.journal.fileRevisions(revisionScope(state, url.searchParams.get('workspaceId') ?? undefined))));
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            const root = await workspaceRoot(state, workspaceId);
+            const listed = await listWorkspaceFiles(root, state.journal.fileRevisions(revisionScope(state, workspaceId)));
+            console.log(`[workspace-files] GET /runtime/files workspaceId=${workspaceId ?? '-'} root=${root} files=${listed.files.length}`);
+            writeJson(response, 200, listed);
             return;
         }
         if (request.method === 'GET' && url.pathname === '/runtime/file') {

package/dist/workspace-runtime/workspaces/checkpoint-saves.js

@@ -0,0 +1,79 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+/** Local copies kept per workspace. Older ones are removed; the remote snapshots stay. */
+const LOCAL_COPIES_KEPT = 3;
+const saves = new WeakMap();
+/** Kept in memory: after a restart the first save writes a new checkpoint and uploads again. */
+export function workspaceSaves(state, workspaceId) {
+    let byWorkspace = saves.get(state);
+    if (!byWorkspace) {
+        byWorkspace = new Map();
+        saves.set(state, byWorkspace);
+    }
+    let entry = byWorkspace.get(workspaceId);
+    if (!entry) {
+        entry = { uploaded: new Set(), transcripts: new Map(), local: [], queue: Promise.resolve() };
+        byWorkspace.set(workspaceId, entry);
+    }
+    return entry;
+}
+/**
+ * Saves of one workspace run one after another. Overlapping saves (the page's timer, Runtime's
+ * save after a change, the Save button) would otherwise finish in any order, and the last to finish
+ * becomes the recovery point even when it captured the older tree.
+ */
+export function oneSaveAtATime(state, workspaceId, run) {
+    const entry = workspaceSaves(state, workspaceId);
+    const next = entry.queue.then(run, run);
+    entry.queue = next.then(() => undefined, () => undefined);
+    return next;
+}
+export function sessionsKey(sessions) {
+    return JSON.stringify([...sessions]
+        .sort((left, right) => left.sessionId.localeCompare(right.sessionId))
+        .map((item) => [item.sessionId, item.nativeThreadId ?? null, item.nativeDurableTurnId ?? null, item.recoverability]));
+}
+/**
+ * The checkpoint a save can answer with instead of writing a new one: same files on disk, same
+ * native session state, and the journal still has it.
+ */
+export function unchangedCheckpoint(state, workspaceId, digest, sessions) {
+    const last = workspaceSaves(state, workspaceId).last;
+    if (!last || last.digest !== digest || last.sessions !== sessionsKey(sessions))
+        return undefined;
+    const checkpoint = state.journal.getCheckpoint(last.checkpointId);
+    return checkpoint?.workspaceId === workspaceId ? checkpoint : undefined;
+}
+export async function rememberFileCheckpoint(state, workspaceId, saved) {
+    const entry = workspaceSaves(state, workspaceId);
+    entry.last = { checkpointId: saved.checkpointId, digest: saved.digest, sessions: sessionsKey(saved.sessions) };
+    entry.local.push(saved.checkpointId);
+    // The journal's current file and consistent checkpoints keep their copy until they are replaced.
+    const kept = new Set([state.journal.fileCheckpointId(), state.journal.consistentCheckpointId()]);
+    const removable = entry.local
+        .slice(0, Math.max(0, entry.local.length - LOCAL_COPIES_KEPT))
+        .filter((checkpointId) => !kept.has(checkpointId));
+    entry.local = entry.local.filter((checkpointId) => !removable.includes(checkpointId));
+    for (const checkpointId of removable) {
+        await rm(join(state.config.stateDir, 'file-checkpoints', checkpointId), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+/**
+ * The control credential goes only to Runtime's own object endpoint, never to another store.
+ */
+export function objectStoreHeaders(state, storeUrl) {
+    try {
+        if (new URL(storeUrl).origin !== new URL(state.config.callbackUrl).origin)
+            return {};
+    }
+    catch {
+        return {};
+    }
+    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),
+    };
+}

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

@@ -1,7 +1,75 @@
 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, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileSnapshotDigest, fileSnapshotManifestKey, fileSnapshotContentKey, nativeTranscriptKey, fileSnapshotManifestSchema, hashSnapshotBytes, isDisposableBackupPath, putObjectBytes, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { UNPUSHED_BUNDLE, addBundleObjects, repositoryResolves } from './git.js';
 const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
+/** Build output, caches and scratch folders, at any depth: regenerated, so not kept in storage. */
+const UNSTORED_DIRECTORY_NAMES = new Set([
+    'dist',
+    'dist-all',
+    'coverage',
+    '.vite',
+    '.cache',
+    '.turbo',
+    '.parcel-cache',
+    '.sass-cache',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    'tmp',
+    '.tmp',
+    '.temp',
+]);
+/** Scratch and cache files, at any depth. */
+const UNSTORED_FILE = /(?:\.tmp|\.log|\.tsbuildinfo|^\.eslintcache)$/;
+/**
+ * At the workspace root: the preview build's output, the builder's scratch folder, and skill
+ * artifacts the sandbox pulls from the registry by `.playcraft/skills.lock.json`.
+ */
+const UNSTORED_ROOT_DIRECTORIES = [
+    '.playcraft-preview-out/',
+    '.playcraft-temp/',
+    '.playcraft/skills/',
+    'ta-workspace/logs/',
+];
+/**
+ * Recordings, frames and reports the template's verify and record scripts write again on each run.
+ * The ring JSON evidence the build gate reads stays, as do the agent-edited profile and catalogs.
+ */
+const UNSTORED_RUN_OUTPUT = [
+    /^recordings\/(?:.+\.(?:mp4|webm)$|\.tmp-[^/]+\/|focus\/|clean\/)/,
+    /^validate\/(?:[^/]+\.md$|(?:ring\d+\/)?frames\/|ring\d+\/[^/]+\.mp4$)/,
+];
+/**
+ * Whether a path goes to checkpoint storage. Credentials, lock files, build output, caches and
+ * scratch files stay in the instance: its local copy keeps them, so restoring inside the instance
+ * does not remove them.
+ */
+export function keptInStorage(path) {
+    if (isDisposableBackupPath(path))
+        return false;
+    if (path.startsWith('.git/'))
+        return true;
+    if (UNSTORED_ROOT_DIRECTORIES.some((prefix) => path.startsWith(prefix)))
+        return false;
+    if (UNSTORED_RUN_OUTPUT.some((pattern) => pattern.test(path)))
+        return false;
+    const segments = path.split('/');
+    if (UNSTORED_FILE.test(segments[segments.length - 1]))
+        return false;
+    return !segments.slice(0, -1).some((segment) => UNSTORED_DIRECTORY_NAMES.has(segment));
+}
+/**
+ * Under `.git/`, what a `local` capture leaves to the remote: packs and their indexes, submodule
+ * repositories (`git submodule update` fetches them again), LFS objects, and template hooks.
+ */
+const REMOTE_GIT_DIRECTORIES = new Set([
+    '.git/objects/pack',
+    '.git/objects/info',
+    '.git/modules',
+    '.git/lfs',
+    '.git/hooks',
+]);
 const READ_ATTEMPTS = 3;
 const realIo = {
     async readdir(path) {
@@ -13,13 +81,28 @@ const realIo = {
     readFile,
     readlink,
 };
-export async function captureWorkspaceTree(root, previousPaths, revisions, io = realIo) {
+export async function captureWorkspaceTree(root, previousPaths, revisions, io = realIo, options = {}) {
     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, () => {
+    const skip = (relativePath, name, directory) => {
+        if (name === '.' || name === '..')
+            return true;
+        if (directory && name === '.git')
+            return !(options.git && relativePath === '.git');
+        // A submodule's `.git` file points into `.git/modules`, which is not kept either.
+        if (!directory && name === '.git' && relativePath !== '.git')
+            return true;
+        if (directory && SKIP_DIRECTORY_NAMES.has(name))
+            return true;
+        if (directory && options.git === 'local' && REMOTE_GIT_DIRECTORIES.has(relativePath))
+            return true;
+        // Git's own lock files only exist while a command runs and must not come back with a restore.
+        return !directory && relativePath.startsWith('.git/') && name.endsWith('.lock');
+    };
+    await walk(root, root, io, revisions, entries, files, bodies, seen, skip, () => {
         status = 'incomplete';
     });
     for (const path of [...previousPaths].sort((left, right) => left.localeCompare(right))) {
@@ -62,6 +145,12 @@ export async function materializeRemoteSnapshot(root, entries) {
         if (hashSnapshotBytes(body) !== entry.contentHash)
             throw new Error('snapshot_mismatch');
     }
+    if (applicable.some((entry) => entry.path === '.git/HEAD')) {
+        const bundle = applicable.find((entry) => entry.path === UNPUSHED_BUNDLE && entry.kind === 'file');
+        if (bundle)
+            await addBundleObjects(rootReal, Buffer.from(bundle.contentBase64 ?? '', 'base64'));
+        await clearClonedGitMetadata(rootReal);
+    }
     for (const entry of applicable) {
         const target = resolve(rootReal, ...entry.path.split('/'));
         const rel = relative(rootReal, target);
@@ -85,50 +174,100 @@ export async function materializeRemoteSnapshot(root, entries) {
         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,
+        repositoryReady: await repositoryResolves(rootReal),
         environmentReady: false,
     };
 }
+/**
+ * The snapshot's `.git` replaces the one a new clone made, objects aside: a ref the clone wrote
+ * would otherwise outrank the snapshot's packed refs.
+ */
+async function clearClonedGitMetadata(rootReal) {
+    const gitDir = join(rootReal, '.git');
+    const info = await lstat(gitDir).catch(() => undefined);
+    if (!info?.isDirectory())
+        return;
+    for (const name of await readdir(gitDir)) {
+        if (name !== 'objects')
+            await rm(join(gitDir, name), { recursive: true, force: true });
+    }
+}
+/**
+ * Content goes to the workspace's shared objects, keyed by hash. A hash in `uploaded` was stored by
+ * this process before and is not sent again; hashes stored now are added to it. The manifest still
+ * lists every stored file, so each snapshot restores on its own. Paths not `keptInStorage` are left
+ * out of both the objects and the manifest.
+ */
 export async function publishFileSnapshot(input) {
-    for (const entry of input.tree.entries) {
+    const stored = new Set();
+    const entries = input.tree.entries.filter((entry) => keptInStorage(entry.path));
+    for (const entry of entries) {
         if (entry.kind !== 'file' || !entry.contentHash)
             continue;
+        if (input.uploaded?.has(entry.contentHash) || stored.has(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');
+        await putObjectBytes(input.baseUrl, fileSnapshotContentKey(input.workspaceId, entry.contentHash), body, 'cli', input.headers);
+        stored.add(entry.contentHash);
+    }
+    const native = [];
+    for (const transcript of input.native ?? []) {
+        const contentHash = hashSnapshotBytes(transcript.body);
+        if (input.uploadedTranscripts?.get(transcript.path) !== contentHash) {
+            await putObjectBytes(input.baseUrl, nativeTranscriptKey(input.workspaceId, transcript.path), transcript.body, 'cli', input.headers);
+            input.uploadedTranscripts?.set(transcript.path, contentHash);
+        }
+        native.push({
+            sessionId: transcript.sessionId,
+            threadId: transcript.threadId,
+            path: transcript.path,
+            contentHash,
+            size: transcript.body.byteLength,
+            capturedAt: transcript.capturedAt,
+        });
     }
-    const digest = fileSnapshotDigest(input.tree.entries);
+    const digest = fileSnapshotDigest(entries);
     const manifest = fileSnapshotManifestSchema.parse({
         snapshotId: input.snapshotId,
         workspaceId: input.workspaceId,
         generation: input.generation,
         status: input.tree.status,
-        entries: input.tree.entries,
+        entries,
         digest,
+        objectLayout: 'workspace',
+        ...(native.length > 0 ? { native } : {}),
     });
     const manifestKey = fileSnapshotManifestKey(input.workspaceId, input.generation, input.snapshotId);
-    await putObjectBytes(input.baseUrl, manifestKey, Buffer.from(JSON.stringify(manifest)), 'cli');
+    await putObjectBytes(input.baseUrl, manifestKey, Buffer.from(JSON.stringify(manifest)), 'cli', input.headers);
+    for (const hash of stored)
+        input.uploaded?.add(hash);
     return { manifestKey, checksum: digest, status: input.tree.status };
 }
-async function walk(rootReal, current, io, revisions, entries, files, bodies, seen, markIncomplete) {
+/**
+ * Digest of what is on disk now, without the deletions recorded against the previous snapshot.
+ * Transcripts count too: a turn that only talked still changes what a restore can resume.
+ */
+export function liveTreeDigest(tree, native = []) {
+    const files = fileSnapshotDigest(tree.entries.filter((entry) => entry.kind !== 'deleted'));
+    if (native.length === 0)
+        return files;
+    const transcripts = native
+        .map((item) => `${item.sessionId}:${item.threadId}:${item.path}:${hashSnapshotBytes(item.body)}`)
+        .sort();
+    return hashSnapshotBytes(Buffer.from([files, ...transcripts].join('\n')));
+}
+async function walk(rootReal, current, io, revisions, entries, files, bodies, seen, skip, 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 (skip(relativePath, entry.name, entry.isDirectory()))
+            continue;
         if (!workspaceRelativePathSchema.safeParse(relativePath).success) {
             markIncomplete();
             continue;
@@ -145,7 +284,7 @@ async function walk(rootReal, current, io, revisions, entries, files, bodies, se
             continue;
         }
         if (entry.isDirectory()) {
-            await walk(rootReal, child, io, revisions, entries, files, bodies, seen, markIncomplete);
+            await walk(rootReal, child, io, revisions, entries, files, bodies, seen, skip, markIncomplete);
             continue;
         }
         if (!entry.isFile())

package/dist/workspace-runtime/workspaces/git-credential-broker.js

@@ -77,6 +77,8 @@ export class WorkspaceGitCredentialBroker {
     }
     async configure(binding, preparation) {
         preparation = workspacePreparationSchema.parse(preparation);
+        if (binding.targetKind === 'standalone' || preparation.mode !== 'clone')
+            throw new Error('git_access_denied');
         const transport = preparation.transport;
         const isDirect = isLocalWorkspaceGitAuthMode(preparation.authMode);
         if (!isDirect && transport?.kind !== 'git-gateway-v2')
@@ -118,7 +120,7 @@ export class WorkspaceGitCredentialBroker {
             || typeof input.path !== 'string')
             throw new Error('git_access_denied');
         const binding = this.state.journal.getWorkspace(input.workspaceId);
-        if (!binding)
+        if (!binding || binding.targetKind === 'standalone')
             throw new Error('git_access_denied');
         const cloneUrl = `${input.protocol}://${input.host}/${input.path}`;
         const direct = await this.direct.get(binding);
@@ -177,6 +179,8 @@ export class WorkspaceGitCredentialBroker {
             throw new Error('git_broker_unavailable');
         }
         const preparation = workspacePreparationSchema.parse(await response.json());
+        if (preparation.mode !== 'clone')
+            throw new Error('git_access_denied');
         const matched = preparation.transport && matchWorkspaceGitGatewayCloneUrl(preparation.transport.cloneUrl, this.state.config.gitGatewayOrigins, binding.repositoryUrl);
         if (this.closed || this.state.journal.destroyed() || this.state.runtimeEpoch !== epoch
             || JSON.stringify(this.state.journal.getWorkspace(binding.workspaceId)) !== JSON.stringify(binding)

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

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { lstat, readFile, realpath, stat, unlink } from 'node:fs/promises';
+import { lstat, mkdir, readFile, realpath, rename, rm, stat, unlink, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
 import { WORKSPACE_FILE_CONTENT_MAX, gitDiffSchema, gitFileContentSchema, gitGraphSchema, gitStatusSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
@@ -245,6 +245,96 @@ export async function pushWorkspaceGit(root, boundBranch) {
     catch { /* Preserve uncertainty; never replay a write automatically. */ }
     throw new GitWorkspaceError('git_push_outcome_unknown', 'git_push_outcome_unknown');
 }
+const UNPUSHED_DIRECTORY = '.git/playcraft';
+export const UNPUSHED_BUNDLE = `${UNPUSHED_DIRECTORY}/unpushed.bundle`;
+const UNPUSHED_TIPS = `${UNPUSHED_DIRECTORY}/unpushed.tips`;
+/**
+ * Keeps a bundle of the commits on local branches and the latest stash that no remote-tracking
+ * branch holds, so a backup without the packs still has them. It is rewritten only when one of
+ * those refs moves, and removed when nothing is unpushed. Without remote-tracking refs there is no
+ * baseline, and the whole history is left out rather than bundled.
+ */
+export async function bundleUnpushedCommits(root) {
+    const rootReal = await realpath(root);
+    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
+    if (!marker?.isDirectory())
+        return;
+    const tips = await git(rootReal, [
+        'for-each-ref', '--format=%(objectname) %(refname)', 'refs/heads', 'refs/remotes', 'refs/stash',
+    ]);
+    const tipsPath = join(rootReal, UNPUSHED_TIPS);
+    if ((await readFile(tipsPath, 'utf8').catch(() => undefined)) === tips)
+        return;
+    const refs = tips.split('\n').map((line) => line.split(' ')[1]).filter((ref) => Boolean(ref));
+    const local = ['--branches', ...(refs.includes('refs/stash') ? ['refs/stash'] : [])];
+    const unpushed = refs.some((ref) => ref.startsWith('refs/remotes/'))
+        ? Number.parseInt((await git(rootReal, ['rev-list', '--count', ...local, '--not', '--remotes'], 60000)).trim(), 10)
+        : 0;
+    const bundlePath = join(rootReal, UNPUSHED_BUNDLE);
+    await mkdir(join(rootReal, UNPUSHED_DIRECTORY), { recursive: true, mode: 0o700 });
+    if (unpushed > 0) {
+        // The `.lock` name keeps a half-written bundle out of any snapshot.
+        const temp = `${bundlePath}.lock`;
+        try {
+            await git(rootReal, ['bundle', 'create', temp, ...local, '--not', '--remotes'], 120000);
+            await rename(temp, bundlePath);
+        }
+        finally {
+            await rm(temp, { force: true });
+        }
+    }
+    else {
+        await rm(bundlePath, { force: true });
+    }
+    await writeFile(tipsPath, tips, { mode: 0o600 });
+}
+/**
+ * Adds a bundle's objects to the repository. `unbundle` walks history from the current refs, so this
+ * runs on the fresh clone before the snapshot's refs, which point at these very commits, replace its
+ * own. It fails when the remote lost the commits the bundle was built on; `repositoryResolves` then
+ * reports what is missing.
+ */
+export async function addBundleObjects(root, body) {
+    const rootReal = await realpath(root);
+    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
+    if (!marker?.isDirectory())
+        return;
+    const temp = join(rootReal, '.git', 'playcraft-restore.bundle.lock');
+    try {
+        await writeFile(temp, body, { mode: 0o600 });
+        await gitAllowFail(rootReal, ['bundle', 'unbundle', temp], 120000);
+    }
+    catch {
+        /* Reported by repositoryResolves. */
+    }
+    finally {
+        await rm(temp, { force: true });
+    }
+}
+/** Whether HEAD and the index resolve to objects the repository holds. */
+export async function repositoryResolves(root) {
+    const rootReal = await realpath(root);
+    const marker = await lstat(join(rootReal, '.git')).catch(() => undefined);
+    if (!marker?.isDirectory())
+        return false;
+    try {
+        // Snapshots hold files only; Git does not recognise a repository whose refs folder is gone.
+        for (const directory of ['refs/heads', 'refs/tags', 'objects']) {
+            await mkdir(join(rootReal, '.git', directory), { recursive: true, mode: 0o755 });
+        }
+        const head = await gitAllowFail(rootReal, ['rev-parse', '-q', '--verify', 'HEAD^{tree}']);
+        if (head.code === 0) {
+            const index = await gitAllowFail(rootReal, ['diff-index', '--cached', '--quiet', 'HEAD'], 60000);
+            return index.code === 0 || index.code === 1;
+        }
+        // Before the first commit there is no branch to resolve.
+        const branches = await gitAllowFail(rootReal, ['for-each-ref', '--count=1', 'refs/heads']);
+        return branches.code === 0 && branches.stdout.trim() === '';
+    }
+    catch {
+        return false;
+    }
+}
 export async function ensureWorkspaceGit(root) {
     const rootReal = await realpath(root);
     if (!(await gitMarkerExists(rootReal))) {