@playcraft/cli 0.1.73 → 0.1.75

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/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';
@@ -440,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;
         }
@@ -898,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/attachments.js

@@ -8,21 +8,9 @@ import { excludeFromGit } from './dependencies.js';
 import { hashAttachment, probeAttachmentVideo } from './video-attachments.js';
 import { resolveLibraryAttachment } from './library-attachments.js';
 import { resolveWorkspaceDirectoryAttachment } from './directory-attachments.js';
-async function attachmentRoot(root) {
-    // Reject redirected upload directories, including symlinks that stay inside the workspace.
-    let directory = root;
-    for (const part of WORKSPACE_USER_UPLOADS_DIRECTORY.split('/')) {
-        directory = join(directory, part);
-        // shared
-        await mkdir(directory, { mode: 0o755 }).catch((error) => {
-            if (error.code !== 'EEXIST')
-                throw error;
-        });
-        if (!(await lstat(directory)).isDirectory())
-            throw new Error('invalid_attachment');
-        await chmod(directory, 0o755);
-    }
-    return directory;
+import { ensureSharedDirectory } from './shared-write.js';
+function attachmentRoot(root) {
+    return ensureSharedDirectory(root, join(root, WORKSPACE_USER_UPLOADS_DIRECTORY));
 }
 export function imageMime(bytes) {
     if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))

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/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.73",
+  "version": "0.1.75",
   "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.73",
-    "@playcraft/common": "0.1.73",
+    "@playcraft/build": "0.1.75",
+    "@playcraft/common": "0.1.75",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",