@playcraft/cli 0.1.60-beta → 0.1.62-beta

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

@@ -1,6 +1,7 @@
 import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, } from '@playcraft/common/cloud-workspace/runtime';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { buildOperationRecord } from './operation-record.js';
+import { preflightSkillExecution } from '../workspaces/skill-execution-context.js';
 /**
  * Shared operation acceptance: lease fence, idempotency, capability, record creation and
  * execution. HTTP supplies its transport/session checks through `validate`; in-sandbox Agent
@@ -62,7 +63,15 @@ export async function acceptOperationCore(state, parsed, options) {
         if (validation)
             return { rejected: true, refusal: validation };
         const executable = canExecuteKind(state, parsed.kind);
-        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable);
+        let policy;
+        try {
+            policy = await preflightSkillExecution(state, parsed);
+        }
+        catch (error) {
+            return rejected(409, { error: error instanceof Error && /^(?:context_|invalid_composer_context|untrusted_runtime_field)/.test(error.message)
+                    ? error.message : 'context_skill_unavailable' });
+        }
+        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable, policy);
         if (!executable) {
             const saved = await state.journal.putOperation(scopeKey, operation);
             return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed() ? 'runtime_destroyed' : state.nativeError ?? 'adapter_not_started', { operationId: saved.operationId }));

package/dist/workspace-runtime/server/directory-access.js

@@ -8,7 +8,7 @@ const instances = new WeakMap();
 const executing = new WeakMap();
 const freezing = new WeakMap();
 const TERMINAL = new Set(['completed', 'failed', 'interrupted']);
-const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'delivery.build', 'directory.create',
+const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'delivery.build', 'model.preview', 'directory.create',
     'directory.rename', 'directory.delete', 'workspace.references.import', 'skills.update', 'parameter.verify',
     'checkpoint.create', 'checkpoint.restore']);
 export function managedDirectoryScope(state, value) {
@@ -152,7 +152,7 @@ async function gateFor(state) {
                     gate.restore({ ...terminal, owner: `terminal:${terminal.terminalId}`, mode: 'shared' });
             for (const writer of state.journal.listManagedWrites())
                 if (!writer.stoppedAt) {
-                    gate.restore({ ...managedDirectoryScope(state, writer.workspaceId), owner: `managed:${writer.writeId}`, mode: 'shared' });
+                    gate.restore({ ...managedDirectoryScope(state, writer.workspaceId), owner: `managed:${writer.writeId}`, mode: writer.directoryAccessMode ?? 'shared' });
                 }
             const waiting = [];
             for (const barrier of state.journal.directoryBarriers()) {
@@ -237,6 +237,11 @@ export async function withDirectoryOwner(state, scope, owner, action) {
         throw new Error('directory_owner_not_held');
     return context.run({ state, claim: { ...scope, owner, mode: 'exclusive' } }, action);
 }
+/** Verify the existing claim without acquiring or upgrading a lease from a tool callback. */
+export async function assertOperationDirectoryAccess(state, operation, mode) {
+    if (!(await gateFor(state)).permits(`operation:${operation.operationId}`, operation, mode))
+        throw new Error('requires-exclusive-turn');
+}
 export async function withDirectoryWrite(state, scope, action) {
     const inherited = context.getStore();
     const gate = await gateFor(state);
@@ -314,9 +319,11 @@ export async function withOperationDirectoryAccess(state, operation, action, def
         const current = state.journal.getOperationById(operation.operationId);
         if (!current || TERMINAL.has(current.status))
             return;
-        await state.journal.putOperation(deferred.scopeKey, transitionOperation(current, 'uncertain', {
-            error: error instanceof Error && error.message === 'directory_access_cancelled' ? 'cancelled' : 'native_receipt_lost',
+        const cancelled = current.status === 'queued' && error instanceof Error && error.message === 'directory_access_cancelled';
+        await state.journal.putOperation(deferred.scopeKey, transitionOperation(current, cancelled ? 'interrupted' : 'uncertain', {
+            error: cancelled ? 'cancelled' : 'native_receipt_lost',
         }));
+        await state.journal.deleteDeferredDirectoryOperation(operation.operationId);
     }).catch(() => undefined);
     return state.journal.getOperationById(operation.operationId) ?? operation;
 }

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

@@ -1,11 +1,12 @@
 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';
+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, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials, ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
@@ -42,6 +43,7 @@ import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.j
 import { publishAssetTransfer } from '../workspaces/asset-transfer-publish.js';
 import { AssetTransferError } from '../workspaces/asset-transfer-storage.js';
 import { runDeliveryBuild, cancelDeliveryBuild, trackDeliveryBuild, DeliveryBuildError } from '../workspaces/delivery-build.js';
+import { runModelPreviewBuild, cancelModelPreview, modelPreviewError } from '../workspaces/procedural-3d/model-preview-build.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -76,6 +78,8 @@ const LOCAL_KINDS = new Set([
     'preview.publish',
     'delivery.build',
     'delivery.cancel',
+    'model.preview',
+    'model.preview.cancel',
     'skills.update',
 ]);
 const parameterVerifications = new WeakMap();
@@ -119,7 +123,7 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
             return executeScopedOperation(state, scopeKey, operation, payload, recovery);
         }, { operationId: operation.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}) });
     };
-    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel'].includes(operation.kind)) {
+    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel', 'model.preview', 'model.preview.cancel'].includes(operation.kind)) {
         return run();
     }
     return state.journal.exclusive(operation.kind.startsWith('session.') && operation.sessionId
@@ -201,6 +205,9 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'delivery.cancel') {
         return executeDeliveryCancel(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'model.preview' || operation.kind === 'model.preview.cancel') {
+        return executeModelPreview(state, scopeKey, current, payload);
+    }
     if (!state.native?.ready()) {
         return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
     }
@@ -411,6 +418,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 {
@@ -858,9 +879,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') {
@@ -1466,6 +1510,29 @@ async function executePreviewPublish(state, scopeKey, operation) {
     }).catch(() => undefined));
     return accepted;
 }
+async function executeModelPreview(state, scopeKey, operation, payload) {
+    if (!operation.workspaceId || operation.directoryName === 'root')
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'model_preview_scope_invalid' }));
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    if (operation.kind === 'model.preview.cancel') {
+        try {
+            const input = workspaceModelPreviewCancelSchema.parse(payload);
+            await cancelModelPreview(state, operation.workspaceId, operation.directoryName ?? 'basic', input.previewId);
+            return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
+        }
+        catch (error) {
+            return persist(state, scopeKey, transitionOperation(accepted, 'failed', { error: modelPreviewError(error) }));
+        }
+    }
+    const parsed = workspaceModelPreviewBuildSchema.safeParse(payload);
+    if (!parsed.success)
+        return persist(state, scopeKey, transitionOperation(accepted, 'failed', { error: 'model_preview_invalid_request' }));
+    trackPreviewPublish(state, runModelPreviewBuild(state, accepted, parsed.data).then(async () => { await persist(state, scopeKey, transitionOperation(accepted, 'completed')); }, async (error) => {
+        const code = modelPreviewError(error);
+        await persist(state, scopeKey, transitionOperation(accepted, code === 'model_preview_process_unknown' ? 'uncertain' : code === 'model_preview_cancelled' ? 'interrupted' : 'failed', { error: code }));
+    }).catch(() => undefined));
+    return accepted;
+}
 async function executeDeliveryBuild(state, scopeKey, operation, payload) {
     const parsed = deliveryBuildPayloadSchema.safeParse(payload);
     if (!parsed.success) {

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';
@@ -47,6 +47,8 @@ import { restoreNativeSession, SessionRestoreError } from './session-restore.js'
 import { handleAssetTransferRequest } from './asset-transfers.js';
 import { readWorktreeSource, registerChatWorktree } from '../workspaces/worktrees.js';
 import { withDirectoryWrite } from './directory-access.js';
+import { readProceduralModelCandidates } from '../workspaces/procedural-3d/read-candidates.js';
+import { ModelPreviewStore } from '../workspaces/procedural-3d/model-preview-store.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const workspaceId = url.searchParams.get('workspaceId');
@@ -137,6 +139,7 @@ async function dispatchRuntimeRequest(state, request, response) {
                 ...(state.native?.scheduledTaskProposalSource ? { scheduledTaskProposalVersion: 1 } : {}),
                 parameterAgentVersion: 1,
                 directoryConcurrencyVersion: 1,
+                skillExecutionPolicyVersion: 1,
                 parameterInitializationVersion: 1,
                 remixReferencesVersion: 1,
                 batchSourceFreezeRevision: 2,
@@ -530,6 +533,40 @@ async function dispatchRuntimeRequest(state, request, response) {
             writeJson(response, 200, deliveryBuildDetailSchema.parse({ record, ...(report ? { report } : {}) }));
             return;
         }
+        if (['GET', 'HEAD'].includes(request.method ?? '') && url.pathname === '/runtime/model-preview-content') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId');
+            if (!workspaceId || directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace' });
+                return;
+            }
+            const root = await workspaceRoot(state, workspaceId, directoryName);
+            try {
+                const output = await new ModelPreviewStore(state.config.stateDir, root).content(url.searchParams.get('previewId') ?? '');
+                response.writeHead(200, { 'content-type': 'text/html; charset=utf-8', 'content-length': output.bytes.length,
+                    'cache-control': 'private, no-store', 'x-content-type-options': 'nosniff', 'x-content-sha256': output.record.contentHash,
+                    'content-security-policy': "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: blob:; connect-src 'none'",
+                    'referrer-policy': 'no-referrer' });
+                response.end(request.method === 'HEAD' ? undefined : output.bytes);
+            }
+            catch {
+                writeJson(response, 404, { error: 'model_preview_unavailable' });
+            }
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/model-candidates') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId');
+            if (!workspaceId || directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace' });
+                return;
+            }
+            const root = await workspaceRoot(state, workspaceId, directoryName);
+            writeJson(response, 200, await readProceduralModelCandidates(root, state.config.stateDir));
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/artifacts') {
             if (writeDestroyed(state, response))
                 return;
@@ -707,6 +744,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;
@@ -974,8 +1025,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.

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,6 +4,7 @@ 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';
@@ -16,7 +17,8 @@ export const EMPTY_WORKSPACE_REPOSITORY_SKILLS = [
     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) {