@playcraft/cli 0.1.72 → 0.1.74

package/dist/recording/recorder.js

@@ -9,6 +9,7 @@ import { promisify } from 'node:util';
 import { createRequire } from 'node:module';
 import { canonicalReplicaJson, replicaRecordingMetadataSchema, } from '@playcraft/common/agent-tools';
 import { prepareArtifactDirectory, writeJsonAtomic } from '../video-replication/evidence.js';
+import { shareVideoEvidence } from '../video-replication/evidence-share.js';
 import { probeVideo } from '../video-replication/media.js';
 import { VideoCliError } from '../video-replication/messages.js';
 import { computeProjectInputDigest } from './project-digest.js';
@@ -101,6 +102,8 @@ async function recordOne(browser, root, url, scenario, variant, signal) {
     const consolePath = join(directory, 'console.jsonl');
     await writeFile(eventPath, '', { flag: 'wx', mode: 0o600 });
     await writeFile(consolePath, '', { flag: 'wx', mode: 0o600 });
+    await shareVideoEvidence(eventPath, 'file');
+    await shareVideoEvidence(consolePath, 'file');
     const context = await browser.newContext({
         viewport: { width: scenario.viewport.width, height: scenario.viewport.height }, deviceScaleFactor: scenario.viewport.deviceScaleFactor,
         hasTouch: scenario.pointer === 'touch', isMobile: scenario.pointer === 'touch', serviceWorkers: 'block',

package/dist/video-replication/comparison-output.js

@@ -2,14 +2,24 @@ import { randomUUID } from 'node:crypto';
 import { lstat, mkdir, realpath, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, extname, isAbsolute, join, parse, resolve, sep } from 'node:path';
 import { ComparisonCliError } from './comparison-messages.js';
+import { shareVideoEvidence } from './evidence-share.js';
+/** Creates one private directory; one this run created is shared inside a cloud workspace. */
+async function makeOutputDirectory(path) {
+    const created = await mkdir(path, { mode: 0o700 }).then(() => true, error => {
+        if (error.code !== 'EEXIST')
+            throw error;
+        return false;
+    });
+    if (created)
+        await shareVideoEvidence(path, 'directory');
+}
 export async function comparisonOutputRoot(root, create = false) {
     const absolute = resolve(root), prefix = parse(absolute).root;
     let current = prefix;
     for (const part of absolute.slice(prefix.length).split(sep).filter(Boolean)) {
         current = join(current, part);
         if (create)
-            await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-                throw error; });
+            await makeOutputDirectory(current);
         const stat = await lstat(current);
         if (stat.isSymbolicLink()) {
             // macOS exposes system-managed temporary directories through these aliases.
@@ -32,8 +42,7 @@ export async function comparisonOutputPath(root, relative) {
     const parts = relative.split('/');
     for (const part of parts.slice(0, -1)) {
         current = join(current, part);
-        await mkdir(current, { mode: 0o700 }).catch(error => { if (error.code !== 'EEXIST')
-            throw error; });
+        await makeOutputDirectory(current);
         const stat = await lstat(current);
         if (!stat.isDirectory() || stat.isSymbolicLink())
             throw new ComparisonCliError('unsafeOutput', 64);
@@ -51,6 +60,7 @@ export async function writeComparisonArtifact(root, relative, writer) {
     const temporary = join(dirname(target), `.comparison-${randomUUID()}.tmp${extname(target)}`);
     try {
         await writer(temporary);
+        await shareVideoEvidence(temporary, 'file');
         await comparisonOutputPath(root, relative);
         await rename(temporary, target);
     }

package/dist/video-replication/evidence-share.js

@@ -0,0 +1,25 @@
+import { lstat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { isInsideRoot, SHARED_DIRECTORY_MODE, SHARED_FILE_MODE, sharePathWithGroup, workspaceGroup, } from '../workspace-runtime/workspaces/shared-write.js';
+/** The cloud workspace checkout above `path`: its control process writes this context file. */
+async function cloudWorkspaceRoot(path) {
+    for (let current = resolve(path);; current = dirname(current)) {
+        const context = await lstat(join(current, '.playcraft/workspace-context.json')).catch(() => undefined);
+        if (context?.isFile())
+            return current;
+        if (dirname(current) === current)
+            return undefined;
+    }
+}
+/**
+ * Evidence is created private (0700/0600) so a local run never exposes it to other users. In a
+ * cloud workspace the controller is a second identity that lists and opens these files for the
+ * user, so an entry this run created gets the development group instead. Ownership elsewhere is
+ * left to the workspace share repair.
+ */
+export async function shareVideoEvidence(path, kind) {
+    const root = await cloudWorkspaceRoot(dirname(path));
+    if (!root || resolve(path) === root || !isInsideRoot(root, path))
+        return;
+    await sharePathWithGroup(path, await workspaceGroup(root), kind === 'directory' ? SHARED_DIRECTORY_MODE : SHARED_FILE_MODE);
+}

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

@@ -109,6 +109,9 @@ export class RuntimeJournal {
     getWorkspace(workspaceId) {
         return this.snapshot.workspaces[workspaceId];
     }
+    listWorkspaces() {
+        return Object.values(this.snapshot.workspaces);
+    }
     async putWorkspace(binding) {
         const parsed = workspaceRegistrationSchema.parse(binding);
         await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });

package/dist/workspace-runtime/serve.js

@@ -33,7 +33,7 @@ import { revisionScope } from './workspaces/registry.js';
 import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
 import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
-import { platformExportTarget, readPlatformExport, startPlatformExport } from './workspaces/platform-export.js';
+import { platformExportTarget, readPlatformExport, startPlatformExport, syncWorkspaceBindings } from './workspaces/platform-export.js';
 import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
 import { executionContextToolHandler } from './workspaces/execution-context.js';
 import { registerLevelEditorRequest, startLevelEditorRequestQueue, stopLevelEditorRequestQueue } from './workspaces/level-editor-requests.js';
@@ -352,6 +352,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const port = await listenOn(server, config.listen.host, config.listen.port);
         startLevelEditorRequestQueue(state);
         startSkillActivationRequestQueue(state);
+        // After listening: the platform registers a missed binding through this server before it replies.
+        void syncWorkspaceBindings(state);
         return {
             config: state.config,
             state,

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

@@ -17,7 +17,7 @@ import { listLevelEditorTasks } from '../workspaces/level-editor-agent.js';
 import { listLevelEditorRequests } from '../workspaces/level-editor-requests.js';
 import { listSkillActivationRequests } from '../workspaces/skill-activation-requests.js';
 import { readDependencies } from '../workspaces/dependencies.js';
-import { permissionDriftFromError } from '../workspaces/workspace-shares.js';
+import { permissionDriftFromError, withShareRepair } from '../workspaces/workspace-shares.js';
 import { desktopHost, desktopRoute } from './desktop-host.js';
 import { ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { readAttachmentUpload, uploadWorkspaceAttachment, uploadWorkspaceVideoAttachment, } from '../workspaces/attachments.js';
@@ -42,7 +42,7 @@ import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
 import { WorkspaceArtifactStore } from '../workspaces/artifacts.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
 import { acceptOperationCore, observeLevelEditorTransaction } from './accept-operation.js';
-import { workspaceArtifactContentQuerySchema } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceArtifactContentQuerySchema, workspaceBindingIdentity } from '@playcraft/common/cloud-workspace/runtime';
 import { searchWorkspaceFiles } from '../workspaces/files-search.js';
 import { serveWorkspaceArchive } from '../workspaces/archive.js';
 import { verifyRuntimeAssetProvenance } from '../workspaces/asset-provenance-verifier.js';
@@ -251,6 +251,8 @@ async function dispatchRuntimeRequest(state, request, response) {
                 ...(state.native?.startPrediction ? { predictionVersion: 1 } : {}),
                 sourceReadToken: state.journal.sourceReadToken(),
                 workspaceMode: state.config.workspaceMode,
+                // Runtime compares these with Business and registers again a binding this sandbox missed.
+                workspaceBindings: state.journal.listWorkspaces().map(workspaceBindingIdentity),
                 executionGroup: {
                     replaced: state.journal.executionGroup().replaced,
                     stopConfirmed: state.journal.executionGroup().stopConfirmed,
@@ -438,7 +440,7 @@ async function dispatchRuntimeRequest(state, request, response) {
             const body = asRecord(await readJson(request));
             const workspaceId = maintenance[1];
             writeJson(response, 200, maintenance[2] === 'cleanup'
-                ? await cleanupWorkspaceDirectories(state, workspaceId, body.directoryNames)
+                ? await cleanupWorkspaceDirectories(state, workspaceId, body.directoryNames, body.archived === true ? { archived: true } : undefined)
                 : await syncWorkspaceDirectories(state, workspaceId, body.commitHash, body.targetDirectoryNames));
             return;
         }
@@ -896,8 +898,11 @@ async function dispatchRuntimeRequest(state, request, response) {
             if (writeDestroyed(state, response))
                 return;
             const relativePath = url.searchParams.get('path') ?? '';
+            const fileWorkspaceId = url.searchParams.get('workspaceId') ?? undefined;
             try {
-                writeJson(response, 200, await readObservedFile(state, url.searchParams.get('workspaceId') ?? undefined, relativePath, directoryName));
+                // A file that lost development-group access is repaired once before the read is reported.
+                const root = await workspaceRoot(state, fileWorkspaceId, directoryName);
+                writeJson(response, 200, await withShareRepair(state, root, () => readObservedFile(state, fileWorkspaceId, relativePath, directoryName)));
             }
             catch (error) {
                 if (error instanceof InvalidWorkspacePathError) {

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

@@ -3,13 +3,15 @@ import { randomUUID } from 'node:crypto';
 import { lstat, rename, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
-import { workspaceDirectoryRegistrationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceDirectoryRegistrationSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { workspaceContainerRoot, workspaceRoot, WorkspaceContextError } from './registry.js';
 import { openDirectoryToDevelopment } from './directory-access.js';
 import { prepareWorkspaceCheckout } from './prepare.js';
 import { readDependencies, scheduleDependencyInstall } from './dependencies.js';
 import { revisionScope } from './registry.js';
-import { ensureWorkspaceSkills } from './skills.js';
+import { ensureWorkspaceSkills, readWorkspaceSkills } from './skills.js';
+import { loadWorkspaceSkillArtifact, workspacePlatformSkillAccess, } from './skill-artifact-loader.js';
+import { writeWorkspaceCliContext } from './cli-context.js';
 import { checkoutBatchCommit, freezeBatchCommit } from './batch-commit.js';
 import { ensureWorkspaceArtifactInstructions } from './instructions.js';
 import { shareWorkspaceRepository } from './git.js';
@@ -28,19 +30,42 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
         const binding = state.journal.getWorkspace(directory.workspaceId);
         if (!binding)
             throw new WorkspaceContextError('workspace_not_registered');
-        const existing = binding.directories?.find(item => item.directoryName === directory.directoryName);
-        if (existing && (existing.remixId !== directory.remixId || existing.branchName !== directory.branchName || (existing.sourceCommit !== undefined && existing.sourceCommit !== directory.sourceCommit)))
+        const existing = binding.directories?.find((item) => item.directoryName === directory.directoryName);
+        if (existing &&
+            (existing.remixId !== directory.remixId ||
+                existing.branchName !== directory.branchName ||
+                (existing.sourceCommit !== undefined && existing.sourceCommit !== directory.sourceCommit)))
             throw new WorkspaceContextError('workspace_directory_binding_conflict');
         const parent = await workspaceContainerRoot(state, directory.workspaceId);
         const root = join(parent, directory.directoryName);
-        const git = async (cwd, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'credential.helper=', '-c', 'core.fsmonitor=false', '-C', cwd, ...args], {
-            timeout: 90_000, maxBuffer: 1024 * 1024,
-            env: { PATH: process.env.PATH, HOME: state.config.stateDir, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
+        const git = async (cwd, ...args) => (await execute('git', [
+            '-c',
+            'core.hooksPath=/dev/null',
+            '-c',
+            'credential.helper=',
+            '-c',
+            'core.fsmonitor=false',
+            '-C',
+            cwd,
+            ...args,
+        ], {
+            timeout: 90_000,
+            maxBuffer: 1024 * 1024,
+            env: {
+                PATH: process.env.PATH,
+                HOME: state.config.stateDir,
+                GIT_CONFIG_GLOBAL: '/dev/null',
+                GIT_CONFIG_NOSYSTEM: '1',
+                GIT_TERMINAL_PROMPT: '0',
+            },
         })).stdout.trim();
         const stat = await lstat(root).catch(() => undefined);
         if (stat) {
-            if (!stat.isDirectory() || stat.isSymbolicLink() || await git(root, 'symbolic-ref', '--short', 'HEAD') !== directory.branchName
-                || (binding.repositoryUrl !== null && await git(root, 'config', '--get', 'remote.origin.url') !== binding.repositoryUrl))
+            if (!stat.isDirectory() ||
+                stat.isSymbolicLink() ||
+                (await git(root, 'symbolic-ref', '--short', 'HEAD')) !== directory.branchName ||
+                (binding.repositoryUrl !== null &&
+                    (await git(root, 'config', '--get', 'remote.origin.url')) !== binding.repositoryUrl))
                 throw new WorkspaceContextError('workspace_checkout_mismatch');
         }
         else {
@@ -55,12 +80,29 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
                 if (worktree)
                     await checkoutChatWorktree(source, staging, directory.sourceCommit, state.config.stateDir);
                 else if (sourceDirectoryName !== undefined) {
-                    const frozen = await freezeBatchCommit({ source: { workspaceId: directory.workspaceId, root: source },
-                        commitHash: directory.sourceCommit, snapshotId: `directory-${directory.remixId}` });
-                    await checkoutBatchCommit({ source: { workspaceId: directory.workspaceId, root: source }, frozen, destination: staging });
+                    const frozen = await freezeBatchCommit({
+                        source: { workspaceId: directory.workspaceId, root: source },
+                        commitHash: directory.sourceCommit,
+                        snapshotId: `directory-${directory.remixId}`,
+                    });
+                    await checkoutBatchCommit({
+                        source: { workspaceId: directory.workspaceId, root: source },
+                        frozen,
+                        destination: staging,
+                    });
                 }
                 else
-                    await execute('git', ['-c', 'core.hooksPath=/dev/null', 'clone', '--local', '--no-hardlinks', '--no-checkout', '--', source, staging], { timeout: 90_000, maxBuffer: 1024 * 1024 });
+                    await execute('git', [
+                        '-c',
+                        'core.hooksPath=/dev/null',
+                        'clone',
+                        '--local',
+                        '--no-hardlinks',
+                        '--no-checkout',
+                        '--',
+                        source,
+                        staging,
+                    ], { timeout: 90_000, maxBuffer: 1024 * 1024 });
                 await git(staging, 'checkout', '-b', directory.branchName, directory.sourceCommit);
                 if (binding.repositoryUrl)
                     await git(staging, 'remote', 'set-url', 'origin', binding.repositoryUrl);
@@ -85,7 +127,13 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
             state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, leaseFence);
             await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
             const latest = state.journal.getWorkspace(directory.workspaceId) ?? binding;
-            await state.journal.putWorkspace({ ...latest, directories: [...(latest.directories ?? []).filter(item => item.directoryName !== directory.directoryName), { ...directory, status: 'ready' }] });
+            await state.journal.putWorkspace({
+                ...latest,
+                directories: [
+                    ...(latest.directories ?? []).filter((item) => item.directoryName !== directory.directoryName),
+                    { ...directory, status: 'ready' },
+                ],
+            });
         });
         if (state.gitCredentials && binding.repositoryUrl) {
             await state.gitCredentials.configure(state.journal.getWorkspace(directory.workspaceId) ?? binding, await state.gitCredentials.prepareDirectory(directory.workspaceId, directory.directoryName), directory.directoryName);
@@ -99,7 +147,7 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
         return;
     await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
         const binding = state.journal.getWorkspace(workspaceId);
-        const directory = binding?.directories?.find(item => item.directoryName === directoryName);
+        const directory = binding?.directories?.find((item) => item.directoryName === directoryName);
         if (!binding)
             return;
         if (directory?.status !== 'reclaimed') {
@@ -113,15 +161,33 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
             throw new WorkspaceContextError('workspace_recovery_required');
         const preparation = await state.gitCredentials.prepareDirectory(workspaceId, directoryName);
         const { pendingFork: _pendingFork, directories: _directories, ...base } = binding;
-        const target = directoryName === 'basic' ? base : { ...base, targetKind: 'remix', remixId: directory.remixId, branchName: directory.branchName };
+        const target = directoryName === 'basic'
+            ? base
+            : {
+                ...base,
+                targetKind: 'remix',
+                remixId: directory.remixId,
+                branchName: directory.branchName,
+            };
         const root = join(state.config.workspaceRoot, workspaceId, directoryName);
-        if (!await lstat(root).catch(() => undefined))
+        if (!(await lstat(root).catch(() => undefined)))
             await prepareWorkspaceCheckout(state, target, preparation, state.acceptedLeaseFence, directoryName, true);
         await shareWorkspaceRepository(root);
-        await ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'));
+        await ensureWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'), workspacePlatformSkillAccess(state, workspaceId), { optionalPlatformDefaults: true });
+        if (directoryName === 'basic')
+            await writeWorkspaceCliContext(root, workspaceId);
         await ensureWorkspaceArtifactInstructions(root);
         await openDirectoryToDevelopment(root, (await lstat(state.config.workspaceRoot)).gid);
-        await state.journal.putWorkspace({ ...binding, directories: binding.directories?.map(item => item.directoryName === directoryName ? { ...item, status: 'ready' } : item) });
+        await state.journal.putWorkspace({
+            ...binding,
+            directories: binding.directories?.map((item) => item.directoryName === directoryName ? { ...item, status: 'ready' } : item),
+        });
+        try {
+            await readWorkspaceSkills(root, join(state.config.stateDir, 'skill-artifacts'), (entry) => loadWorkspaceSkillArtifact(state, workspaceId, entry));
+        }
+        catch {
+            /* Skills reads and native turns diagnose missing artifacts; files and source repair remain available. */
+        }
         try {
             await state.gitCredentials.configure(binding, preparation, directoryName);
             const scope = revisionScope(state, workspaceId, directoryName);
@@ -131,7 +197,10 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
         }
         catch (error) {
             const current = state.journal.getWorkspace(workspaceId);
-            await state.journal.putWorkspace({ ...current, directories: current.directories?.map(item => item.directoryName === directoryName ? { ...item, status: 'reclaimed' } : item) });
+            await state.journal.putWorkspace({
+                ...current,
+                directories: current.directories?.map((item) => item.directoryName === directoryName ? { ...item, status: 'reclaimed' } : item),
+            });
             throw error;
         }
     });

package/dist/workspace-runtime/workspaces/directory-maintenance.js

@@ -1,12 +1,14 @@
 import { execFile } from 'node:child_process';
-import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { lstat, mkdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { promisify } from 'node:util';
 import { workspaceDirectoryNameSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { batchDirectoryHeld } from '../batch/occupancy.js';
-import { workspaceRoot, workspaceSessions } from './registry.js';
+import { WorkspaceContextError } from './context-error.js';
+import { residentWorkspaceDirectory, workspaceRoot, workspaceSessions } from './registry.js';
 import { withDirectoryWrite } from '../server/directory-access.js';
+import { runDeveloperCommand } from './developer-command.js';
 const execute = promisify(execFile);
 const git = async (state, root, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root, ...args], {
     timeout: 30_000, maxBuffer: 1024 * 1024, env: { PATH: process.env.PATH, HOME: state.config.stateDir, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
@@ -30,10 +32,74 @@ async function assertCleanAndPushed(state, root, allowedHead) {
     if (!upstream || (Number(await git(state, root, 'rev-list', '--count', `${upstream}..HEAD`)) > 0 && await git(state, root, 'rev-parse', 'HEAD') !== allowedHead))
         throw new Error('workspace_directory_unpushed');
 }
+async function cleanupRoot(state, workspaceId, directoryName, archived) {
+    if (state.journal.getWorkspace(workspaceId)) {
+        try {
+            return await workspaceRoot(state, workspaceId, directoryName);
+        }
+        catch (error) {
+            if (!archived || !(error instanceof WorkspaceContextError) || error.message !== 'workspace_directory_not_registered')
+                throw error;
+        }
+    }
+    else if (!archived)
+        throw new Error('workspace_not_registered');
+    // An archived checkout can outlive the journal that registered it.
+    return residentWorkspaceDirectory(state, workspaceId, directoryName);
+}
+/** True only when the archived checkout path is absent. A symlink or escaped path stays blocked. */
+async function archivedCheckoutMissing(state, workspaceId, directoryName) {
+    if (!/^[0-9a-f-]{36}$/i.test(workspaceId) || !/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
+        return false;
+    const parent = await realpath(state.config.workspaceRoot);
+    const container = join(parent, workspaceId);
+    let containerStat;
+    try {
+        containerStat = await lstat(container);
+    }
+    catch (error) {
+        return error.code === 'ENOENT';
+    }
+    if (!containerStat.isDirectory() || containerStat.isSymbolicLink() || relative(parent, await realpath(container)) !== workspaceId)
+        return false;
+    try {
+        await lstat(join(container, directoryName));
+        return false;
+    }
+    catch (error) {
+        return error.code === 'ENOENT';
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/** The controller cannot unlink files the development user created with mode 0700. That user removes them. */
+async function removeCheckout(state, root) {
+    try {
+        await rm(root, { recursive: true, force: true });
+        return;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== 'EACCES' && code !== 'EPERM')
+            throw error;
+        const outcome = await runDeveloperCommand(state, {
+            processId: `checkout-remove-${randomUUID()}`,
+            cwd: dirname(root),
+            command: `rm -rf -- ${shellQuote(root)}`,
+            timeoutMs: 60_000,
+            onOutput: () => undefined,
+        });
+        if (outcome.code !== 0 || outcome.timedOut)
+            throw new Error('workspace_permission_denied');
+    }
+    await rm(root, { recursive: true, force: true });
+}
 /** Keep remote branches, published previews and all journal identities; only local checkouts are reclaimed. */
-export async function cleanupWorkspaceDirectories(state, workspaceId, directoryNames) {
+export async function cleanupWorkspaceDirectories(state, workspaceId, directoryNames, options) {
     if (!Array.isArray(directoryNames) || directoryNames.length === 0 || directoryNames.length > 64)
         throw new Error('workspace_directories_invalid');
+    const archived = options?.archived === true;
     const names = [...new Set(directoryNames.map(name => workspaceDirectoryNameSchema.parse(name)))];
     return state.journal.exclusive(`maintenance:${workspaceId}`, async () => {
         const cleaned = [];
@@ -43,14 +109,26 @@ export async function cleanupWorkspaceDirectories(state, workspaceId, directoryN
                 await withDirectoryWrite(state, { workspaceId, directoryName, mode: 'exclusive', wait: false }, () => state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
                     if (await workspaceDirectoryOccupied(state, workspaceId, directoryName))
                         throw new Error('workspace_directory_occupied');
-                    const root = await workspaceRoot(state, workspaceId, directoryName);
-                    await assertCleanAndPushed(state, root);
+                    const root = await cleanupRoot(state, workspaceId, directoryName, archived).catch(async (error) => {
+                        if (!archived || !(error instanceof WorkspaceContextError) || error.message !== 'workspace_not_prepared' || !await archivedCheckoutMissing(state, workspaceId, directoryName))
+                            throw error;
+                        return null;
+                    });
+                    // Archived projects are reclaimed to free the sandbox. Active projects keep uncommitted work.
+                    if (!archived) {
+                        if (root === null)
+                            throw new Error('workspace_not_prepared');
+                        await assertCleanAndPushed(state, root);
+                    }
                     const binding = state.journal.getWorkspace(workspaceId);
-                    // Persist recoverable identity before removing the checkout; a retry cannot silently adopt another branch.
-                    const existing = binding.directories?.find(item => item.directoryName === directoryName);
-                    const directory = existing ?? { workspaceId, directoryName, remixId: binding.remixId, branchName: binding.branchName };
-                    await state.journal.putWorkspace({ ...binding, directories: [...(binding.directories ?? []).filter(item => item.directoryName !== directoryName), { ...directory, status: 'reclaimed' }] });
-                    await rm(root, { recursive: true });
+                    if (binding) {
+                        // Persist recoverable identity before removing the checkout; a retry cannot silently adopt another branch.
+                        const existing = binding.directories?.find(item => item.directoryName === directoryName);
+                        const directory = existing ?? { workspaceId, directoryName, remixId: binding.remixId, branchName: binding.branchName };
+                        await state.journal.putWorkspace({ ...binding, directories: [...(binding.directories ?? []).filter(item => item.directoryName !== directoryName), { ...directory, status: 'reclaimed' }] });
+                    }
+                    if (root)
+                        await removeCheckout(state, root);
                     cleaned.push(directoryName);
                 }));
             }

package/dist/workspace-runtime/workspaces/platform-export.js

@@ -31,12 +31,11 @@ export async function platformExportTarget(state, scope) {
     return { projectId: binding.projectId, root };
 }
 /**
- * A standalone workspace has no remote to export from. The platform gives it a project (as its
- * first save does) and registers it again; the registration reaches this runtime before the reply.
+ * Asks the platform about this workspace's binding. `promote` gives a standalone workspace a
+ * project (as its first save does); both register the binding Business holds again when this
+ * runtime lacks it. The registration reaches this runtime before the reply.
  */
-async function promoteStandalone(state, scope) {
-    if (state.journal.getWorkspace(scope.workspaceId)?.targetKind !== 'standalone' || scope.directoryName !== 'basic')
-        return;
+async function requestBinding(state, workspaceId, intent) {
     const config = state.config;
     const response = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.workspacePromotions), {
         method: 'POST',
@@ -44,7 +43,7 @@ async function promoteStandalone(state, scope) {
         signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
         headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
         body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: state.runtimeEpoch,
-            workspaceId: scope.workspaceId }),
+            workspaceId, ...(intent === 'sync' ? { intent } : {}) }),
     });
     if (!response.ok) {
         const body = await response.json().catch(() => undefined);
@@ -52,6 +51,28 @@ async function promoteStandalone(state, scope) {
     }
     await response.body?.cancel().catch(() => undefined);
 }
+/**
+ * Basic needs a project to export from. Without one in the journal, the workspace is either still
+ * standalone or holds a binding whose registration never arrived; the platform settles both.
+ */
+async function ensureProjectBinding(state, scope) {
+    if (scope.directoryName !== 'basic' || state.journal.getWorkspace(scope.workspaceId)?.projectId)
+        return;
+    await requestBinding(state, scope.workspaceId, 'promote');
+}
+/**
+ * On start, asks that each binding this runtime holds still match Business, so one whose
+ * registration never arrived is registered again before anything needs it. Best effort.
+ */
+export async function syncWorkspaceBindings(state) {
+    if (state.config.workspaceMode !== 'multi' || !state.config.publicBaseUrl || !state.config.controlToken)
+        return;
+    for (const binding of state.journal.listWorkspaces()) {
+        await requestBinding(state, binding.workspaceId, 'sync').catch((error) => {
+            console.warn('[workspace-runtime] binding sync failed:', error instanceof Error ? error.message : error);
+        });
+    }
+}
 const credentialSchema = z.object({ apiUrl: z.string().url(), token: z.string().min(1) });
 async function request(state, path, init) {
     await ensureCliCredentials(state).catch(() => { throw new PlatformExportError('cli_credentials_unavailable'); });
@@ -86,13 +107,16 @@ async function request(state, path, init) {
  * Saves the directory (commit + push), then exports that commit for the channels through the
  * platform, as the delivery panel's Export does. Each channel uses that panel's fixed HTML or
  * ZIP choice. Other options repeat the channel's latest export of the branch, or stay empty
- * without one. A standalone workspace first becomes a project.
+ * without one. A standalone workspace first becomes a project, and a binding this runtime missed
+ * is registered again.
  */
 export async function startPlatformExport(state, input) {
-    await promoteStandalone(state, input);
+    await ensureProjectBinding(state, input);
     const target = await platformExportTarget(state, input);
+    // The platform replied that the workspace has a project, but this runtime still holds none.
     if (!target)
-        throw new PlatformExportError('platform_export_requires_project');
+        throw new PlatformExportError(input.directoryName === 'basic'
+            ? 'workspace_registration_not_delivered' : 'platform_export_requires_project');
     const saved = await submitTrustedOperation(state, {
         kind: 'workspace.save',
         workspaceId: input.workspaceId,

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

@@ -23,6 +23,12 @@ export function workspaceSessions(state, workspaceId, directoryName = 'basic') {
         .listSessions()
         .filter((item) => state.config.workspaceMode !== 'multi' || (item.workspaceId === workspaceId && (item.directoryName ?? 'basic') === directoryName));
 }
+/** A checkout that outlived the journal. Cleanup of an archived workspace is the only caller. */
+export async function residentWorkspaceDirectory(state, workspaceId, directoryName) {
+    if (!/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
+        throw new WorkspaceContextError('invalid_workspace_directory');
+    return checkedDirectory(state, workspaceId, directoryName);
+}
 export async function workspaceRoot(state, workspaceId, directoryName = 'basic') {
     if (state.config.workspaceMode !== 'multi')
         return state.config.workspaceRoot;

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

@@ -11,6 +11,7 @@ export const WORKSPACE_SHARED_PATHS = [
     '.playcraft/artifact-receipts',
     '.playcraft/skills',
     '.playcraft/skill-artifacts',
+    '.playcraft/video-replication',
     '.playcraft-temp',
     'dist',
 ];

package/package.json

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