@playcraft/cli 0.1.59-beta → 0.1.61-beta

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

@@ -1,8 +1,9 @@
 import { withObservedFile } from '../workspaces/revisions.js';
 import { revisionScope, sessionWorkspaceRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
+import { preflightSkillExecution } from '../workspaces/skill-execution-context.js';
 import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../workspaces/turn-changes.js';
 import { shareWorkspaceGit } from '../workspaces/shared-git.js';
-import { holdDirectoryAccess, withOperationDirectoryAccess } from './directory-access.js';
+import { cancelPendingDirectoryAccess, holdDirectoryAccess, withOperationDirectoryAccess } from './directory-access.js';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
@@ -411,6 +412,20 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
     }
     const root = await sessionWorkspaceRoot(state, operation.workspaceId, operation.directoryName);
+    try {
+        const policy = await preflightSkillExecution(state, { ...operation, payload });
+        if (policy?.directoryAccessMode === 'exclusive' && operation.directoryAccessMode !== 'exclusive')
+            throw new ComposerContextError('requires-exclusive-turn');
+        if (operation.skillExecutionPolicyVersion === 1 && (!policy ||
+            (parameterTask.data ? 'exclusive' : policy.directoryAccessMode) !== operation.directoryAccessMode))
+            throw new ComposerContextError('context_skills_changed');
+    }
+    catch (error) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', {
+            error: error instanceof Error && /^(?:context_|requires-exclusive-turn)/.test(error.message)
+                ? error.message : 'context_skill_unavailable',
+        }));
+    }
     let composer;
     let initializationSkill;
     try {
@@ -497,6 +512,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             workMode: selection.data.workMode ?? 'execute',
             skillsLockHash: composer.skillsLockHash,
             uiSnapshot: uiSnapshot.data,
+            scheduledTaskProposalBridge: typeof body.scheduledTaskProposalBridge === 'string' ? body.scheduledTaskProposalBridge : undefined,
             simulateLostReceipt: body.simulateLostReceipt === true,
             persistReservation: async ({ nativeRequestId, modelConfigId, reasoningEffort, permissionMode }) => {
                 const selectedEffort = reasoningEffort ?? requestedEffort;
@@ -857,9 +873,32 @@ async function executeInterrupt(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
     const expectedTurnId = asRecord(payload).expectedTurnId;
+    const cancelTarget = asRecord(payload).cancelQueuedOperationId;
     if (expectedTurnId !== undefined && (typeof expectedTurnId !== 'string' || !expectedTurnId
         || binding.activeTurnId !== expectedTurnId))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_changed' }));
+    // A directory-gated turn has no native turn to interrupt. Cancel only a proven pending
+    // claim; an admitted/racing claim still goes through the native interruption contract.
+    if (expectedTurnId === undefined && !binding.activeTurnId) {
+        const candidates = state.journal.deferredDirectoryOperations().flatMap(pending => {
+            const queued = state.journal.getOperationById(pending.operationId);
+            return queued?.status === 'queued' && ['session.turn', 'session.review', 'session.compact'].includes(queued.kind)
+                && queued.sessionId === sessionId && queued.workspaceId === operation.workspaceId
+                && (queued.directoryName ?? 'basic') === (operation.directoryName ?? 'basic')
+                && (cancelTarget === undefined || cancelTarget === queued.operationId || cancelTarget === queued.gatewayOperationId)
+                && !queued.nativeTurnId && !queued.nativeRequestId ? [{ pending, queued }] : [];
+        });
+        if (candidates.length === 1) {
+            const { pending, queued } = candidates[0];
+            if (await cancelPendingDirectoryAccess(state, `operation:${queued.operationId}`)) {
+                await persist(state, pending.scopeKey, transitionOperation(queued, 'interrupted', { error: 'cancelled' }));
+                await state.journal.deleteDeferredDirectoryOperation(queued.operationId);
+                return persist(state, scopeKey, transitionOperation(transitionOperation(operation, 'accepted'), 'completed'));
+            }
+        }
+    }
+    if (cancelTarget !== undefined && expectedTurnId === undefined)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_changed' }));
     const result = await native(state).interrupt({ sessionId, threadId: binding.threadId,
         ...(typeof expectedTurnId === 'string' ? { expectedTurnId } : {}) });
     if (result.outcome === 'failed') {

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

@@ -22,7 +22,7 @@ import { validateDeliveryArtifact, DeliveryValidationError } from '../workspaces
 import { DeliveryStore } from '../workspaces/delivery-store.js';
 import { importWorkspaceLibraryAttachment, listWorkspaceLibraryAttachments, listWorkspaceLibraryImportReceipts, readLibraryAttachmentUpload } from '../workspaces/library-attachments.js';
 import { beginWorkspaceDirectoryAttachment, uploadWorkspaceDirectoryFile, completeWorkspaceDirectoryAttachment, cancelWorkspaceDirectoryAttachment } from '../workspaces/directory-attachments.js';
-import { readWorkspaceSkills } from '../workspaces/skills.js';
+import { readWorkspaceSkills, readWorkspaceSkillSnapshot } from '../workspaces/skills.js';
 import { listWorkspaceRemixReferences, RemixReferenceError } from '../workspaces/remix-references.js';
 import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.js';
 import { join } from 'node:path';
@@ -134,8 +134,10 @@ async function dispatchRuntimeRequest(state, request, response) {
                 composerContextVersion: 1,
                 scheduledTaskIdentityVersion: 1,
                 scheduledTaskCancellationVersion: 1,
+                ...(state.native?.scheduledTaskProposalSource ? { scheduledTaskProposalVersion: 1 } : {}),
                 parameterAgentVersion: 1,
                 directoryConcurrencyVersion: 1,
+                skillExecutionPolicyVersion: 1,
                 parameterInitializationVersion: 1,
                 remixReferencesVersion: 1,
                 batchSourceFreezeRevision: 2,
@@ -706,6 +708,20 @@ async function dispatchRuntimeRequest(state, request, response) {
             }
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/skills/snapshot') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            try {
+                writeJson(response, 200, await readWorkspaceSkillSnapshot(await workspaceRoot(state, workspaceId, directoryName)));
+            }
+            catch (error) {
+                if (error instanceof WorkspaceContextError)
+                    throw error;
+                writeJson(response, 409, { error: 'context_skill_unavailable' });
+            }
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/skills') {
             if (writeDestroyed(state, response))
                 return;
@@ -812,6 +828,16 @@ async function dispatchRuntimeRequest(state, request, response) {
             writeJson(response, 200, operation);
             return;
         }
+        if (request.method === 'POST' && url.pathname === '/runtime/scheduled-task-proposals/source') {
+            const body = await readJson(request);
+            if (!body || Object.keys(body).some(key => !['bridge', 'threadId', 'turnId', 'toolCallId'].includes(key))
+                || !['bridge', 'threadId', 'turnId', 'toolCallId'].every(key => typeof body[key] === 'string' && Boolean(body[key]))) {
+                writeJson(response, 400, { valid: false });
+                return;
+            }
+            writeJson(response, 200, { valid: state.native?.scheduledTaskProposalSource?.(body) === true });
+            return;
+        }
         if (request.method === 'POST' && url.pathname === '/runtime/operations') {
             // Track creation before accepting it, so a new unconnected terminal is known not to have spawned.
             terminalHost(state);
@@ -963,8 +989,15 @@ async function acceptOperation(state, request, response) {
         writeJson(response, 400, { error: 'invalid_workspace_directory' });
         return;
     }
-    if (state.config.workspaceMode === 'multi' && parsed.data.kind === 'runtime.ensure' && parsed.data.workspaceId)
-        await withDirectoryWrite(state, { workspaceId: parsed.data.workspaceId, directoryName: parsed.data.directoryName, mode: 'exclusive', wait: false }, () => restoreWorkspaceDirectory(state, parsed.data.workspaceId, parsed.data.directoryName));
+    if (state.config.workspaceMode === 'multi' && parsed.data.kind === 'runtime.ensure' && parsed.data.workspaceId && parsed.data.directoryName !== 'root') {
+        const workspaceId = parsed.data.workspaceId, directoryName = parsed.data.directoryName ?? 'basic';
+        const restoring = state.journal.getWorkspace(workspaceId)?.directories?.some(directory => directory.directoryName === directoryName && directory.status === 'reclaimed') ?? false;
+        // Opening a resident checkout only refreshes instructions and can share its background install.
+        // Rebuilding a reclaimed checkout must still exclude every existing writer.
+        await withDirectoryWrite(state, { workspaceId, directoryName, mode: restoring ? 'exclusive' : 'shared', wait: false }, async () => {
+            await restoreWorkspaceDirectory(state, workspaceId, directoryName, restoring);
+        });
+    }
     if (state.config.workspaceMode === 'multi')
         await sessionWorkspaceRoot(state, parsed.data.workspaceId, parsed.data.directoryName);
     // Shared classification: a new conversation writes no files, so a batch hold must not refuse it.
@@ -977,7 +1010,9 @@ async function acceptOperation(state, request, response) {
         ? { snapshot: parsed.data.remixReferenceSnapshot }
         : parsed.data.kind === 'asset.library.import'
             ? { selection: parsed.data.payload, snapshot: parsed.data.libraryAssetImports }
-            : parsed.data.payload;
+            : parsed.data.kind === 'session.turn' && parsed.data.scheduledTaskProposalBridge
+                ? { ...asRecord(parsed.data.payload), scheduledTaskProposalBridge: parsed.data.scheduledTaskProposalBridge }
+                : parsed.data.payload;
     const accept = async () => {
         const result = await acceptOperationCore(state, parsed.data, {
             leaseFence: incomingFence,

package/dist/workspace-runtime/server/operation-record.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
+import { workspaceComposerSelectionSchema } from '@playcraft/common/cloud-workspace/runtime';
 /** One construction point for operation records so HTTP and in-sandbox callers cannot drift. */
-export function buildOperationRecord(state, parsed, payloadHash, leaseFence, executable = true) {
+export function buildOperationRecord(state, parsed, payloadHash, leaseFence, executable = true, policy) {
     const now = new Date().toISOString();
     const payload = parsed.payload && typeof parsed.payload === 'object' && !Array.isArray(parsed.payload)
         ? parsed.payload
@@ -8,6 +9,8 @@ export function buildOperationRecord(state, parsed, payloadHash, leaseFence, exe
     return {
         operationId: randomUUID(),
         ...(parsed.gatewayOperationId ? { gatewayOperationId: parsed.gatewayOperationId } : {}),
+        ...(policy ? { skillExecutionPolicyVersion: policy.skillExecutionPolicyVersion, directoryAccessMode: policy.directoryAccessMode,
+            ...workspaceComposerSelectionSchema.parse({ context: payload.context, workMode: payload.workMode }) } : {}),
         ...(parsed.kind === 'session.turn' && payload.parameterTask !== undefined ? { directoryAccessMode: 'exclusive' } : {}),
         environment: state.config.environment,
         userId: state.config.userId,

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

@@ -5,6 +5,7 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { join } from 'node:path';
 import { launcherSocket, runDeveloperCommand } from './developer-command.js';
 import { adoptDirectoryAccess, holdDirectoryAccess, managedDirectoryScope } from '../server/directory-access.js';
+import { stopLauncherExecution } from '../codex/launcher-client.js';
 /** Long enough for a cold store on a game template; a stuck registry must not hold the write lease. */
 const INSTALL_TIMEOUT_MS = 10 * 60_000;
 const LOG_TAIL_LINES = 50;
@@ -96,7 +97,7 @@ export async function ensureWorkspaceDependencies(state, workspaceId, root) {
  * A lost controller makes the install result unknown. Keep its writer claim until a supervisor
  * confirms that the process group stopped; a closed connection alone cannot prove that.
  */
-export async function recoverInterruptedInstalls(journal) {
+export async function recoverInterruptedInstalls(journal, recovery) {
     const now = new Date().toISOString();
     for (const record of journal.listWorkspaceDependencies()) {
         if (record.status !== 'installing')
@@ -108,6 +109,26 @@ export async function recoverInterruptedInstalls(journal) {
             finishedAt: now,
         });
     }
+    for (const writer of journal.listManagedWrites()) {
+        if (writer.stoppedAt || writer.source !== 'background' || writer.executionMode === 'local' || !writer.writeId.startsWith(WRITE_PREFIX))
+            continue;
+        // As with terminals, the trusted supervisor advances an epoch only after stop-all is confirmed.
+        const stoppedEpoch = recovery?.launcherSocket && recovery.identityMatches && recovery.previousRuntimeEpoch !== undefined &&
+            recovery.runtimeEpoch > recovery.previousRuntimeEpoch &&
+            (writer.runtimeEpoch ?? recovery.previousRuntimeEpoch) < recovery.runtimeEpoch;
+        if (!stoppedEpoch) {
+            if (!recovery?.identityMatches || !recovery.launcherSocket || !writer.launcher ||
+                writer.launcher.processId !== writer.writeId || writer.launcher.runtimeEpoch !== writer.runtimeEpoch)
+                continue;
+            try {
+                await stopLauncherExecution(recovery.launcherSocket, writer.launcher);
+            }
+            catch {
+                continue;
+            }
+        }
+        await journal.putManagedWrite({ ...writer, stoppedAt: now });
+    }
 }
 async function installOnce(state, workspaceId, root, writeId) {
     const startedAt = new Date().toISOString();
@@ -150,7 +171,9 @@ async function installOnce(state, workspaceId, root, writeId) {
         }
         await excludeFromGit(root);
         // A checkpoint waits for this write: node_modules is half written until the install ends.
-        await state.journal.putManagedWrite({ writeId, workspaceId, source: 'background', startedAt });
+        const writer = { writeId, workspaceId, source: 'background', startedAt, runtimeEpoch: state.runtimeEpoch,
+            executionMode: launcherSocket(state) ? 'launcher' : 'local' };
+        await state.journal.putManagedWrite(writer);
         await state.journal.putWorkspaceDependencies({
             workspaceId,
             status: 'installing',
@@ -163,7 +186,7 @@ async function installOnce(state, workspaceId, root, writeId) {
             const shared = !launcherSocket(state) || (await waitUntilShared(root));
             if (shared) {
                 processMayRun = true;
-                outcome = await runInstall(state, workspaceId, root);
+                outcome = await runInstall(state, root, writer);
                 processStopped = outcome.code !== undefined;
             }
             else
@@ -172,10 +195,7 @@ async function installOnce(state, workspaceId, root, writeId) {
         finally {
             if (!processMayRun || processStopped)
                 await state.journal.putManagedWrite({
-                    writeId,
-                    workspaceId,
-                    source: 'background',
-                    startedAt,
+                    ...(state.journal.getManagedWrite(writeId) ?? writer),
                     stoppedAt: new Date().toISOString(),
                 });
         }
@@ -203,22 +223,27 @@ async function installOnce(state, workspaceId, root, writeId) {
  * Runs as the development user through the launcher, so the packages belong to the same user as
  * Codex and its own later installs. Without a launcher (local runs and tests) it runs directly.
  */
-async function runInstall(state, workspaceId, root) {
+async function runInstall(state, root, writer) {
     // Tests replace the install; a real registry is never reached from them.
     const planned = process.env.PLAYCRAFT_DEPENDENCY_INSTALL_COMMAND || dependencyInstallCommand(state);
     const logDir = join(state.config.stateDir, 'dependency-logs');
     // private
     await mkdir(logDir, { recursive: true, mode: 0o700 });
-    const logPath = join(logDir, `${workspaceId}.log`);
+    const logPath = join(logDir, `${writer.workspaceId}.log`);
     // private
     await writeFile(logPath, `$ ${planned}\n`, { mode: 0o600 });
     let log = '';
     let pending = Promise.resolve();
     const outcome = await runDeveloperCommand(state, {
-        processId: `${WRITE_PREFIX}${workspaceId}`,
+        processId: writer.writeId,
         cwd: root,
         command: planned,
         timeoutMs: INSTALL_TIMEOUT_MS,
+        onStarted: async (identity) => {
+            const current = state.journal.getManagedWrite(writer.writeId) ?? writer;
+            if (!current.stoppedAt)
+                await state.journal.putManagedWrite({ ...current, ...identity });
+        },
         onOutput: (chunk) => {
             const text = String(chunk);
             log = (log + text).slice(-64 * 1024);

package/dist/workspace-runtime/workspaces/developer-command.js

@@ -13,97 +13,98 @@ export function launcherSocket(state) {
 export async function runDeveloperCommand(state, input) {
     if (input.signal?.aborted)
         return { code: null, timedOut: false, canceled: true };
-    const command = `{ ${input.command}; } </dev/null 2>&1`;
+    const deadline = Date.now() + input.timeoutMs;
+    const command = `{ umask 007; ${input.command}; } </dev/null 2>&1`;
+    const gate = input.onStarted ? 'IFS= read -r playcraft_start && [ "$playcraft_start" = start ] && ' : '';
+    const args = ['-c', `umask 007; ${gate}exec "$BASH" -lc "$1"`, 'playcraft-command', command];
     const socketPath = launcherSocket(state);
     const launched = socketPath
         ? await startLauncherProcess({
             socketPath,
             processId: input.processId,
             runtimeEpoch: state.runtimeEpoch,
-            argv: ['/usr/bin/bash', '-lc', command],
+            argv: ['/usr/bin/bash', ...args],
             cwd: input.cwd,
             env: {},
         })
         : undefined;
-    launched?.stdin?.end();
     const local = launched
         ? undefined
-        : spawn('bash', ['-lc', command], {
+        : spawn('bash', args, {
             cwd: input.cwd,
             detached: true,
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ['pipe', 'pipe', 'pipe'],
         });
     const stdout = launched?.stdout ?? local.stdout;
     const stderr = launched?.stderr ?? local.stderr;
+    local?.stdin.on('error', () => undefined);
     stdout.on('data', input.onOutput);
     stderr.on('data', input.onOutput);
-    let timedOut = false;
-    let canceled = false;
-    let killTimer;
-    const abort = () => {
-        if (canceled || timedOut)
-            return;
-        canceled = true;
-        if (launched) {
-            void launched.stop().catch(() => undefined);
-            return;
+    const exited = new Promise(resolve => {
+        const finish = (code) => resolve({ kind: 'exit', code });
+        if (launched)
+            launched.onExit(finish);
+        else {
+            local.once('error', () => finish(null));
+            local.once('close', finish);
         }
-        if (!local?.pid)
-            return;
+    });
+    let stopping;
+    const stop = () => stopping ??= (async () => {
         try {
-            process.kill(-local.pid, 'SIGTERM');
+            if (launched) {
+                await launched.stop();
+                return true;
+            }
+            return !local?.pid || await stopBackgroundWriter(local.pid);
         }
         catch {
-            /* already gone */
+            return false;
         }
-        killTimer = setTimeout(() => {
-            try {
-                process.kill(-local.pid, 'SIGKILL');
-            }
-            catch {
-                /* already gone */
-            }
-        }, 5_000);
-        killTimer.unref?.();
-    };
+    })();
+    let timedOut = false;
+    let canceled = false;
+    let interrupt;
+    const interrupted = new Promise(resolve => {
+        interrupt = () => { resolve({ kind: 'interrupted' }); void stop(); };
+    });
+    const abort = () => { canceled = true; interrupt(); };
+    const timeout = () => { timedOut = true; interrupt(); };
     input.signal?.addEventListener('abort', abort, { once: true });
-    const code = await new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            timedOut = true;
-            if (launched)
-                void launched.stop().catch(() => undefined);
-            else if (local?.pid) {
-                try {
-                    process.kill(-local.pid, 'SIGKILL');
-                }
-                catch {
-                    /* already gone */
-                }
-            }
-        }, input.timeoutMs);
-        const finish = (value) => {
-            clearTimeout(timer);
-            if (killTimer)
-                clearTimeout(killTimer);
-            input.signal?.removeEventListener('abort', abort);
-            resolve(value);
-        };
-        if (launched)
-            launched.onExit(finish);
-        else {
-            local.once('error', () => finish(null));
-            local.once('close', (value) => finish(value));
-        }
+    const timer = setTimeout(timeout, Math.max(0, deadline - Date.now()));
+    if (input.signal?.aborted)
+        abort();
+    if (Date.now() >= deadline)
+        timeout();
+    const outcome = async (code) => ({
+        code: await stop() ? code : undefined, timedOut, ...(canceled ? { canceled: true } : {}),
     });
-    let stopped = !launched && !local?.pid;
     try {
-        if (launched) {
-            await launched.stop();
-            stopped = true;
+        if (canceled || timedOut)
+            return await outcome(null);
+        if (input.onStarted) {
+            if (launched && !launched.executionIdentity)
+                throw new Error('launcher_execution_identity_unavailable');
+            const persisted = Promise.resolve().then(() => input.onStarted({ pid: launched?.pid ?? local?.pid,
+                ...(launched ? { launcher: launched.executionIdentity } : {}) })).then(() => ({ kind: 'persisted' }));
+            const ready = await Promise.race([persisted, interrupted, exited]);
+            if (ready.kind !== 'persisted')
+                return await outcome(ready.kind === 'exit' ? ready.code : null);
         }
-        else if (local?.pid)
-            stopped = await stopBackgroundWriter(local.pid);
+        // A late persistence result must never reopen a canceled or timed-out command gate.
+        if (canceled || timedOut)
+            return await outcome(null);
+        (launched?.stdin ?? local.stdin)?.end(input.onStarted ? 'start\n' : undefined);
+        const result = await Promise.race([exited, interrupted]);
+        return await outcome(result.kind === 'exit' ? result.code : null);
+    }
+    catch (error) {
+        // The gate never opened. Retain the journal claim if this stop cannot be confirmed.
+        await stop();
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        input.signal?.removeEventListener('abort', abort);
     }
-    catch { /* Transport loss cannot prove the process group has stopped. */ }
-    return { code: stopped ? code : undefined, timedOut, ...(canceled ? { canceled: true } : {}) };
 }

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

@@ -94,7 +94,7 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
     });
 }
 /** A reclaimed checkout recovers its existing remote branch; no new variant or moving basic head is used. */
-export async function restoreWorkspaceDirectory(state, workspaceId, directoryName = 'basic') {
+export async function restoreWorkspaceDirectory(state, workspaceId, directoryName = 'basic', allowReclaimedRestore = true) {
     if (directoryName === 'root')
         return;
     await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => {
@@ -106,6 +106,9 @@ export async function restoreWorkspaceDirectory(state, workspaceId, directoryNam
             await ensureWorkspaceArtifactInstructions(await workspaceRoot(state, workspaceId, directoryName));
             return;
         }
+        // Recheck under the journal lock: a resident-directory caller holds only shared access.
+        if (!allowReclaimedRestore)
+            throw new Error('directory_busy');
         if (binding.targetKind === 'standalone' || !state.gitCredentials)
             throw new WorkspaceContextError('workspace_recovery_required');
         const preparation = await state.gitCredentials.prepareDirectory(workspaceId, directoryName);

package/dist/workspace-runtime/workspaces/empty-template.js

@@ -4,17 +4,21 @@ import { resolveCliPackageRoot } from '../../scaffold/compose.js';
 import { importBuiltinProjectSkills } from '../../project-skills/builtin-import.js';
 import { createHash } from 'node:crypto';
 import { canonicalProjectSkillsJson } from '@playcraft/common/project-skills';
+import { WORKSPACE_BUILTIN_SKILLS } from '@playcraft/common/cloud-workspace/runtime';
 import { syncLocalProjectSkills } from '../../project-skills/local-store.js';
 import { selectOptionalPlatformSkills } from './optional-platform-skills.js';
+import { WORKSPACE_REMIX_REFERENCES_SKILL } from './remix-reference-skill.js';
 export const EMPTY_WORKSPACE_REPOSITORY_SKILLS = [
     'playcraft-skill-recommender',
     'playcraft-image-generation',
     'playcraft-audio-generation',
     'playcraft-image-processing',
     'playcraft-workspace-assets',
+    WORKSPACE_REMIX_REFERENCES_SKILL,
     'playcraft-build-optimizer',
 ];
-export const EMPTY_WORKSPACE_PLATFORM_SKILLS = ['playcraft-video-understanding', 'playcraft-replica-validation'];
+export const EMPTY_WORKSPACE_PLATFORM_SKILLS = WORKSPACE_BUILTIN_SKILLS
+    .filter(skill => skill.defaultOnInitialize).map(skill => skill.name);
 export const EMPTY_WORKSPACE_DEFAULT_SKILLS = [...EMPTY_WORKSPACE_REPOSITORY_SKILLS, ...EMPTY_WORKSPACE_PLATFORM_SKILLS];
 /** Only called in a new, unpublished staging directory; existing workspaces are never scaffolded. */
 export async function scaffoldEmptyWorkspace(root, skillCache, access) {

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

@@ -84,8 +84,9 @@ 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 repeats its latest export of the
- * branch, or uses the defaults without one. A standalone workspace first becomes a project.
+ * 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.
  */
 export async function startPlatformExport(state, input) {
     await promoteStandalone(state, input);
@@ -121,7 +122,6 @@ export async function startPlatformExport(state, input) {
             branchName: status.branch,
             commitHash: commit,
             platforms: input.channels,
-            ...(input.format ? { format: input.format } : {}),
             clientRequestId: input.clientRequestId,
         },
     });

package/dist/workspace-runtime/workspaces/procedural-3d/candidate.js

@@ -0,0 +1,129 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, readdir, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { ensureSharedDirectory } from '../shared-write.js';
+import { createHostReviewFiles } from './review-page.js';
+import { REVIEW_DIRECTORY, REVIEW_PAGE, reviewProfileHash, validateRenderReceipt, } from './review-contracts.js';
+import { checkedFile, copySnapshot, dependencyHash, digest, relativeFile, snapshotFiles, verifyFiles, } from './files.js';
+export async function freezeCandidate(root, jobRoot, input, lockedHelpers) {
+    if ((!input.review && (!input.pagePath || !input.files.includes(input.pagePath))) ||
+        !input.sourcePaths.includes('src/createObjectModel.ts') ||
+        input.files.includes('object-sculpt-spec.json') ||
+        input.sourcePaths.some((path) => !input.files.includes(path)))
+        throw new Error('procedural_skill_missing_candidate_inputs');
+    const files = await snapshotFiles(join(jobRoot, 'workspace'), input.files);
+    if (input.review) {
+        if (!lockedHelpers ||
+            input.pagePath ||
+            !input.files.includes(input.review.factoryPath) ||
+            input.files.some((path) => path.toLowerCase().startsWith(`${REVIEW_DIRECTORY}/`)))
+            throw new Error('procedural_skill_invalid_review_input');
+        for (const file of createHostReviewFiles(input.review, lockedHelpers))
+            files.push({ ...file, hash: digest(file.bytes) });
+        files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+        if (files.length > 256 ||
+            files.reduce((size, file) => size + file.bytes.length, 0) > 64 * 1024 * 1024)
+            throw new Error('procedural_skill_size_limit');
+    }
+    const id = randomUUID();
+    await copySnapshot(root, join(jobRoot, 'candidates', id, 'source'), files);
+    const spec = await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json');
+    await copySnapshot(root, join(jobRoot, 'candidates', id), [{ path: 'spec.json', bytes: spec }]);
+    const hashes = files.map(({ path, hash }) => ({ path, hash }));
+    return {
+        id,
+        files: hashes,
+        sourcePaths: [...new Set(input.sourcePaths)].sort(),
+        sourceHash: digest(JSON.stringify(hashes)),
+        dependencyHash: await dependencyHash(root),
+        pagePath: relativeFile(input.review ? REVIEW_PAGE : input.pagePath),
+        views: input.views,
+        specHash: digest(spec),
+        expectedSpecHash: digest(spec),
+        passId: input.passId,
+        ...(input.review
+            ? {
+                hostReview: {
+                    profile: input.review.profile,
+                    profileHash: reviewProfileHash(input.review.profile),
+                    helperHash: digest(lockedHelpers.scene),
+                    profileHelperHash: digest(lockedHelpers.profile),
+                },
+            }
+            : {}),
+    };
+}
+export const candidateWorkspaceFiles = (candidate) => candidate.hostReview
+    ? candidate.files.filter((file) => !file.path.startsWith(`${REVIEW_DIRECTORY}/`))
+    : candidate.files;
+export async function verifyCandidate(root, jobRoot, candidate) {
+    if ((await dependencyHash(root)) !== candidate.dependencyHash)
+        throw new Error('procedural_skill_dependencies_changed');
+    await verifyFiles(join(jobRoot, 'workspace'), candidateWorkspaceFiles(candidate));
+    await verifyFiles(join(jobRoot, 'candidates', candidate.id, 'source'), candidate.files);
+    if (digest(await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json')) !==
+        candidate.expectedSpecHash ||
+        digest(await checkedFile(join(jobRoot, 'candidates', candidate.id), 'spec.json')) !==
+            candidate.specHash)
+        throw new Error('procedural_skill_spec_changed');
+    if (!candidate.captures?.length)
+        throw new Error('procedural_skill_captures_missing');
+    await verifyFiles(jobRoot, candidate.captures);
+    if (candidate.hostReview) {
+        if (!candidate.renderReceipt)
+            throw new Error('procedural_skill_review_receipt_missing');
+        const bytes = await checkedFile(jobRoot, candidate.renderReceipt.path);
+        if (digest(bytes) !== candidate.renderReceipt.hash)
+            throw new Error('procedural_skill_review_receipt_changed');
+        validateRenderReceipt(JSON.parse(bytes.toString('utf8')), candidate.hostReview.profile, candidate.views);
+    }
+}
+/** Publish a new immutable source directory; never overwrite the agent's current factory. */
+export async function adoptCandidate(root, jobRoot, candidate, assetId) {
+    await verifyCandidate(root, jobRoot, candidate);
+    if (candidate.review?.decision !== 'accept' ||
+        candidate.review.sourceHash !== candidate.sourceHash)
+        throw new Error('procedural_skill_review_required');
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(assetId))
+        throw new Error('procedural_skill_invalid_asset_id');
+    const relative = `src/generated/${assetId}/${candidate.id}`;
+    const target = join(root, relative);
+    const expected = candidate.files.filter((file) => candidate.sourcePaths.includes(file.path));
+    await ensureSharedDirectory(root, dirname(target));
+    const existing = await lstat(target).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (existing) {
+        if (!existing.isDirectory() || existing.isSymbolicLink())
+            throw new Error('procedural_skill_adoption_conflict');
+        const expectedPaths = new Set(expected.map((file) => file.path));
+        const checkTree = async (directory = '') => {
+            for (const item of await readdir(join(target, directory), { withFileTypes: true })) {
+                const path = directory ? `${directory}/${item.name}` : item.name;
+                if (item.isDirectory() && expected.some((file) => file.path.startsWith(`${path}/`)))
+                    await checkTree(path);
+                else if (!item.isFile() || !expectedPaths.has(path))
+                    throw new Error('procedural_skill_adoption_conflict');
+            }
+        };
+        await checkTree();
+        await verifyFiles(target, expected);
+        return { path: relative, sourceHash: candidate.sourceHash };
+    }
+    const staging = `${target}.${randomUUID()}.pending`;
+    try {
+        const files = await Promise.all(expected.map(async (file) => ({
+            path: file.path,
+            bytes: await checkedFile(join(jobRoot, 'candidates', candidate.id, 'source'), file.path),
+        })));
+        await copySnapshot(root, staging, files);
+        await verifyFiles(staging, expected);
+        await rename(staging, target);
+        return { path: relative, sourceHash: candidate.sourceHash };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}