@playcraft/cli 0.1.66 → 0.1.67

package/dist/workspace-runtime/workspaces/level-editor-requests.js

@@ -0,0 +1,724 @@
+import { mkdir, readdir, readFile, rename, writeFile, lstat, realpath } from 'node:fs/promises';
+import { join, resolve, relative, sep, isAbsolute } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { platformEndpoint, hashOperationPayload, levelEditorCanonicalJson, levelEditorRetryPayloadSchema, levelEditorRequestRecordSchema, levelEditorTaskReportSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceContextFromRoot, workspaceRoot } from './registry.js';
+import { levelEditorDigest, readLevelEditorFile, readWorkspaceLevelEditor, } from './level-editor.js';
+import { readPrivateLevelEditorTask } from './level-editor-agent-store.js';
+const recordSchema = z
+    .object({
+    action: z.enum(['initialize', 'evolve', 'repair']),
+    goal: z.string().min(1).max(4000),
+    editorId: z.string().optional(),
+    version: z.literal(1),
+    requestId: z.string().uuid(),
+    taskId: z.string().uuid(),
+    workspaceId: z.string(),
+    directoryName: z.string(),
+    sourceOperationId: z.string(),
+    sourceSessionId: z.string(),
+    sourceThreadId: z.string(),
+    sourceTurnId: z.string(),
+    toolCallId: z.string(),
+    generation: z.number(),
+    runtimeEpoch: z.number(),
+    status: z.enum([
+        'requested',
+        'queued',
+        'dispatched',
+        'failed',
+        'stale',
+        'uncertain',
+        'cancelled',
+    ]),
+    operationId: z.string().optional(),
+    stage: z.enum(['generate', 'verify', 'preview', 'complete']).default('generate'),
+    taskOperationId: z.string().optional(),
+    verifyOperationId: z.string().optional(),
+    previewOperationId: z.string().optional(),
+    attemptId: z.string().uuid().optional(),
+    retryOfRequestId: z.string().uuid().optional(),
+    retryStage: z.enum(['verify', 'preview']).optional(),
+    failedStage: z.enum(['generate', 'verify', 'preview']).optional(),
+    retryableStage: z.enum(['verify', 'preview']).optional(),
+    verifyClientRequestId: z.string().optional(),
+    retryInputHash: z.string().optional(),
+    retryPayloadHash: z.string().optional(),
+    expectedSourceFingerprint: z.string().optional(),
+    expectedDefinitionHash: z.string().optional(),
+    expectedDocumentHashes: z.record(z.string(), z.string()).optional(),
+    error: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .strict();
+const loops = new WeakMap();
+function stableId(value) { const text = levelEditorDigest(value); return `${text.slice(0, 8)}-${text.slice(8, 12)}-4${text.slice(13, 16)}-8${text.slice(17, 20)}-${text.slice(20, 32)}`; }
+async function directory(state) {
+    const path = resolve(state.config.stateDir, 'level-editor-requests');
+    // private
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    if ((await lstat(path)).isSymbolicLink())
+        throw new Error('level_editor_state_invalid');
+    const actual = await realpath(path), rel = relative(await realpath(state.config.workspaceRoot), actual);
+    if (rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)))
+        throw new Error('level_editor_state_not_private');
+    return actual;
+}
+async function write(state, record) {
+    const folder = await directory(state), temporary = join(folder, `.${randomUUID()}.tmp`);
+    const serialized = JSON.stringify(recordSchema.parse(record));
+    if (Buffer.byteLength(serialized) > 32 * 1024)
+        throw new Error('level_editor_request_budget');
+    // private
+    await writeFile(temporary, serialized, { mode: 0o600 });
+    await rename(temporary, join(folder, `${record.requestId}.json`));
+}
+export async function listLevelEditorRequests(state, workspaceId, directoryName) {
+    const folder = await directory(state), names = (await readdir(folder)).filter((name) => /^[a-f0-9-]{36}\.json$/.test(name));
+    if (names.length > 256)
+        throw new Error('level_editor_request_limit');
+    const records = [];
+    for (const name of names) {
+        const path = join(folder, name), stat = await lstat(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 32 * 1024)
+            throw new Error('level_editor_state_invalid');
+        const record = recordSchema.parse(JSON.parse(await readFile(path, 'utf8')));
+        if ((!workspaceId || record.workspaceId === workspaceId) &&
+            (!directoryName || record.directoryName === directoryName)) {
+            const failedStage = failureStage(state, record);
+            records.push({
+                ...record,
+                failedStage,
+                retryableStage: record.status === 'failed' && (failedStage === 'verify' || failedStage === 'preview')
+                    ? failedStage
+                    : undefined,
+            });
+        }
+    }
+    const superseded = new Set(records.map((item) => item.retryOfRequestId).filter(Boolean));
+    return records
+        .map((item) => (superseded.has(item.requestId) ? { ...item, retryableStage: undefined } : item))
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+function failureStage(state, record) {
+    if (record.error?.startsWith('level_editor_local_operation_'))
+        return undefined;
+    if (record.status !== 'failed')
+        return record.failedStage;
+    if (record.failedStage)
+        return record.failedStage;
+    if (record.stage === 'verify')
+        return localStageOperation(state, record, 'generate').operation?.status === 'completed'
+            ? 'verify'
+            : 'generate';
+    if (record.stage === 'preview') {
+        const prior = localStageOperation(state, record, 'verify').operation;
+        const result = prior?.result;
+        return prior?.status === 'completed' && result?.status === 'verified' ? 'preview' : 'verify';
+    }
+    return record.stage === 'generate' ? 'generate' : undefined;
+}
+async function retryInput(state, record, root, allowOwnCheck = false) {
+    const task = await readPrivateLevelEditorTask(state, record.workspaceId, record.directoryName, record.taskId, root);
+    if (!task ||
+        task.record.sessionId !== record.sourceSessionId ||
+        task.record.generation !== record.generation ||
+        task.record.runtimeEpoch !== record.runtimeEpoch ||
+        ['running', 'uncertain', 'interrupted', 'stale', 'invalid'].includes(task.record.status) ||
+        (task.record.status === 'checking' && !allowOwnCheck))
+        throw new Error('level_editor_retry_task_unavailable');
+    const snapshot = await readWorkspaceLevelEditor(root, state.journal.fileRevisions?.() ?? {}, { state, workspaceId: record.workspaceId, directoryName: record.directoryName });
+    if (snapshot.status !== 'ready' ||
+        snapshot.sourceFingerprint !== record.expectedSourceFingerprint ||
+        snapshot.definitionHash !== record.expectedDefinitionHash ||
+        levelEditorCanonicalJson(snapshot.documentHashes) !==
+            levelEditorCanonicalJson(record.expectedDocumentHashes))
+        throw new Error('level_editor_retry_inputs_changed');
+    const reportBytes = await readLevelEditorFile(root, task.record.reportPath);
+    const report = levelEditorTaskReportSchema.parse(JSON.parse(reportBytes.toString('utf8')));
+    if (report.taskId !== record.taskId || report.missing.length)
+        throw new Error('level_editor_retry_report_invalid');
+    let size = reportBytes.length;
+    const sources = [];
+    for (const source of report.sources) {
+        const bytes = await readLevelEditorFile(root, source.path);
+        size += bytes.length;
+        if (size > 32 * 1024 * 1024 || levelEditorDigest(bytes) !== source.sha256)
+            throw new Error('level_editor_retry_inputs_changed');
+        sources.push([source.path, source.sha256]);
+    }
+    return {
+        task,
+        hash: levelEditorDigest(levelEditorCanonicalJson({
+            sourceFingerprint: snapshot.sourceFingerprint,
+            definitionHash: snapshot.definitionHash,
+            documentHashes: snapshot.documentHashes,
+            reportHash: levelEditorDigest(reportBytes),
+            sources: sources.sort(),
+        })),
+    };
+}
+/** A new explicit attempt owns a new record; the failed request and its operation receipts remain immutable. */
+export async function retryLevelEditorRequest(state, operation, value, root) {
+    const input = levelEditorRetryPayloadSchema.parse(value), payloadHash = levelEditorDigest(levelEditorCanonicalJson(input));
+    if (operation.kind !== 'level-editor.request' ||
+        operation.clientRequestId !== input.attemptId ||
+        operation.sessionId ||
+        operation.environment !== state.config.environment ||
+        operation.userId !== state.config.userId ||
+        operation.generation !== state.config.generation ||
+        operation.runtimeEpoch !== state.runtimeEpoch)
+        throw new Error('level_editor_retry_scope_invalid');
+    return state.journal.exclusive('level-editor-request-store', async () => {
+        const records = await listLevelEditorRequests(state);
+        const previous = records.find((item) => item.requestId === input.attemptId);
+        if (previous) {
+            if (previous.workspaceId !== operation.workspaceId ||
+                previous.directoryName !== (operation.directoryName ?? 'basic') ||
+                previous.retryPayloadHash !== payloadHash)
+                throw new Error('level_editor_retry_conflict');
+            return levelEditorRequestRecordSchema.parse(previous);
+        }
+        const parent = records.find((item) => item.requestId === input.requestId);
+        if (!parent ||
+            parent.workspaceId !== operation.workspaceId ||
+            parent.directoryName !== (operation.directoryName ?? 'basic') ||
+            parent.generation !== state.config.generation ||
+            parent.runtimeEpoch !== state.runtimeEpoch ||
+            parent.status !== 'failed' ||
+            failureStage(state, parent) !== input.stage)
+            throw new Error('level_editor_retry_unavailable');
+        if (records.some((item) => item.retryOfRequestId === parent.requestId))
+            throw new Error('level_editor_retry_superseded');
+        if (records.length >= 256)
+            throw new Error('level_editor_request_limit');
+        if (records.some((item) => item.taskId === parent.taskId &&
+            (['requested', 'queued', 'uncertain'].includes(item.status) ||
+                (item.status === 'dispatched' && item.stage !== 'complete'))))
+            throw new Error('level_editor_retry_busy');
+        const source = state.journal.getOperationById(parent.sourceOperationId);
+        if (!source ||
+            source.kind !== 'session.turn' ||
+            source.environment !== state.config.environment ||
+            source.userId !== state.config.userId ||
+            source.generation !== parent.generation ||
+            source.runtimeEpoch !== parent.runtimeEpoch ||
+            source.status !== 'completed' ||
+            source.sessionId !== parent.sourceSessionId ||
+            source.nativeThreadId !== parent.sourceThreadId ||
+            source.nativeTurnId !== parent.sourceTurnId ||
+            source.workspaceId !== parent.workspaceId ||
+            (source.directoryName ?? 'basic') !== parent.directoryName)
+            throw new Error('level_editor_retry_source_invalid');
+        const generation = localStageOperation(state, parent, 'generate');
+        if (generation.error || generation.operation?.status !== 'completed')
+            throw new Error('level_editor_retry_generation_unconfirmed');
+        const now = new Date().toISOString();
+        const candidate = {
+            ...parent,
+            ...input,
+            requestId: input.attemptId,
+            retryOfRequestId: input.requestId,
+            retryStage: input.stage,
+            stage: input.stage,
+            status: 'queued',
+            failedStage: undefined,
+            retryableStage: undefined,
+            error: undefined,
+            operationId: undefined,
+            previewOperationId: undefined,
+            taskOperationId: generation.operation.operationId,
+            verifyOperationId: input.stage === 'preview' ? parent.verifyOperationId : undefined,
+            verifyClientRequestId: input.stage === 'verify'
+                ? `${parent.taskId}:verify:${input.attemptId}`
+                : (parent.verifyClientRequestId ?? `${parent.taskId}:verify`),
+            retryPayloadHash: payloadHash,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const frozen = await retryInput(state, candidate, root);
+        if (input.stage === 'preview') {
+            const prior = localStageOperation(state, parent, 'verify');
+            if (prior.error ||
+                prior.operation?.status !== 'completed' ||
+                frozen.task.record.status !== 'verified' ||
+                !frozen.task.record.sourceDigest)
+                throw new Error('level_editor_retry_verification_required');
+        }
+        candidate.retryInputHash = frozen.hash;
+        await write(state, candidate);
+        wakeLevelEditorRequests(state);
+        return levelEditorRequestRecordSchema.parse(candidate);
+    });
+}
+/** Recheck the frozen retry input while the normal verification directory lease is held. */
+export async function assertLevelEditorRetryInput(state, operation, value, root) {
+    const retryRequestId = value?.retryRequestId;
+    if (!retryRequestId)
+        return;
+    const record = (await listLevelEditorRequests(state)).find((item) => item.requestId === retryRequestId);
+    if (!record ||
+        operation.kind !== 'level-editor.verify' ||
+        operation.sessionId ||
+        operation.environment !== state.config.environment ||
+        operation.userId !== state.config.userId ||
+        record.retryStage !== 'verify' ||
+        record.workspaceId !== operation.workspaceId ||
+        record.directoryName !== (operation.directoryName ?? 'basic') ||
+        operation.clientRequestId !== record.verifyClientRequestId ||
+        record.generation !== state.config.generation ||
+        record.runtimeEpoch !== state.runtimeEpoch ||
+        value.taskId !== record.taskId ||
+        !['queued', 'dispatched'].includes(record.status))
+        throw new Error('level_editor_retry_scope_invalid');
+    if ((await retryInput(state, record, root)).hash !== record.retryInputHash)
+        throw new Error('level_editor_retry_inputs_changed');
+}
+/** Prove only that this control request registered its exact durable child; never execute it again. */
+export async function reconcileLevelEditorRetryRequest(state, operation) {
+    if (operation.kind !== 'level-editor.request' ||
+        !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status) ||
+        operation.sessionId ||
+        operation.environment !== state.config.environment ||
+        operation.userId !== state.config.userId ||
+        operation.generation !== state.config.generation ||
+        operation.runtimeEpoch !== state.runtimeEpoch ||
+        state.journal.destroyed())
+        return undefined;
+    const records = await listLevelEditorRequests(state);
+    const children = records.filter((item) => item.requestId === operation.clientRequestId && item.attemptId === operation.clientRequestId);
+    const child = children.length === 1 ? children[0] : undefined;
+    if (!child ||
+        child.workspaceId !== operation.workspaceId ||
+        child.directoryName !== (operation.directoryName ?? 'basic') ||
+        child.generation !== operation.generation ||
+        child.runtimeEpoch !== operation.runtimeEpoch ||
+        !child.retryOfRequestId ||
+        !/^[a-f0-9]{64}$/.test(child.retryInputHash ?? ''))
+        return undefined;
+    const reconstructed = levelEditorRetryPayloadSchema.safeParse({
+        version: 1,
+        requestId: child.retryOfRequestId,
+        attemptId: child.attemptId,
+        stage: child.retryStage,
+        expectedSourceFingerprint: child.expectedSourceFingerprint,
+        expectedDefinitionHash: child.expectedDefinitionHash,
+        expectedDocumentHashes: child.expectedDocumentHashes,
+    });
+    if (!reconstructed.success ||
+        hashOperationPayload(reconstructed.data) !== operation.payloadHash ||
+        levelEditorDigest(levelEditorCanonicalJson(reconstructed.data)) !== child.retryPayloadHash)
+        return undefined;
+    const parents = records.filter((item) => item.requestId === child.retryOfRequestId);
+    const parent = parents.length === 1 ? parents[0] : undefined;
+    const fields = [
+        'workspaceId',
+        'directoryName',
+        'taskId',
+        'sourceOperationId',
+        'sourceSessionId',
+        'sourceThreadId',
+        'sourceTurnId',
+        'toolCallId',
+        'generation',
+        'runtimeEpoch',
+        'action',
+        'goal',
+        'editorId',
+    ];
+    if (!parent || parent.status !== 'failed' || fields.some((key) => parent[key] !== child[key]))
+        return undefined;
+    const generated = localStageOperation(state, child, 'generate');
+    if (generated.error || generated.operation?.status !== 'completed')
+        return undefined;
+    const source = state.journal.getOperationById(child.sourceOperationId);
+    if (!source ||
+        source.kind !== 'session.turn' ||
+        source.status !== 'completed' ||
+        source.environment !== operation.environment ||
+        source.userId !== operation.userId ||
+        source.workspaceId !== operation.workspaceId ||
+        (source.directoryName ?? 'basic') !== child.directoryName ||
+        source.sessionId !== child.sourceSessionId ||
+        source.nativeThreadId !== child.sourceThreadId ||
+        source.nativeTurnId !== child.sourceTurnId ||
+        source.generation !== child.generation ||
+        source.runtimeEpoch !== child.runtimeEpoch)
+        return undefined;
+    return levelEditorRequestRecordSchema.parse(child);
+}
+/** The source is supplied by the native tool closure, never by generated tool arguments. */
+export async function registerLevelEditorRequest(state, source, intent) {
+    const context = await workspaceContextFromRoot(state, await realpath(source.cwd));
+    if (context.directoryName === 'root')
+        throw new Error('level_editor_scope_invalid');
+    let operation = state.journal
+        .listOperations()
+        .map((item) => item.operation)
+        .find((item) => item.kind === 'session.turn' &&
+        item.sessionId === source.sessionId &&
+        item.nativeThreadId === source.threadId &&
+        item.nativeTurnId === source.turnId);
+    for (let attempt = 0; !operation && attempt < 20; attempt++) {
+        await new Promise((done) => setTimeout(done, 25));
+        operation = state.journal
+            .listOperations()
+            .map((item) => item.operation)
+            .find((item) => item.kind === 'session.turn' &&
+            item.sessionId === source.sessionId &&
+            item.nativeThreadId === source.threadId &&
+            item.nativeTurnId === source.turnId);
+    }
+    if (!operation ||
+        !['dispatched', 'accepted'].includes(operation.status) ||
+        operation.workspaceId !== context.workspaceId ||
+        (operation.directoryName ?? 'basic') !== context.directoryName ||
+        operation.workMode === 'plan' ||
+        operation.permissionMode === 'read-only')
+        throw new Error('level_editor_source_unavailable');
+    if (/^[a-f0-9-]{36}$/i.test(operation.clientRequestId) &&
+        (await readPrivateLevelEditorTask(state, context.workspaceId, context.directoryName, operation.clientRequestId)))
+        throw new Error('level_editor_managed_task_already_active');
+    return state.journal.exclusive('level-editor-request-store', async () => {
+        const records = await listLevelEditorRequests(state), key = JSON.stringify([
+            context.workspaceId,
+            context.directoryName,
+            operation.operationId,
+            intent.editorId ?? '',
+            intent.action,
+        ]);
+        const requestId = stableId(key), previous = records.find((item) => item.requestId === requestId);
+        if (previous) {
+            if (previous.goal !== intent.goal ||
+                previous.action !== intent.action ||
+                previous.editorId !== intent.editorId)
+                throw new Error('level_editor_request_conflict');
+            return { requestId, taskId: previous.taskId, status: previous.status };
+        }
+        if (records.length >= 256)
+            throw new Error('level_editor_request_limit');
+        const timestamp = new Date().toISOString();
+        const record = {
+            version: 1,
+            ...intent,
+            requestId,
+            taskId: stableId(`${key}:task`),
+            ...context,
+            sourceOperationId: operation.operationId,
+            sourceSessionId: source.sessionId,
+            sourceThreadId: source.threadId,
+            sourceTurnId: source.turnId,
+            toolCallId: source.toolCallId,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            status: 'requested',
+            stage: 'generate',
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        await write(state, record);
+        wakeLevelEditorRequests(state);
+        return {
+            requestId,
+            taskId: record.taskId,
+            status: record.status, message: 'The managed initialization starts after this turn completes normally. Do not initialize it again in this turn.',
+        };
+    });
+}
+/** Panel tasks use the same durable post-generation pipeline, without a second generated turn. */
+export async function ensureLevelEditorTaskPipeline(state, operation) {
+    if (operation.kind !== 'session.turn' ||
+        operation.status !== 'completed' ||
+        !operation.sessionId ||
+        !operation.workspaceId ||
+        !operation.nativeThreadId ||
+        !operation.nativeTurnId)
+        return;
+    const task = await readPrivateLevelEditorTask(state, operation.workspaceId, operation.directoryName ?? 'basic', operation.clientRequestId);
+    if (!task)
+        return;
+    await state.journal.exclusive('level-editor-request-store', async () => {
+        const records = await listLevelEditorRequests(state);
+        if (records.some((item) => item.taskId === task.record.taskId))
+            return;
+        const timestamp = new Date().toISOString();
+        await write(state, {
+            version: 1,
+            action: task.request.action,
+            goal: task.request.goal ?? 'Initialize the project level editor',
+            ...(task.request.editorId ? { editorId: task.request.editorId } : {}),
+            requestId: stableId(`${task.record.taskId}:pipeline`),
+            taskId: task.record.taskId,
+            workspaceId: operation.workspaceId,
+            directoryName: operation.directoryName ?? 'basic',
+            sourceOperationId: operation.operationId,
+            sourceSessionId: operation.sessionId,
+            sourceThreadId: operation.nativeThreadId,
+            sourceTurnId: operation.nativeTurnId,
+            toolCallId: 'panel-initialization',
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            status: 'dispatched',
+            stage: 'verify',
+            taskOperationId: operation.operationId,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        });
+    });
+    wakeLevelEditorRequests(state);
+}
+/** Durable control queue; no engineering directory lease is acquired by request registration. */
+export function startLevelEditorRequestQueue(state) {
+    if (loops.has(state))
+        return;
+    const loop = {
+        running: false,
+        closed: false,
+        controller: new AbortController(),
+        timer: setInterval(() => wakeLevelEditorRequests(state), 2_000),
+        unsubscribe: undefined,
+    };
+    loop.timer.unref?.();
+    loops.set(state, loop);
+    loop.unsubscribe = state.journal.onChange(() => wakeLevelEditorRequests(state));
+    wakeLevelEditorRequests(state);
+}
+export function stopLevelEditorRequestQueue(state) {
+    const loop = loops.get(state);
+    if (!loop)
+        return;
+    loop.closed = true;
+    loop.controller.abort();
+    clearInterval(loop.timer);
+    loop.unsubscribe?.();
+    loops.delete(state);
+}
+export function wakeLevelEditorRequests(state) {
+    const loop = loops.get(state);
+    if (!loop || loop.closed || loop.running)
+        return;
+    loop.running = true;
+    setTimeout(() => {
+        void drain(state)
+            .catch(() => undefined)
+            .finally(() => {
+            loop.running = false;
+        });
+    }, 0).unref?.();
+}
+function localStageOperation(state, record, stage) {
+    const kind = stage === 'generate' ? 'session.turn' : 'level-editor.verify';
+    const clientRequestId = stage === 'generate'
+        ? record.taskId
+        : (record.verifyClientRequestId ?? `${record.taskId}:verify`);
+    const sessionId = stage === 'generate' ? record.sourceSessionId : undefined;
+    const matches = (operation) => operation.kind === kind &&
+        operation.clientRequestId === clientRequestId &&
+        operation.environment === state.config.environment &&
+        operation.userId === state.config.userId &&
+        operation.workspaceId === record.workspaceId &&
+        (operation.directoryName ?? 'basic') === record.directoryName &&
+        operation.sessionId === sessionId &&
+        operation.generation === record.generation &&
+        operation.runtimeEpoch === record.runtimeEpoch;
+    const candidates = state.journal
+        .listOperations()
+        .map((item) => item.operation)
+        .filter(matches);
+    if (candidates.length > 1)
+        return { error: 'level_editor_local_operation_ambiguous' };
+    const previousId = stage === 'generate' ? record.taskOperationId : record.verifyOperationId;
+    const previous = previousId ? state.journal.getOperationById(previousId) : undefined;
+    if (previous && (!matches(previous) || previous.operationId !== candidates[0]?.operationId))
+        return { error: 'level_editor_local_operation_mismatch' };
+    // Older records may contain a control-service operation ID. Only the scoped native journal
+    // identifies a local prior stage; the authoritative backend ID remains record.operationId.
+    return { operation: candidates[0] };
+}
+async function drain(state) {
+    for (const record of await listLevelEditorRequests(state)) {
+        if (!loops.get(state) || state.journal.destroyed())
+            return;
+        if (!['requested', 'queued', 'dispatched'].includes(record.status) ||
+            record.stage === 'complete')
+            continue;
+        const change = async (status, error, patch = {}) => {
+            const failedStage = patch.failedStage ??
+                (status === 'failed' ? failureStage(state, { ...record, status }) : record.failedStage);
+            await write(state, {
+                ...record,
+                ...patch,
+                status,
+                error,
+                failedStage,
+                updatedAt: new Date().toISOString(),
+            });
+        };
+        if (record.generation !== state.config.generation ||
+            record.runtimeEpoch !== state.runtimeEpoch) {
+            await change('stale', 'level_editor_request_runtime_changed');
+            continue;
+        }
+        const source = state.journal.getOperationById(record.sourceOperationId);
+        if (!source ||
+            source.sessionId !== record.sourceSessionId ||
+            source.nativeThreadId !== record.sourceThreadId ||
+            source.nativeTurnId !== record.sourceTurnId) {
+            await change('stale', 'level_editor_source_unavailable');
+            continue;
+        }
+        if (source.status === 'uncertain') {
+            await change('uncertain', 'level_editor_source_uncertain');
+            continue;
+        }
+        if (source.status === 'failed' || source.status === 'interrupted') {
+            await change('cancelled', 'level_editor_source_interrupted');
+            continue;
+        }
+        if (source.status !== 'completed')
+            continue;
+        if (record.stage === 'generate' &&
+            state.journal
+                .listOperations()
+                .some(({ operation }) => operation.kind === 'session.turn' &&
+                operation.operationId !== source.operationId && !['completed', 'failed', 'interrupted'].includes(operation.status))) {
+            if (record.status !== 'queued')
+                await change('queued');
+            continue;
+        }
+        if (record.stage === 'verify' || record.stage === 'preview') {
+            const resolved = localStageOperation(state, record, record.stage === 'verify' ? 'generate' : 'verify');
+            if (resolved.error) {
+                await change('failed', resolved.error);
+                continue;
+            }
+            const prior = resolved.operation;
+            if (!prior || !['completed', 'failed', 'interrupted', 'uncertain'].includes(prior.status))
+                continue;
+            if (prior.status !== 'completed') {
+                await change(prior.status === 'uncertain' ? 'uncertain' : 'failed', prior.error ?? 'level_editor_prior_stage_failed');
+                continue;
+            }
+            if (record.stage === 'preview') {
+                const task = await readPrivateLevelEditorTask(state, record.workspaceId, record.directoryName, record.taskId);
+                if (task?.record.status !== 'verified') {
+                    await change('failed', task?.record.error ?? 'level_editor_verification_failed', {
+                        failedStage: 'verify',
+                    });
+                    continue;
+                }
+            }
+        }
+        if (record.status === 'requested')
+            await change('queued');
+        if (record.attemptId) {
+            try {
+                const ownCheck = record.stage === 'verify' ? localStageOperation(state, record, 'verify') : undefined;
+                const frozen = await retryInput(state, record, await workspaceRoot(state, record.workspaceId, record.directoryName), !!ownCheck?.operation &&
+                    ['queued', 'dispatched', 'accepted'].includes(ownCheck.operation.status));
+                if (frozen.hash !== record.retryInputHash)
+                    throw new Error('level_editor_retry_inputs_changed');
+            }
+            catch (error) {
+                await change('failed', error instanceof Error && /^level_editor_[a-z_]+$/.test(error.message)
+                    ? error.message
+                    : 'level_editor_retry_inputs_changed');
+                continue;
+            }
+        }
+        try {
+            const response = await fetch(platformEndpoint(state.config.publicBaseUrl, '/runtime/internal/level-editor-requests/dispatch'), {
+                method: 'POST',
+                redirect: 'error',
+                signal: AbortSignal.any([
+                    AbortSignal.timeout(15_000),
+                    loops.get(state).controller.signal,
+                ]),
+                headers: {
+                    authorization: `Bearer ${state.config.controlToken}`,
+                    'content-type': 'application/json',
+                    'playcraft-env': state.config.environment,
+                },
+                body: JSON.stringify({
+                    runtimeId: state.config.runtimeId,
+                    generation: state.config.generation,
+                    runtimeEpoch: state.runtimeEpoch,
+                    requestId: record.requestId,
+                    taskId: record.taskId,
+                    workspaceId: record.workspaceId,
+                    directoryName: record.directoryName,
+                    sourceOperationId: record.sourceOperationId,
+                    sourceSessionId: record.sourceSessionId,
+                    sourceThreadId: record.sourceThreadId,
+                    sourceTurnId: record.sourceTurnId,
+                    toolCallId: record.toolCallId,
+                    step: record.stage,
+                    action: record.action,
+                    goal: record.goal,
+                    ...(record.editorId ? { editorId: record.editorId } : {}),
+                    ...(record.attemptId
+                        ? {
+                            attemptId: record.attemptId,
+                            retryOfRequestId: record.retryOfRequestId,
+                            retryStage: record.retryStage,
+                            retryInputHash: record.retryInputHash,
+                            expectedSourceFingerprint: record.expectedSourceFingerprint,
+                            expectedDefinitionHash: record.expectedDefinitionHash,
+                            expectedDocumentHashes: record.expectedDocumentHashes,
+                        }
+                        : {}),
+                }),
+            });
+            const result = (await response.json().catch(() => ({})));
+            if (!loops.get(state))
+                return;
+            if (response.ok && typeof result.operationId === 'string') {
+                if (result.status === 'uncertain')
+                    await change('uncertain', typeof result.error === 'string' ? result.error : 'level_editor_stage_uncertain');
+                else if (result.status === 'failed' || result.status === 'interrupted')
+                    await change('failed', typeof result.error === 'string' ? result.error : 'level_editor_stage_failed');
+                else if (record.stage === 'generate' || record.stage === 'verify') {
+                    const local = localStageOperation(state, record, record.stage);
+                    if (local.error)
+                        await change('failed', local.error, { operationId: result.operationId });
+                    else
+                        await change('dispatched', undefined, record.stage === 'generate'
+                            ? {
+                                stage: 'verify',
+                                taskOperationId: local.operation?.operationId,
+                                operationId: result.operationId,
+                            }
+                            : {
+                                stage: 'preview',
+                                verifyOperationId: local.operation?.operationId,
+                                operationId: result.operationId,
+                            });
+                }
+                else if (record.stage === 'preview') {
+                    if (result.status === 'completed')
+                        await change('dispatched', undefined, {
+                            stage: 'complete',
+                            previewOperationId: result.operationId,
+                            operationId: result.operationId,
+                        });
+                    // Repeat the exact preview request while its authority record is pending.
+                }
+            }
+            else if (result.code === 'uncertain_operation')
+                await change('uncertain', 'level_editor_stage_uncertain');
+            else if (result.code === 'level_editor_retry_inputs_changed')
+                await change('failed', 'level_editor_retry_inputs_changed');
+            else if (response.status !== 409 && response.status < 500)
+                await change('failed', typeof result.code === 'string' ? result.code : 'level_editor_dispatch_denied');
+            else if (response.status >= 500 && record.error !== 'level_editor_control_unavailable')
+                await change('queued', 'level_editor_control_unavailable');
+            // A timeout, server error or lost reply retries the same task identity through control admission.
+        }
+        catch {
+            if (loops.has(state) && record.error !== 'level_editor_control_unavailable')
+                await change('queued', 'level_editor_control_unavailable');
+        }
+    }
+}