@playcraft/cli 0.1.65 → 0.1.67

package/dist/workspace-runtime/batch/source-capture.js

@@ -57,19 +57,17 @@ export async function readSourceFiles(root) {
     }
     return files;
 }
-/**
- * Drops paths whose bytes change between two reads. A managed writer that could not be stopped
- * does not become part of the frozen input.
- */
+/** A changing source must not silently lose files from the captured input. */
 export async function filterUnstableFiles(root, files) {
     const again = await readSourceFiles(root);
-    const stable = new Map();
+    if (again.size !== files.size)
+        throw new Error('batch_source_changed');
     for (const [path, file] of files) {
         const next = again.get(path);
-        if (next && next.body.equals(file.body) && next.mode === file.mode)
-            stable.set(path, file);
+        if (!next || !next.body.equals(file.body) || next.mode !== file.mode)
+            throw new Error('batch_source_changed');
     }
-    return stable;
+    return files;
 }
 /** Independent root commit. The source branch, index and config are never written. */
 export async function captureIndependentSource(source, destination) {

package/dist/workspace-runtime/codex/app-server.js

@@ -21,6 +21,8 @@ import { WORKSPACE_DELIVERY_TOOLS, WorkspaceDeliveryTools, isWorkspaceDeliveryTo
 import { WORKSPACE_UI_INSTRUCTIONS } from './ui-instructions.js';
 import { WORKSPACE_SCHEDULED_TASK_TOOLS, WorkspaceScheduledTaskTools, isWorkspaceScheduledTaskTool } from './scheduled-task-tools.js';
 import { PROCEDURAL_3D_TOOL, ProductionSkillTools } from './production-skill-tools.js';
+import { WORKSPACE_EXECUTION_CONTEXT_TOOL, WorkspaceExecutionContextTools } from './execution-context-tools.js';
+import { WORKSPACE_LEVEL_EDITOR_TOOL, requestLevelEditorTool } from './level-editor-tools.js';
 function withModelShell(config, modelConfigId) {
     if (!modelConfigId || !/^[0-9a-f-]{36}$/i.test(modelConfigId))
         return config;
@@ -32,7 +34,7 @@ const ENGINEERING_BATCH_INSTRUCTIONS = [
     'When the user requests multiple independent engineering variants, create a real platform batch using playcraft tools create-batch --prompt <the complete request, including constraints established in this conversation> --workspace-id <the trusted batch request workspaceId> --source-directory <the trusted batch request sourceDirectoryName> --client-request-id <the trusted batch request clientRequestId> --json.',
     'Distinguish independent variants from multiple assets, levels or themes within one engineering project. Use the current session directory supplied by the runtime as the batch source; do not infer it from a preview or another conversation.',
     'The platform freezes the current source and generates each planned variant in its own Remix directory. Submission authorizes automatic generation without another prompt approval. Keep the source unchanged for this batch; do not replace independent variants with theme switching in the source.',
-    'Pass --team-id when the trusted batch request context supplies teamId. Creation means queued; use playcraft tools get-batch --batch-id <the actual batch identifier> for results. On an uncertain creation, reuse the same clientRequestId. Report creation failures without falling back to editing the source.',
+    'Creation means queued; use playcraft tools get-batch --batch-id <the actual batch identifier> for results. On an uncertain creation, reuse the same clientRequestId. Report creation failures without falling back to editing the source.',
 ].join('\n');
 const MEMBER_EXECUTION_INSTRUCTIONS = [
     'You are implementing one assigned variant in an independent Remix directory which the platform has already created.',
@@ -197,11 +199,14 @@ export function createCodexAppServerAdapter(options) {
         proposalId, sessionId: threads.get(source.threadId)?.sessionId, threadId: source.threadId, turnId: source.turnId,
     }))) : undefined;
     const productionSkill = options.productionSkill ? new ProductionSkillTools(options.productionSkill) : undefined;
+    const executionContext = options.executionContext ? new WorkspaceExecutionContextTools(options.executionContext) : undefined;
     const dynamicTools = [
         ...(options.workspaceUi ? WORKSPACE_UI_TOOLS : []),
         ...(deliveryTools ? WORKSPACE_DELIVERY_TOOLS : []),
         ...(scheduledTaskTools ? WORKSPACE_SCHEDULED_TASK_TOOLS : []),
         ...(productionSkill ? [PROCEDURAL_3D_TOOL] : []),
+        ...(executionContext ? [WORKSPACE_EXECUTION_CONTEXT_TOOL] : []),
+        ...(options.levelEditorTasks ? [WORKSPACE_LEVEL_EDITOR_TOOL] : []),
     ];
     function emitCollected(event) {
         for (const listener of collected)
@@ -310,7 +315,6 @@ export function createCodexAppServerAdapter(options) {
                 'You coordinate PlayCraft batches. The workspace engineering directories are read-only in this conversation.',
                 `Workspace identity: ${scope}. Engineering source root: ${JSON.stringify(cwd)}. Default source directory: basic.`,
                 'For a request to create multiple independent variants, create a real platform batch using playcraft tools create-batch --prompt <the complete user request> --workspace-id <workspace identity> --source-directory <basic or the explicitly selected remix directory> --client-request-id <the current batch request context identity> --json.',
-                'When the batch request context provides teamId, pass it as --team-id; the platform verifies membership before creating project ownership for a standalone workspace.',
                 'The platform plans differences, freezes the selected source and generates independent Remix engineering directories. It automatically starts generation; no browser approval is required. Preserve the source files and source Git history.',
                 'Do not implement a batch as theme switching inside one engineering directory. Do not generate or repair engineering in this coordinator conversation; the platform production tasks own that work.',
                 'If the user asks for status, use playcraft tools get-batch --batch-id <the actual batch identifier>. A successful create-batch response means queued, not completed. Report the actual identifier and current status; never claim generation completed without platform results.',
@@ -633,6 +637,26 @@ export function createCodexAppServerAdapter(options) {
             }
             if (method === 'item/tool/call') {
                 const thread = typeof payload.threadId === 'string' ? threads.get(payload.threadId) : undefined;
+                if (executionContext && payload.tool === WORKSPACE_EXECUTION_CONTEXT_TOOL.name) {
+                    const current = () => Boolean(thread && threads.get(String(payload.threadId)) === thread && thread.turnActive
+                        && payload.turnId === thread.lastTurnId && !childParents.has(String(payload.threadId)));
+                    setTimeout(() => {
+                        void executionContext.request(id, payload, nativeClient, thread?.cwd ? {
+                            cwd: thread.cwd, sessionId: thread.sessionId, current,
+                        } : undefined);
+                    }, 0);
+                    return;
+                }
+                if (options.levelEditorTasks && payload.tool === WORKSPACE_LEVEL_EDITOR_TOOL.name) {
+                    const trusted = thread?.turnActive && thread.cwd && thread.activeMode === 'execute' && !childParents.has(String(payload.threadId))
+                        && !options.fixedExecution && !options.trustedExecution?.(thread.sessionId) && thread.permissionMode !== 'read-only'
+                        && !thread.readOnlyConfirmed && payload.turnId === thread.lastTurnId && typeof payload.threadId === 'string'
+                        && typeof payload.turnId === 'string' && typeof payload.callId === 'string' && payload.callId.length > 0;
+                    void requestLevelEditorTool(options.levelEditorTasks, id, payload, nativeClient, trusted ? {
+                        sessionId: thread.sessionId, cwd: thread.cwd, threadId: payload.threadId, turnId: payload.turnId, toolCallId: payload.callId,
+                    } : undefined);
+                    return;
+                }
                 if (scheduledTaskTools && isWorkspaceScheduledTaskTool(payload.tool)) {
                     const threadId = String(payload.threadId ?? ''), turnId = String(payload.turnId ?? '');
                     const current = () => {

package/dist/workspace-runtime/codex/execution-context-broker.js

@@ -0,0 +1,61 @@
+import { workspaceExecutionContextQuerySchema } from '@playcraft/common/cloud-workspace/runtime';
+import { executionContextToolHandler } from '../workspaces/execution-context.js';
+/** Reads use the existing authenticated per-session broker route, without trusting shell scope fields. */
+export class WorkspaceExecutionContextBroker {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    current(source, valid) {
+        const state = this.state, session = state.journal.getSession(source.sessionId);
+        const operations = state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind) && operation.sessionId === source.sessionId
+            && operation.clientRequestId === source.clientRequestId
+            && operation.generation === state.config.generation && operation.runtimeEpoch === state.runtimeEpoch
+            && ['dispatched', 'accepted'].includes(operation.status));
+        const operation = operations.length === 1 ? operations[0] : undefined;
+        return Boolean(valid() && !state.journal.destroyed() && operation?.nativeThreadId && operation.nativeTurnId
+            && session?.threadId === operation.nativeThreadId && session?.activeTurnId === operation.nativeTurnId
+            && session?.cwd === source.cwd && session.workspaceId === operation.workspaceId
+            && (session.directoryName ?? 'basic') === operation.directoryName
+            && !session.turnBlock && ['running', 'waiting_for_user'].includes(session.turnStatus ?? ''));
+    }
+    async forward(request, response, source, valid) {
+        const reply = (status, value) => {
+            response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(value));
+        };
+        try {
+            if (request.socket.remoteAddress !== '127.0.0.1' || !this.current(source, valid))
+                return reply(403, { code: 'execution_context_access_denied' });
+            let text = '';
+            for await (const chunk of request) {
+                text += chunk.toString();
+                if (Buffer.byteLength(text) > 4096)
+                    return reply(400, { code: 'execution_context_invalid_input' });
+            }
+            let raw;
+            try {
+                raw = JSON.parse(text);
+            }
+            catch {
+                return reply(400, { code: 'execution_context_invalid_input' });
+            }
+            const parsed = workspaceExecutionContextQuerySchema.safeParse(raw);
+            if (!parsed.success)
+                return reply(400, { code: 'execution_context_invalid_input' });
+            if (!this.current(source, valid))
+                return reply(403, { code: 'execution_context_access_denied' });
+            const result = await executionContextToolHandler(this.state)(parsed.data, source);
+            if (!this.current(source, valid))
+                return reply(403, { code: 'execution_context_access_denied' });
+            reply(200, result);
+        }
+        catch (error) {
+            const denied = error instanceof Error && ['execution_context_access_denied', 'execution_context_scope_unavailable'].includes(error.message);
+            if (!response.headersSent)
+                reply(denied ? 403 : 503, { code: denied ? 'execution_context_access_denied' : 'execution_context_unavailable' });
+            else
+                response.destroy();
+        }
+    }
+}

package/dist/workspace-runtime/codex/execution-context-tools.js

@@ -0,0 +1,37 @@
+import { workspaceExecutionContextQuerySchema, workspaceExecutionContextReadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_EXECUTION_CONTEXT_TOOL = {
+    type: 'function', name: 'playcraft_get_execution_context',
+    description: 'Read selected current user, team, workspace or clock information for this execution. Scope and permissions come from the runtime. Request only needed fields. Omit knownRevision when the corresponding information is no longer visible, including after compaction. Clock reads always sample the current time.',
+    inputSchema: { type: 'object', properties: {
+            fields: { type: 'array', items: { type: 'string', enum: ['user', 'team', 'workspace', 'clock'] },
+                minItems: 1, maxItems: 4, uniqueItems: true },
+            knownRevision: { type: 'string', pattern: '^[a-f0-9]{64}$',
+                description: 'A revision from a previous read of the same fields, only when those values remain visible.' },
+        }, required: ['fields'], additionalProperties: false },
+};
+/** Explicit reads always reach the authority again, including conditional and repeated reads. */
+export class WorkspaceExecutionContextTools {
+    handler;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    async request(requestId, payload, client, context) {
+        if (!context?.current() || payload.namespace || payload.tool !== WORKSPACE_EXECUTION_CONTEXT_TOOL.name)
+            return rejectTool(client, requestId, 'execution_context_source_unavailable');
+        const parsed = workspaceExecutionContextQuerySchema.safeParse(payload.arguments);
+        if (!parsed.success)
+            return rejectTool(client, requestId, 'execution_context_invalid_input');
+        try {
+            const value = workspaceExecutionContextReadSchema.parse(await this.handler(parsed.data, { cwd: context.cwd, sessionId: context.sessionId }));
+            if (!context.current())
+                return rejectTool(client, requestId, 'execution_context_source_unavailable');
+            await client.respond(requestId, { success: true, contentItems: toolContent(value) });
+        }
+        catch (error) {
+            const allowed = new Set(['execution_context_access_denied', 'execution_context_scope_unavailable']);
+            await rejectTool(client, requestId, error instanceof Error && allowed.has(error.message)
+                ? error.message : 'execution_context_unavailable');
+        }
+    }
+}

package/dist/workspace-runtime/codex/generation-provenance-broker.js

@@ -13,11 +13,11 @@ export class WorkspaceGenerationProvenanceBroker {
         const root = this.state.native?.executionProcess?.();
         return socketPath && root ? prepareLauncherOrigin({ socketPath, rootPid: root.pid, runtimeEpoch: this.state.runtimeEpoch }) : undefined;
     }
-    operation(context, batch = false) {
+    operation(context, scoped = false) {
         let active = this.state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind)
             && ['dispatched', 'accepted', 'uncertain'].includes(operation.status)
             && operation.generation === this.state.config.generation && operation.runtimeEpoch === this.state.runtimeEpoch);
-        if (batch) {
+        if (scoped) {
             const owned = active.find(operation => operation.sessionId === context.sessionId && operation.clientRequestId === context.clientRequestId);
             if (!owned)
                 return undefined;
@@ -50,13 +50,16 @@ export class WorkspaceGenerationProvenanceBroker {
             const parsed = requestSchema.safeParse(JSON.parse(text));
             if (!parsed.success)
                 return deny();
-            const batch = parsed.data.toolPath === '/agent/tools/create-batch';
-            const operation = this.operation(context, batch);
+            const audio = parsed.data.toolPath === '/agent/tools/workspace-audio';
+            if (audio && context.readOnly)
+                return deny();
+            const scoped = audio || parsed.data.toolPath === '/agent/tools/create-batch';
+            const operation = this.operation(context, scoped);
             if (!operation || !await verifyLauncherOrigin({ socketPath, boundaryId: context.boundaryId,
                 runtimeEpoch: this.state.runtimeEpoch, serverPort: request.socket.localPort, clientPort: request.socket.remotePort, cwd: context.originCwd ?? context.cwd }))
                 return deny();
             // The socket lookup may take time. Never attest a turn which ended or changed meanwhile.
-            if (!valid() || this.operation(context, batch)?.operationId !== operation.operationId)
+            if (!valid() || this.operation(context, scoped)?.operationId !== operation.operationId)
                 return deny();
             const config = this.state.config;
             const input = agentGenerationProvenanceRequestSchema.parse({ ...parsed.data,
@@ -74,7 +77,7 @@ export class WorkspaceGenerationProvenanceBroker {
                 return deny();
             }
             const value = z.object({ proof: z.string().min(1).max(8192) }).strict().parse(await upstream.json());
-            if (!valid() || this.operation(context, batch)?.operationId !== operation.operationId)
+            if (!valid() || this.operation(context, scoped)?.operationId !== operation.operationId)
                 return deny();
             response.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
             response.end(JSON.stringify(value));

package/dist/workspace-runtime/codex/level-editor-tools.js

@@ -0,0 +1,18 @@
+import { levelEditorTaskIntentSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_LEVEL_EDITOR_TOOL = { type: 'function', name: 'playcraft_request_level_editor_task',
+    description: 'Request creation, evolution or repair of this project’s declarative level editor. This records a request only. Finish this turn normally without doing the same initialization yourself; the platform then runs the locked level-editor skill in a managed follow-up turn in this conversation. A requested result is not a completed editor.',
+    inputSchema: { type: 'object', properties: {
+            action: { type: 'string', enum: ['initialize', 'evolve', 'repair'] }, goal: { type: 'string', minLength: 1, maxLength: 4000 }, editorId: { type: 'string' },
+        }, required: ['action', 'goal'], additionalProperties: false } };
+export async function requestLevelEditorTool(handler, id, payload, client, source) {
+    const parsed = levelEditorTaskIntentSchema.safeParse(payload.arguments);
+    if (!source || !parsed.success || payload.namespace)
+        return rejectTool(client, id, 'level_editor_request_unavailable');
+    try {
+        await client.respond(id, { success: true, contentItems: toolContent(await handler(source, parsed.data)) });
+    }
+    catch (error) {
+        await rejectTool(client, id, error instanceof Error && /^level_editor_/.test(error.message) ? error.message : 'level_editor_request_failed');
+    }
+}

package/dist/workspace-runtime/codex/model-broker.js

@@ -8,6 +8,7 @@ import { workspaceContextFromRoot } from '../workspaces/registry.js';
 import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 import { WorkspaceGenerationProvenanceBroker } from './generation-provenance-broker.js';
 import { WorkspaceRemixReferencesBroker } from './remix-references-broker.js';
+import { WorkspaceExecutionContextBroker } from './execution-context-broker.js';
 const credentialSchema = z.object({
     token: z.string().min(1), expiresAt: z.string().datetime(),
     configId: z.string().uuid(), model: z.string().min(1).max(128),
@@ -30,10 +31,12 @@ export class WorkspaceModelBroker {
     sessionRequests = new Map();
     generation;
     references;
+    executionContext;
     constructor(state) {
         this.state = state;
         this.generation = new WorkspaceGenerationProvenanceBroker(state);
         this.references = new WorkspaceRemixReferencesBroker(state);
+        this.executionContext = new WorkspaceExecutionContextBroker(state);
     }
     async start() {
         if (this.server)
@@ -182,14 +185,15 @@ export class WorkspaceModelBroker {
         const cancel = () => abort.abort();
         response.once('close', cancel);
         try {
-            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance|remix-references)$/.exec(request.url ?? '');
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance|remix-references|execution-context)$/.exec(request.url ?? '');
             const route = match ? this.routes.get(match[1]) : undefined;
             const selected = route?.selected;
             const entry = selected?.entry;
             const presented = Buffer.from(request.headers.authorization ?? '');
             const generationRequest = match?.[2] === 'generation-provenance';
+            const contextRequest = match?.[2] === 'execution-context';
             const referencesRequest = match?.[2] === 'remix-references';
-            const expected = Buffer.from(route ? `Bearer ${generationRequest ? route.generationCapability
+            const expected = Buffer.from(route ? `Bearer ${generationRequest || contextRequest ? route.generationCapability
                 : referencesRequest ? route.referencesCapability : route.capability}` : '');
             if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
                 || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
@@ -206,6 +210,15 @@ export class WorkspaceModelBroker {
                 await this.generation.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected);
                 return;
             }
+            if (contextRequest) {
+                if (!selected?.feedback) {
+                    response.writeHead(403);
+                    response.end();
+                    return;
+                }
+                await this.executionContext.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected);
+                return;
+            }
             if (referencesRequest) {
                 if (!selected?.feedback) {
                     response.writeHead(403);

package/dist/workspace-runtime/codex/scheduled-task-tools.js

@@ -3,7 +3,7 @@ import { scheduledTaskProposalDraftSchema, scheduledTaskProposalDraftJsonSchema
 import { rejectTool, toolContent } from './tool-response.js';
 export const WORKSPACE_SCHEDULED_TASK_TOOLS = [
     { type: 'function', name: 'playcraft_get_scheduled_task_context',
-        description: 'Read server time, scheduling defaults, and tasks actually related to this conversation. The returned timeZone describes the server clock, not the user’s local timezone; clarify the intended timezone when it is unknown. When several tasks match, ask the user which task to change. This tool never changes a task.',
+        description: 'Read current server time, the resolved workspace or user timezone, scheduling defaults, and tasks actually related to this conversation. Use the returned timeZone for local scheduling unless the user explicitly requests another timezone. When several tasks match, ask the user which task to change. This tool never changes a task.',
         inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
     { type: 'function', name: 'playcraft_propose_scheduled_task',
         description: 'Prepare a scheduled-task creation or change for the user to review in a persistent confirmation card. Read scheduling context first. This does not create or change a task: only the user can confirm the card. A pending_confirmation result must never be reported as an applied task.',

package/dist/workspace-runtime/previews/finalize.js

@@ -59,6 +59,6 @@ export async function finalizeWorkspacePlayable(root, built, tool, options = {})
         throw new Error('preview_source_changed');
     const current = await readWorkspacePlayable(root).catch(() => undefined);
     if (!current?.bytes.equals(bytes))
-        await saveWorkspacePlayableOutput(root, bytes);
+        await saveWorkspacePlayableOutput(root, bytes, options);
     await captureGeneratedArtifact(WORKSPACE_PLAYABLE_OUTPUT_PATH, tool, {}, root, createHash('sha256').update(bytes).digest('hex'), options.source);
 }

package/dist/workspace-runtime/previews/output.js

@@ -3,7 +3,7 @@ import { chmod, lstat, mkdir, realpath, rename, rm, writeFile } from 'node:fs/pr
 import { dirname, join, relative } from 'node:path';
 import { WORKSPACE_PLAYABLE_OUTPUT_PATH } from '@playcraft/common/cloud-workspace/runtime';
 /** Persist only validated, self-contained build bytes; unrelated delivery files are preserved. */
-export async function saveWorkspacePlayableOutput(root, bytes) {
+export async function saveWorkspacePlayableOutput(root, bytes, options = {}) {
     const workspace = await realpath(root);
     let directory = workspace;
     for (const segment of dirname(WORKSPACE_PLAYABLE_OUTPUT_PATH).split('/')) {
@@ -30,6 +30,9 @@ export async function saveWorkspacePlayableOutput(root, bytes) {
             return undefined; throw error; });
         if (stat && (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1))
             throw new Error('preview_build_failed');
+        const signature = stat ? JSON.stringify([stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs]) : undefined;
+        if ('expectedSignature' in options && signature !== options.expectedSignature)
+            throw new Error('preview_source_changed');
         await rename(temporary, target);
     }
     finally {

package/dist/workspace-runtime/previews/publish.js

@@ -13,6 +13,7 @@ import { classifyPreviewOutput, findExternalLocalReferences } from './single-fil
 import { finalizeWorkspacePlayable, readWorkspacePlayable, workspacePlayableSignature } from './finalize.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
 import { isolateWorkspaceForBuild } from '../workspaces/build-isolation.js';
+import { markAudioBuildInputs, verifyAudioBuildInputs } from '../workspaces/audio-assets/build-inputs.js';
 import { openScratchToDevelopment } from '../workspaces/directory-access.js';
 import { injectPreviewDiagnostics } from './diagnostics.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
@@ -103,7 +104,7 @@ export async function runPreviewPublish(state, operation, root) {
             // The build runs as the development identity while this copy belongs to the controller.
             await openScratchToDevelopment(buildCopy, (await lstat(root)).gid);
             const project = join(buildCopy, 'project'), staged = join(buildCopy, 'output');
-            await isolateWorkspaceForBuild(root, project);
+            const audioInputs = await isolateWorkspaceForBuild(root, project);
             if (modelInputs)
                 await verifyWorkspaceModelBuildInputs(project, modelInputs);
             await buildPreview(state, project, staged, operation.operationId, output, appendLog);
@@ -112,7 +113,9 @@ export async function runPreviewPublish(state, operation, root) {
             if (modelInputs)
                 await verifyWorkspaceModelBuildInputs(root, modelInputs);
             const built = await readSingleHtml(staged);
-            const finalBytes = modelInputs ? markWorkspaceModelBuild(built, modelInputs) : built;
+            await verifyAudioBuildInputs(root, audioInputs);
+            const audioMarked = markAudioBuildInputs(built, audioInputs);
+            const finalBytes = modelInputs ? markWorkspaceModelBuild(audioMarked, modelInputs) : audioMarked;
             await finalizeWorkspacePlayable(root, finalBytes, 'preview.publish', {
                 expectedSignature: signature, source: { operationId: operation.operationId, ...(operation.sessionId ? { sessionId: operation.sessionId } : {}) },
             });

package/dist/workspace-runtime/previews/runtime-preview.js

@@ -5,6 +5,7 @@ import JSON5 from 'json5';
 import { z } from 'zod';
 import { embedWorkspaceRuntimeProfile, workspaceRelativePathSchema, workspaceRuntimePreviewProfileSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
+import { readWorkspaceLevelEditor, levelEditorDigest } from '../workspaces/level-editor.js';
 import { revisionScope } from '../workspaces/registry.js';
 import { PREVIEW_RUNTIME_DIRECTORY, previewRuntimeSdkArtifactSchema, readPreviewRuntimeDistribution, } from '../../preview-runtime/distribution.js';
 const manifestPath = '.playcraft/workspace.json';
@@ -106,7 +107,21 @@ export async function prepareRuntimePreview(state, operation, root) {
     if (typeof packageData.scripts?.[config.buildScript] !== 'string')
         throw new RuntimePreviewBuildError('runtime_preview_script_missing');
     const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
-    const read = () => readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    const readLevel = () => readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), { state, operation });
+    const beforeLevel = await readLevel();
+    if (JSON5.parse(manifest.toString()).levelEditor && beforeLevel.status !== 'ready')
+        throw new RuntimePreviewBuildError('runtime_preview_level_editor_invalid');
+    const read = async () => {
+        const parameters = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+        if (parameters.status === 'ready')
+            return parameters;
+        const level = await readLevel();
+        if (level.status !== 'ready')
+            return parameters;
+        return { status: 'ready', schemaHash: level.schemaHash, sourceFingerprint: level.sourceFingerprint,
+            dataHash: levelEditorDigest(JSON.stringify(level.documentHashes)), dataRevision: Math.max(0, ...Object.values(level.revisions)),
+            schemaRevision: 0, themeId: 'default', runtimeI18n: undefined };
+    };
     const before = await read();
     if (before.status !== 'ready' ||
         !before.schemaHash ||
@@ -170,7 +185,14 @@ export async function prepareRuntimePreview(state, operation, root) {
                 ...(before.runtimeI18n.themeHash ? { runtimeI18nHash: before.runtimeI18n.themeHash } : {}) } : {}),
         },
     };
-    const context = { buildId, ...profileBase };
+    const levelBinding = beforeLevel.status === 'ready' && beforeLevel.definition ? {
+        workspaceId: operation.workspaceId, directoryName: operation.directoryName ?? 'basic', editorId: beforeLevel.definition.editorId,
+        dataContractVersion: beforeLevel.definition.dataContractVersion, executionContractHash: beforeLevel.executionContractHash,
+    } : undefined;
+    const levelInputs = beforeLevel.status === 'ready' && beforeLevel.definition ? await Promise.all([...new Set([beforeLevel.definitionPath, ...Object.values(beforeLevel.definition.documents).flatMap(item => [item.path, item.schema])])]
+        .map(async (path) => ({ path, sha256: digest(await insideFile(root, path)) }))) : undefined;
+    const context = { buildId, ...profileBase, ...(levelBinding ? { levelEditor: { binding: levelBinding, inputs: levelInputs,
+                schemaHash: beforeLevel.schemaHash, dataHash: before.dataHash } } : {}) };
     // Remove stale outputs before the script runs; a stale report cannot satisfy this build's identity.
     for (const path of [config.outputPath, config.reportPath]) {
         await rm(await isolatedPath(root, path), { force: true });
@@ -183,6 +205,10 @@ export async function prepareRuntimePreview(state, operation, root) {
             : `pnpm run ${shellQuote(config.buildScript)}`}`,
         async finish() {
             const after = await read();
+            const afterLevel = await readLevel();
+            if (levelBinding && (afterLevel.status !== 'ready' || afterLevel.executionContractHash !== beforeLevel.executionContractHash ||
+                JSON.stringify(afterLevel.documentHashes) !== JSON.stringify(beforeLevel.documentHashes)))
+                throw new RuntimePreviewBuildError('runtime_preview_level_editor_changed');
             if (after.status !== 'ready' ||
                 after.sourceFingerprint !== before.sourceFingerprint ||
                 after.dataHash !== before.dataHash ||
@@ -243,8 +269,17 @@ export async function prepareRuntimePreview(state, operation, root) {
                 ...profileBase,
                 buildDigest: report.data.htmlDigest,
             });
+            let html = embedWorkspaceRuntimeProfile(bytes.toString(), profile);
+            if (levelBinding) {
+                if (!/<\/head>/i.test(html))
+                    throw new RuntimePreviewBuildError('runtime_preview_html_invalid');
+                if (/id=["']playcraft-level-editor-profile["']/.test(html))
+                    throw new RuntimePreviewBuildError('runtime_preview_duplicate_level_profile');
+                const stamp = `<script id="playcraft-level-editor-profile" type="application/json">${JSON.stringify({ protocolVersion: 1, binding: levelBinding }).replaceAll('<', '\\u003c')}</script>`;
+                html = html.replace(/<\/head>/i, `${stamp}</head>`);
+            }
             return {
-                bytes: Buffer.from(embedWorkspaceRuntimeProfile(bytes.toString(), profile)),
+                bytes: Buffer.from(html),
                 profile,
             };
         },

package/dist/workspace-runtime/serve.js

@@ -34,6 +34,8 @@ import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
 import { platformExportTarget, readPlatformExport, startPlatformExport } from './workspaces/platform-export.js';
 import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
+import { executionContextToolHandler } from './workspaces/execution-context.js';
+import { registerLevelEditorRequest, startLevelEditorRequestQueue, stopLevelEditorRequestQueue } from './workspaces/level-editor-requests.js';
 import { proceduralSkillHandler } from './workspaces/procedural-3d/host.js';
 import { recoverModelPreviewOperations } from './workspaces/procedural-3d/model-preview-recovery.js';
 import { recoverModelPreparationOperations, stopModelPreparations } from './workspaces/model-preparation.js';
@@ -313,11 +315,13 @@ export async function startWorkspaceRuntime(config, options = {}) {
             socket.destroy();
         });
         const port = await listenOn(server, config.listen.host, config.listen.port);
+        startLevelEditorRequestQueue(state);
         return {
             config: state.config,
             state,
             url: `http://${formatHost(config.listen.host)}:${port}`,
             async close() {
+                stopLevelEditorRequestQueue(state);
                 const serverClosed = closeServer(server);
                 await stopParameterVerifications(state);
                 await stopModelPreparations(state);
@@ -429,7 +433,9 @@ function defaultNativeAdapter(state) {
             workspaceUi: true,
             deliveryTools: deliveryToolHandlers(state),
             scheduledTaskProposals: scheduledTaskProposalHandler(state),
+            executionContext: executionContextToolHandler(state),
             productionSkill: proceduralSkillHandler(state),
+            levelEditorTasks: (source, intent) => registerLevelEditorRequest(state, source, intent),
             ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             ...(multi ? { loadMcpConfig: async (cwd) => {
                     const { workspaceId } = await workspaceContextFromRoot(state, cwd);