@playcraft/cli 0.1.66 → 0.1.68

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

@@ -1,23 +1,26 @@
+import { takesWorkspaceDirectory } from '@playcraft/common/cloud-workspace/runtime';
+import { assertNoPendingLevelEditorTransaction } from '../workspaces/level-editor-atomic.js';
 import { withObservedFile } from '../workspaces/revisions.js';
-import { revisionScope, sessionWorkspaceRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.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 { abandonTurnChanges, beginTurnChanges, finishTurnChanges, } from '../workspaces/turn-changes.js';
 import { shareWorkspaceGit } from '../workspaces/shared-git.js';
-import { cancelPendingDirectoryAccess, 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, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, hashOperationPayload, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, levelEditorTaskRequestSchema, levelEditorVerifyPayloadSchema, levelEditorTransactionRequestSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, isSoundDocumentPath, } 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';
 import { resolveWorkspaceAttachments } from '../workspaces/attachments.js';
-import { importWorkspaceRemixReference, RemixReferenceError } from '../workspaces/remix-references.js';
+import { importWorkspaceRemixReference, RemixReferenceError, } from '../workspaces/remix-references.js';
 import { ComposerContextError, resolveComposerContext } from '../workspaces/composer-context.js';
+import { workspaceAudioAssetService } from './audio-assets.js';
 import { ensureParameterInitializationSkill } from '../workspaces/parameter-initialization-skill.js';
 import { readWorkspaceSkillSnapshot, readWorkspaceSkills } from '../workspaces/skills.js';
-import { loadWorkspaceSkillArtifact, workspacePlatformSkillAccess } from '../workspaces/skill-artifact-loader.js';
-import { enableLocalProjectSkill, syncLocalProjectSkills } from '../../project-skills/local-store.js';
-import { importBuiltinProjectSkills, migrateVideoProjectSkills } from '../../project-skills/builtin-import.js';
+import { loadWorkspaceSkillArtifact, workspacePlatformSkillAccess, } from '../workspaces/skill-artifact-loader.js';
+import { enableLocalProjectSkill, syncLocalProjectSkills, } from '../../project-skills/local-store.js';
+import { importBuiltinProjectSkills, migrateVideoProjectSkills, } from '../../project-skills/builtin-import.js';
 import { NativePreparationError } from '../codex/native-adapter.js';
 import { workspaceUiSnapshotSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { disposeTerminalHost } from './terminal-host.js';
@@ -31,19 +34,23 @@ import { ThemeAssetIndexError } from '../workspaces/theme-asset-index.js';
 import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces/parameters.js';
 import { prepareParameterAgentTask, finishParameterAgentTask, verifyParameterAgentTask, } from '../workspaces/parameter-agent.js';
 import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPreviewPublish, } from '../previews/publish.js';
-import { startManagedBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
+import { startManagedBackgroundWriter, stopBackgroundWriter } from '../processes/managed-writes.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
 import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { trustedMemberPolicy } from '../batch/policy.js';
-import { BinaryWorkspaceWriteError, observeWorkspaceBinaryFile, writeWorkspaceBinaryFile } from '../workspaces/binary-write.js';
+import { BinaryWorkspaceWriteError, observeWorkspaceBinaryFile, writeWorkspaceBinaryFile, } from '../workspaces/binary-write.js';
 import { importWorkspaceLibraryAssets } from '../workspaces/asset-library-import.js';
-import { createWorkspaceDirectory, WorkspaceDirectoryCreateError } from '../workspaces/directory-create.js';
-import { DirectoryMutationError, mutateWorkspaceDirectory } from '../workspaces/directory-mutations.js';
+import { createWorkspaceDirectory, WorkspaceDirectoryCreateError, } from '../workspaces/directory-create.js';
+import { DirectoryMutationError, mutateWorkspaceDirectory, } from '../workspaces/directory-mutations.js';
 import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
 import { publishAssetTransfer } from '../workspaces/asset-transfer-publish.js';
 import { AssetTransferError } from '../workspaces/asset-transfer-storage.js';
-import { runModelPreviewBuild, cancelModelPreview, modelPreviewError } from '../workspaces/procedural-3d/model-preview-build.js';
+import { runModelPreviewBuild, cancelModelPreview, modelPreviewError, } from '../workspaces/procedural-3d/model-preview-build.js';
 import { runModelPreparation, trackModelPreparation } from '../workspaces/model-preparation.js';
+import { prepareLevelEditorTask, finishLevelEditorTask, verifyLevelEditorTask, } from '../workspaces/level-editor-agent.js';
+import { readWorkspaceLevelEditor, transactWorkspaceLevelEditor, reconcileWorkspaceLevelEditorTransaction, } from '../workspaces/level-editor.js';
+import { readLevelEditorHistory } from '../workspaces/level-editor-history-store.js';
+import { wakeLevelEditorRequests, ensureLevelEditorTaskPipeline, retryLevelEditorRequest, assertLevelEditorRetryInput, } from '../workspaces/level-editor-requests.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -75,6 +82,9 @@ const LOCAL_KINDS = new Set([
     'terminal.create',
     'parameter.patch',
     'parameter.verify',
+    'level-editor.request',
+    'level-editor.verify',
+    'level-editor.transaction',
     'preview.publish',
     'model.preview',
     'model.preview.cancel',
@@ -94,7 +104,7 @@ export async function stopParameterVerifications(state) {
 }
 export async function recoverInterruptedParameterVerifications(journal) {
     for (const { scopeKey, operation } of journal.listOperations()) {
-        if (operation.kind !== 'parameter.verify' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
+        if (!['parameter.verify', 'level-editor.verify'].includes(operation.kind) || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
             continue;
         if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
             continue;
@@ -116,9 +126,19 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
         if (operation.kind === 'session.turn' && !recovery && operation.sessionId &&
             state.journal.getSession(operation.sessionId)?.recoverability === 'history_only')
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'native_not_recoverable' }));
-        return withOperationDirectoryAccess(state, operation, () => {
+        return withOperationDirectoryAccess(state, operation, async () => {
             if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
                 return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: state.journal.destroyed() ? 'runtime_destroyed' : 'stale_lease' }));
+            if (takesWorkspaceDirectory(operation.kind) && operation.kind !== 'level-editor.transaction' && operation.kind !== 'runtime.destroy') {
+                // `root` is the workspace container, not a registered directory: resolving it must go
+                // through the session root, or every root-scoped operation fails before it starts.
+                try {
+                    await assertNoPendingLevelEditorTransaction(await sessionWorkspaceRoot(state, operation.workspaceId, operation.directoryName), { state, operation });
+                }
+                catch (error) {
+                    return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: levelEditorErrorCode(error) }));
+                }
+            }
             return executeScopedOperation(state, scopeKey, operation, payload, recovery);
         }, { operationId: operation.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}) });
     };
@@ -195,6 +215,23 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'parameter.verify') {
         return executeParameterVerify(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'level-editor.verify')
+        return executeLevelEditorVerify(state, scopeKey, current, payload);
+    if (operation.kind === 'level-editor.transaction')
+        return executeLevelEditorTransaction(state, scopeKey, current, payload);
+    if (operation.kind === 'level-editor.request') {
+        try {
+            const root = await workspaceRoot(state, current.workspaceId, current.directoryName);
+            const result = await retryLevelEditorRequest(state, current, payload, root);
+            const accepted = await persist(state, scopeKey, transitionOperation(current, 'accepted'));
+            const completed = await persist(state, scopeKey, transitionOperation(accepted, 'completed', { result }));
+            wakeLevelEditorRequests(state);
+            return completed;
+        }
+        catch (error) {
+            return persist(state, scopeKey, transitionOperation(current, 'failed', { error: levelEditorErrorCode(error) }));
+        }
+    }
     if (operation.kind === 'preview.publish') {
         return executePreviewPublish(state, scopeKey, current);
     }
@@ -399,11 +436,14 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     const parameterTask = parameterAgentTaskRequestSchema.optional().safeParse(body.parameterTask);
     if (!parameterTask.success || (parameterTask.data && parameterTask.data.taskId !== operation.clientRequestId))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_parameter_task' }));
-    if (parameterTask.data) {
+    const levelEditorTask = levelEditorTaskRequestSchema.optional().safeParse(body.levelEditorTask);
+    if (!levelEditorTask.success || levelEditorTask.data && (parameterTask.data || levelEditorTask.data.taskId !== operation.clientRequestId))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_level_editor_task' }));
+    if (parameterTask.data || levelEditorTask.data) {
         if (operation.directoryName === 'root')
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_directory' }));
         if ((selection.data.workMode ?? 'execute') !== 'execute' || requestedMode === 'read-only')
-            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_task_readonly' }));
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: levelEditorTask.data ? 'level_editor_task_requires_execute' : 'parameter_task_readonly' }));
         if (workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
         if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
@@ -439,7 +479,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         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))
+            (parameterTask.data || levelEditorTask.data ? 'exclusive' : policy.directoryAccessMode) !== operation.directoryAccessMode))
             throw new ComposerContextError('context_skills_changed');
     }
     catch (error) {
@@ -452,8 +492,8 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     let initializationSkill;
     try {
         let turnContext = selection.data.context;
-        if (parameterTask.data?.action === 'initialize') {
-            const selectedSkill = await ensureParameterInitializationSkill(root);
+        if (parameterTask.data?.action === 'initialize' || levelEditorTask.data) {
+            const selectedSkill = await ensureParameterInitializationSkill(root, levelEditorTask.data ? 'playcraft-level-editor' : 'playcraft-runtime-parameters', levelEditorTask.data ? { preserveExisting: true } : {});
             initializationSkill = { ...selectedSkill,
                 path: join(root, '.playcraft/skills', selectedSkill.lockHash, selectedSkill.entryKey, 'SKILL.md') };
             turnContext = { ...turnContext, files: turnContext?.files ?? [], skills: [
@@ -465,13 +505,16 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             directoryName: binding.directoryName ?? 'basic', context: turnContext,
             skillCache: join(state.config.stateDir, 'skill-artifacts'),
             loadSkillArtifact: entry => loadWorkspaceSkillArtifact(state, operation.workspaceId ?? 'workspace', entry),
+            ...(process.env.CLOUD_WORKSPACE_AUDIO_ASSETS_ENABLED === 'true' ? {
+                readAudioTarget: async (target) => (await workspaceAudioAssetService(state, operation.workspaceId, binding.directoryName ?? 'basic')).read(target),
+            } : {}),
         });
     }
     catch (error) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', {
-            error: error instanceof ComposerContextError ? error.message : parameterTask.data?.action === 'initialize'
+            error: error instanceof ComposerContextError ? error.message : parameterTask.data?.action === 'initialize' || levelEditorTask.data
                 ? error instanceof Error && /^(?:workspace_skills_|skills_revision_conflict$)/.test(error.message)
-                    ? error.message : parameterAgentError(error)
+                    ? error.message : levelEditorTask.data ? 'level_editor_skill_unavailable' : parameterAgentError(error)
                 : 'invalid_composer_context',
         }));
     }
@@ -489,14 +532,12 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         })).join('\n') : '';
     const batchContext = operation.directoryName === 'root' && operation.workspaceId
         ? `PlayCraft batch request context (trusted runtime identity): ${JSON.stringify({ workspaceId: operation.workspaceId,
-            clientRequestId: operation.clientRequestId, sourceDirectoryName: 'basic',
-            ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}\n\n`
+            clientRequestId: operation.clientRequestId, sourceDirectoryName: 'basic' })}\n\n`
         : '';
     const engineeringBatchContext = state.config.workspaceMode === 'multi' && operation.workspaceId
         && operation.directoryName !== 'root' && !productionSessionAttemptId(sessionId) && !trustedMemberPolicy(state, sessionId)
         ? `PlayCraft batch request context (trusted runtime identity): ${JSON.stringify({ workspaceId: operation.workspaceId,
-            clientRequestId: operation.clientRequestId, sourceDirectoryName: binding.directoryName ?? 'basic',
-            ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}`
+            clientRequestId: operation.clientRequestId, sourceDirectoryName: binding.directoryName ?? 'basic' })}`
         : '';
     if (state.config.workspaceMode === 'multi') {
         try {
@@ -516,6 +557,14 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: parameterAgentError(error) }));
         }
     }
+    if (levelEditorTask.data) {
+        try {
+            parameterInstructions = (await prepareLevelEditorTask(state, operation, levelEditorTask.data, root, initializationSkill)).instructions;
+        }
+        catch (error) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: levelEditorErrorCode(error) }));
+        }
+    }
     // Taken before the native turn exists, so nothing the agent writes can precede it.
     await beginTurnChanges(state, sessionId, {
         root, workspaceId: operation.workspaceId, directoryName: binding.directoryName ?? 'basic',
@@ -548,7 +597,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
                     permissionMode: selectedMode,
                     workMode: selection.data.workMode ?? 'execute',
                     context: composer.context,
-                    userText: selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data
+                    userText: selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data || levelEditorTask.data
                         ? String(body.userText ?? body.text ?? '') : undefined,
                     updatedAt: new Date().toISOString(),
                 });
@@ -569,7 +618,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         }
     }
     catch (error) {
-        if (!parameterTask.data)
+        if (!parameterTask.data && !levelEditorTask.data)
             throw error;
         abandonTurnChanges(state, sessionId);
         if (error instanceof NativePreparationError) {
@@ -631,7 +680,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         threadId: binding.threadId,
         turnId: result.turnId,
     });
-    if (selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data) {
+    if (selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data || levelEditorTask.data) {
         await recordNativeEvents(state, accepted, [{
                 type: 'composer.context', occurredAt: new Date().toISOString(), payload: {
                     threadId: binding.threadId, turnId: result.turnId, clientRequestId: operation.clientRequestId,
@@ -1168,6 +1217,8 @@ async function executeFileBinaryWrite(state, scopeKey, operation, payload) {
     if (!parsed.success)
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_binary_write' }));
     const input = parsed.data;
+    if (isSoundDocumentPath(input.path))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unsupported_audio_protocol' }));
     const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
     return state.journal.exclusive(`file:${scope ?? 'single'}:${input.path}`, async () => {
         try {
@@ -1211,6 +1262,8 @@ async function executeFileBinaryWrite(state, scopeKey, operation, payload) {
 }
 async function executeFileWrite(state, scopeKey, operation, payload) {
     const parsed = fileWritePayloadSchema.safeParse(payload);
+    if (parsed.success && isSoundDocumentPath(parsed.data.path))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unsupported_audio_protocol' }));
     if (!parsed.success) {
         const message = parsed.error.issues[0]?.message;
         const error = message === 'write_id_required' || message === 'write_hold_conflict' || message === 'background_write_unmanaged'
@@ -1438,6 +1491,172 @@ async function executeGitIndex(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: gitErrorCode(error) }));
     }
 }
+async function withLevelEditorDocuments(state, operation, paths, action) {
+    const observed = [...new Set(paths)].sort();
+    const run = (index) => index === observed.length
+        ? action()
+        : withObservedFile(state, operation.workspaceId, observed[index], () => run(index + 1), operation.directoryName);
+    return run(0);
+}
+async function executeLevelEditorTransaction(state, scopeKey, operation, payload) {
+    const parsed = levelEditorTransactionRequestSchema.safeParse(payload);
+    if (!parsed.success || parsed.data.requestId !== operation.clientRequestId)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_level_editor_transaction' }));
+    const request = parsed.data;
+    const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName), scope = revisionScope(state, operation.workspaceId, operation.directoryName);
+    const snapshot = await readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), {
+        state,
+        operation,
+    });
+    const ids = request.version === 1 ? [request.documentId] : Object.keys(request.expectedDocuments);
+    const paths = ids.map((id) => snapshot.definition?.documents[id]?.path);
+    if (paths.some((path) => !path) || !paths.length)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', {
+            error: snapshot.diagnostics[0]?.code ?? 'level_editor_not_ready',
+        }));
+    return withLevelEditorDocuments(state, operation, paths, async () => {
+        let applied = false;
+        try {
+            const written = await transactWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), request, { state, operation });
+            applied = true;
+            const files = written.results ?? [
+                { ...written, documentId: request.version === 1 ? request.documentId : '' },
+            ];
+            for (const file of files)
+                await state.journal.putFileRevision(file.path, { revision: file.revision, contentHash: file.contentHash }, scope);
+            const revision = Math.max(...files.map((file) => file.revision));
+            const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { expectedRevision: revision }));
+            await recordNativeEvents(state, accepted, files.map((file) => ({
+                type: 'file.written',
+                occurredAt: new Date().toISOString(),
+                payload: { ...file, editorId: request.editorId },
+            })));
+            return persist(state, scopeKey, transitionOperation(accepted, 'completed', {
+                expectedRevision: revision,
+                result: await readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), {
+                    state,
+                    operation,
+                }),
+            }));
+        }
+        catch (error) {
+            const code = applied ? 'level_editor_transaction_uncertain' : levelEditorErrorCode(error);
+            return persist(state, scopeKey, transitionOperation(operation, code === 'level_editor_transaction_uncertain' ? 'uncertain' : 'failed', { error: code }));
+        }
+    });
+}
+/** Private receipts prove completion; a marker can only resume the previously authorized exact batch. */
+export async function reconcileLevelEditorTransaction(state, scopeKey, operation, payload) {
+    if (operation.kind !== 'level-editor.transaction' ||
+        !['dispatched', 'accepted', 'uncertain'].includes(operation.status) ||
+        state.journal.destroyed())
+        return undefined;
+    const result = await state.journal.exclusive(`workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, () => withOperationDirectoryAccess(state, operation, async () => {
+        const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
+        const trusted = payload === undefined
+            ? await readLevelEditorHistory(root, { state, operation }, operation.clientRequestId)
+            : undefined;
+        const parsed = levelEditorTransactionRequestSchema.safeParse(payload ?? trusted?.request);
+        if (!parsed.success ||
+            parsed.data.requestId !== operation.clientRequestId ||
+            hashOperationPayload(parsed.data) !== operation.payloadHash)
+            return operation;
+        const request = parsed.data, scope = revisionScope(state, operation.workspaceId, operation.directoryName);
+        const initial = await readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), {
+            state,
+            operation,
+        });
+        const ids = request.version === 1 ? [request.documentId] : Object.keys(request.expectedDocuments);
+        const paths = ids.map((id) => initial.definition?.documents[id]?.path);
+        if (paths.some((path) => !path))
+            return operation;
+        return withLevelEditorDocuments(state, operation, paths, async () => {
+            const proof = await reconcileWorkspaceLevelEditorTransaction(root, state.journal.fileRevisions(scope), request, { state, operation });
+            if (!proof)
+                return operation;
+            const files = proof.results ?? [
+                {
+                    path: proof.path,
+                    contentHash: proof.contentHash,
+                    size: proof.size,
+                    revision: proof.revision,
+                    documentId: request.version === 1 ? request.documentId : '',
+                },
+            ];
+            for (const file of files) {
+                await state.journal.putFileRevision(file.path, { revision: file.revision, contentHash: file.contentHash }, scope);
+                const duplicate = state.journal.listEvents().some((event) => {
+                    const body = asRecord(event.payload);
+                    return (body.operationId === operation.operationId &&
+                        event.type === 'file.written' &&
+                        body.contentHash === file.contentHash &&
+                        body.revision === file.revision &&
+                        body.documentId === file.documentId);
+                });
+                if (!duplicate)
+                    await recordNativeEvents(state, operation, [
+                        {
+                            type: 'file.written',
+                            occurredAt: new Date().toISOString(),
+                            payload: { ...file, editorId: request.editorId },
+                        },
+                    ]);
+            }
+            const current = operation.status === 'dispatched'
+                ? transitionOperation(operation, 'accepted')
+                : operation;
+            return persist(state, scopeKey, transitionOperation(current, 'completed', {
+                expectedRevision: Math.max(...files.map((file) => file.revision)),
+                result: proof.snapshot,
+                error: undefined,
+            }));
+        });
+    }));
+    return result.status === 'completed' ? result : undefined;
+}
+async function executeLevelEditorVerify(state, scopeKey, operation, payload) {
+    const parsed = levelEditorVerifyPayloadSchema.safeParse(payload);
+    if (!parsed.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_level_editor_task' }));
+    if (operation.directoryName === 'root' || workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
+    if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
+    const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    const controller = new AbortController();
+    const assertActive = () => {
+        if (controller.signal.aborted ||
+            parameterVerificationClosing.has(state) ||
+            state.journal.destroyed())
+            throw new Error('level_editor_verification_interrupted');
+        if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence)
+            throw new Error('stale_lease');
+    };
+    const key = `workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`;
+    const task = state.journal.exclusive(key, async () => {
+        try {
+            await assertLevelEditorRetryInput(state, operation, parsed.data, root);
+            const result = await verifyLevelEditorTask(state, operation, parsed.data, root, {
+                assertActive,
+                signal: controller.signal,
+            });
+            assertActive();
+            await persist(state, scopeKey, transitionOperation(accepted, 'completed', { result }));
+        }
+        catch (error) {
+            await persist(state, scopeKey, transitionOperation(accepted, 'failed', { error: levelEditorErrorCode(error) }));
+        }
+    });
+    const tasks = parameterVerifications.get(state) ?? new Map();
+    parameterVerifications.set(state, tasks);
+    const tracked = task.catch(() => undefined).finally(() => tasks.delete(controller));
+    tasks.set(controller, tracked);
+    return accepted;
+}
+function levelEditorErrorCode(error) {
+    return error instanceof Error && /^(?:level_editor_|invalid_level_editor_|revision_conflict|stale_lease|runtime_destroyed)/.test(error.message) ? error.message : 'level_editor_operation_failed';
+}
 async function executeParameterPatch(state, scopeKey, operation, payload) {
     const parsed = parameterPatchPayloadSchema.safeParse(payload);
     if (!parsed.success) {
@@ -1729,6 +1948,10 @@ async function syncParameterAgentOperation(state, operation) {
         return;
     if (operation.status === 'completed' || operation.status === 'failed' || operation.status === 'interrupted' || operation.status === 'uncertain') {
         await finishParameterAgentTask(state, operation, operation.status, operation.error);
+        await finishLevelEditorTask(state, operation, operation.status, operation.error);
+        if (operation.status === 'completed' && /^[a-f0-9-]{36}$/i.test(operation.clientRequestId))
+            await ensureLevelEditorTaskPipeline(state, operation);
+        wakeLevelEditorRequests(state);
     }
 }
 function native(state) {

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

@@ -1,3 +1,4 @@
+import { hasPendingLevelEditorTransaction, assertNoPendingLevelEditorTransaction } from '../workspaces/level-editor-atomic.js';
 import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
 import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
 import { registerWorkspace, revisionScope, sessionWorkspaceRoot, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
@@ -11,6 +12,9 @@ import { InvalidWorkspacePathError, } from '../workspaces/files.js';
 import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWorkspaceGitGraph, readWorkspaceGitStatus, } from '../workspaces/git.js';
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
 import { listParameterAgentTasks } from '../workspaces/parameter-agent.js';
+import { readWorkspaceLevelEditor } from '../workspaces/level-editor.js';
+import { listLevelEditorTasks } from '../workspaces/level-editor-agent.js';
+import { listLevelEditorRequests } from '../workspaces/level-editor-requests.js';
 import { readDependencies } from '../workspaces/dependencies.js';
 import { permissionDriftFromError } from '../workspaces/workspace-shares.js';
 import { desktopHost, desktopRoute } from './desktop-host.js';
@@ -36,7 +40,7 @@ import { probeRuntimeConnectivity } from './connectivity.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
 import { WorkspaceArtifactStore } from '../workspaces/artifacts.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
-import { acceptOperationCore } from './accept-operation.js';
+import { acceptOperationCore, observeLevelEditorTransaction } from './accept-operation.js';
 import { workspaceArtifactContentQuerySchema } from '@playcraft/common/cloud-workspace/runtime';
 import { searchWorkspaceFiles } from '../workspaces/files-search.js';
 import { serveWorkspaceArchive } from '../workspaces/archive.js';
@@ -50,11 +54,43 @@ 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';
 import { readModelPreparation } from '../workspaces/model-preparation.js';
+import { serveAudioExport } from './audio-export.js';
+import { handleAudioAssetRequest } from './audio-assets.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');
+    const protectedRead = ['/runtime/level-editor', '/runtime/parameters', '/runtime/file', '/runtime/files', '/runtime/files/search', '/runtime/file-content', '/runtime/archive', '/runtime/git-bundle', '/runtime/git/status', '/runtime/git/diff', '/runtime/audio/assets', '/runtime/audio/content'].includes(url.pathname) && ['GET', 'HEAD'].includes(request.method ?? 'GET');
+    if (authorizeRuntime(state, request) === 'control' && protectedRead) {
+        try {
+            const directoryName = url.searchParams.get('directoryName') ?? 'basic';
+            const readContext = { state, workspaceId: workspaceId ?? undefined, directoryName };
+            const root = await workspaceRoot(state, readContext.workspaceId, directoryName);
+            if (await hasPendingLevelEditorTransaction(root, readContext)) {
+                // A retained writer owns the exclusive lease. Reconcile that exact operation before admitting a reader.
+                for (const { operation } of state.journal.listOperations())
+                    if (operation.kind === 'level-editor.transaction' && (state.config.workspaceMode !== 'multi' || operation.workspaceId === readContext.workspaceId) && (operation.directoryName ?? 'basic') === directoryName)
+                        await observeLevelEditorTransaction(state, operation);
+            }
+            const recovering = await hasPendingLevelEditorTransaction(root, readContext);
+            return await withDirectoryWrite(state, { ...readContext, mode: recovering ? 'exclusive' : 'shared', wait: false }, async () => {
+                if (recovering) {
+                    const snapshot = await readWorkspaceLevelEditor(root, state.journal.fileRevisions(revisionScope(state, readContext.workspaceId, directoryName)), readContext);
+                    if (snapshot.status === 'invalid' && snapshot.diagnostics.some(item => /recovery|history/.test(item.code)))
+                        throw new Error(snapshot.diagnostics[0].code);
+                }
+                await assertNoPendingLevelEditorTransaction(root, readContext);
+                return dispatchRuntimeRequest(state, request, response);
+            });
+        }
+        catch (error) {
+            if (!response.headersSent)
+                writeJson(response, 409, { error: error instanceof Error ? error.message : 'level_editor_recovery_required' });
+            return;
+        }
+    }
     // Body-scoped operations, members and terminal control take their own lifetime-aware leases.
     const ownLease = url.pathname.startsWith('/runtime/operations') || url.pathname.startsWith('/runtime/terminals/') ||
+        url.pathname === '/runtime/audio/export' ||
         url.pathname.startsWith('/runtime/batch-') || /^\/runtime\/sessions\/[^/]+\/ui-results$/.test(url.pathname) ||
         /^\/runtime\/sessions\/[^/]+\/prediction$/.test(url.pathname);
     if (authorizeRuntime(state, request) === 'control' && workspaceId &&
@@ -87,6 +123,15 @@ async function dispatchRuntimeRequest(state, request, response) {
         return;
     }
     try {
+        if (request.method === 'POST' && url.pathname === '/runtime/audio/export') {
+            if (writeDestroyed(state, response))
+                return;
+            await sessionWorkspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined, directoryName);
+            await serveAudioExport(request, response, url);
+            return;
+        }
+        if (await handleAudioAssetRequest(state, request, response, url))
+            return;
         if (await handleWorkspaceStorage(state, request, response, url))
             return;
         const transfer = await handleAssetTransferRequest(state, request, url);
@@ -135,6 +180,10 @@ async function dispatchRuntimeRequest(state, request, response) {
                 instanceToken: state.instanceToken,
                 permissionsVersion: 1,
                 composerContextVersion: 1,
+                audioAssetVersion: 1,
+                audioContextVersion: 1,
+                audioScoreVersion: 1,
+                audioScoreContextVersion: 1,
                 scheduledTaskIdentityVersion: 1,
                 scheduledTaskCancellationVersion: 1,
                 ...(state.native?.scheduledTaskProposalSource ? { scheduledTaskProposalVersion: 1 } : {}),
@@ -142,6 +191,12 @@ async function dispatchRuntimeRequest(state, request, response) {
                 directoryConcurrencyVersion: 1,
                 skillExecutionPolicyVersion: 1,
                 parameterInitializationVersion: 1,
+                levelEditorVersion: 1,
+                levelEditorTaskVersion: 1,
+                levelEditorHistoryVersion: 1,
+                levelEditorTransactionVersion: 2,
+                levelEditorExtensionVersion: 1,
+                levelEditorRetryVersion: 1,
                 remixReferencesVersion: 1,
                 batchSourceFreezeRevision: 2,
                 ...(state.native?.workspaceUi ? { workspaceUiVersion: 1 } : {}),
@@ -789,6 +844,44 @@ async function dispatchRuntimeRequest(state, request, response) {
             await writeGitRead(state, response, async () => readWorkspaceGitGraph(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined, directoryName)));
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/level-editor') {
+            if (writeDestroyed(state, response))
+                return;
+            if (directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace_directory' });
+                return;
+            }
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            const root = await workspaceRoot(state, workspaceId, directoryName), scope = revisionScope(state, workspaceId, directoryName);
+            const first = await readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), { state, workspaceId, directoryName });
+            for (const document of Object.values(first.definition?.documents ?? {}))
+                await withObservedFile(state, workspaceId, document.path, async () => undefined, directoryName);
+            writeJson(response, 200, await readWorkspaceLevelEditor(root, state.journal.fileRevisions(scope), { state, workspaceId, directoryName }));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/level-editor/tasks') {
+            if (writeDestroyed(state, response))
+                return;
+            if (directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace_directory' });
+                return;
+            }
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            writeJson(response, 200, { tasks: await listLevelEditorTasks(state, workspaceId, directoryName, await workspaceRoot(state, workspaceId, directoryName)) });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/level-editor/requests') {
+            if (writeDestroyed(state, response))
+                return;
+            if (directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace_directory' });
+                return;
+            }
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            await workspaceRoot(state, workspaceId, directoryName);
+            writeJson(response, 200, { requests: await listLevelEditorRequests(state, workspaceId, directoryName) });
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/parameters') {
             if (writeDestroyed(state, response))
                 return;
@@ -839,7 +932,8 @@ async function dispatchRuntimeRequest(state, request, response) {
                 directoryName,
                 sessionId: url.searchParams.get('sessionId') ?? undefined,
             }));
-            writeJson(response, operation ? 200 : 404, operation ?? { error: 'operation_not_found' });
+            const observed = operation ? await observeLevelEditorTransaction(state, operation) : undefined;
+            writeJson(response, observed ? 200 : 404, observed ?? { error: 'operation_not_found' });
             return;
         }
         const operationLog = /^\/runtime\/operations\/([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})\/log$/.exec(url.pathname);
@@ -873,7 +967,7 @@ async function dispatchRuntimeRequest(state, request, response) {
                 writeJson(response, 404, { error: 'operation_not_found' });
                 return;
             }
-            writeJson(response, 200, operation);
+            writeJson(response, 200, await observeLevelEditorTransaction(state, operation));
             return;
         }
         if (request.method === 'POST' && url.pathname === '/runtime/scheduled-task-proposals/source') {

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

@@ -11,7 +11,7 @@ export function buildOperationRecord(state, parsed, payloadHash, leaseFence, exe
         ...(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' } : {}),
+        ...(parsed.kind === 'session.turn' && (payload.parameterTask !== undefined || payload.levelEditorTask !== undefined) ? { directoryAccessMode: 'exclusive' } : {}),
         environment: state.config.environment,
         userId: state.config.userId,
         clientRequestId: parsed.clientRequestId,