@playcraft/cli 0.1.47-beta → 0.1.49-beta

package/dist/workspace-runtime/codex/delivery-tools.js

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { DELIVERY_CHANNELS, deliveryFormatSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_DELIVERY_TOOLS = [
+    {
+        type: 'function',
+        name: 'playcraft_build_delivery',
+        description: 'Start one formal channel delivery build. Returns build identifiers immediately; poll playcraft_get_delivery for status and validation results. This writes a delivery record under dist/delivery/.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channels: {
+                    type: 'array',
+                    items: { type: 'string', enum: DELIVERY_CHANNELS },
+                    minItems: 1,
+                    maxItems: 8,
+                    uniqueItems: true,
+                },
+                format: { type: 'string', enum: ['html', 'zip'] },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        type: 'function',
+        name: 'playcraft_get_delivery',
+        description: 'Read the latest delivery build, or one build by id, including status, validation summary, error and a truncated build log.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                buildId: { type: 'string' },
+                channel: { type: 'string', enum: DELIVERY_CHANNELS },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+const DELIVERY_TOOL_NAMES = new Set(WORKSPACE_DELIVERY_TOOLS.map(tool => tool.name));
+export function isWorkspaceDeliveryTool(name) {
+    return typeof name === 'string' && DELIVERY_TOOL_NAMES.has(name);
+}
+export class WorkspaceDeliveryTools {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    async request(requestId, payload, client, context) {
+        const tool = typeof payload.tool === 'string' ? payload.tool : '';
+        const args = payload.arguments;
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (!context.sessionId || (!context.cwd && !context.workspaceId)) {
+            await this.reject(client, requestId, 'feature_unavailable');
+            return;
+        }
+        if (context.directoryName === 'root') {
+            await this.reject(client, requestId, 'invalid_workspace_directory');
+            return;
+        }
+        const input = args;
+        if (tool === 'playcraft_build_delivery')
+            return this.build(requestId, payload, input, client, context);
+        if (tool === 'playcraft_get_delivery')
+            return this.get(requestId, input, client, context);
+        await this.reject(client, requestId, 'unknown_delivery_tool');
+    }
+    async build(requestId, payload, input, client, context) {
+        if (context.readOnly) {
+            await this.reject(client, requestId, 'permission_denied');
+            return;
+        }
+        const unknown = Object.keys(input).filter(key => key !== 'channels' && key !== 'format');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const channels = input.channels === undefined ? ['playcraft'] : input.channels;
+        if (!Array.isArray(channels) || channels.length < 1 || channels.length > 8
+            || channels.some(channel => !DELIVERY_CHANNELS.includes(channel))
+            || new Set(channels).size !== channels.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const format = input.format === undefined ? undefined : deliveryFormatSchema.safeParse(input.format);
+        if (format && !format.success) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.build({
+                ...context,
+                clientRequestId: typeof payload.callId === 'string' && payload.callId.length
+                    ? payload.callId
+                    : randomUUID(),
+                channels: channels,
+                ...(format && format.success ? { format: format.data } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async get(requestId, input, client, context) {
+        const unknown = Object.keys(input).filter(key => key !== 'buildId' && key !== 'channel');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.buildId !== undefined && (typeof input.buildId !== 'string'
+            || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(input.buildId))) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.channel !== undefined && !DELIVERY_CHANNELS.includes(input.channel)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.get({
+                ...context,
+                ...(typeof input.buildId === 'string' ? { buildId: input.buildId } : {}),
+                ...(typeof input.channel === 'string' ? { channel: input.channel } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async respond(client, requestId, value) {
+        await client.respond(requestId, { success: true, contentItems: toolContent(value) }).catch(() => undefined);
+    }
+    async reject(client, requestId, reason) {
+        await rejectTool(client, requestId, reason);
+    }
+}
+function errorReason(cause) {
+    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
+        return cause.code;
+    return 'delivery_tool_failed';
+}

package/dist/workspace-runtime/codex/tool-response.js

@@ -0,0 +1,10 @@
+export function toolContent(value) {
+    return [{ type: 'inputText', text: JSON.stringify(value) }];
+}
+/** The App Server treats a failed tool call as content, not a JSON-RPC error. */
+export async function rejectTool(client, requestId, reason) {
+    await client.respond(requestId, {
+        success: false,
+        contentItems: toolContent({ status: 'failed', reason }),
+    }).catch(() => undefined);
+}

package/dist/workspace-runtime/codex/ui-tools.js

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { workspaceUiCommandSchema, workspaceUiResultSchema, WORKSPACE_UI_COMMAND_EVENT, WORKSPACE_UI_RESULT_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool } from './tool-response.js';
 export const WORKSPACE_UI_TOOLS = [
     { type: 'function', name: 'playcraft_get_ui_context',
         description: 'Read the PlayCraft browser view captured when the user sent this turn. This is a turn-start snapshot, not a live browser observation or visual verification. Only the visible panel target is returned by default; request open tabs only when needed.',
@@ -13,6 +14,13 @@ export const WORKSPACE_UI_TOOLS = [
         description: 'Open an existing preview in the current PlayCraft workspace browser view. Omit identifiers for the latest available preview. Opening does not start a build or verify the rendered appearance.',
         inputSchema: { type: 'object', properties: { artifactId: { type: 'string' }, versionId: { type: 'string' },
                 previewId: { type: 'string' } }, additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_delivery',
+        description: 'Open the delivery panel in the current PlayCraft workspace browser view. Opening does not start or verify a build.',
+        inputSchema: { type: 'object', properties: { channel: { type: 'string' }, buildId: { type: 'string' } },
+            additionalProperties: false } },
+    { type: 'function', name: 'playcraft_open_task',
+        description: 'Open the task panel in the current PlayCraft workspace browser view. Opening does not change task state.',
+        inputSchema: { type: 'object', properties: { taskId: { type: 'string' } }, additionalProperties: false } },
 ];
 /** Read the saved view locally; browser commands have a separate receipt lifecycle. */
 export class WorkspaceUiTools {
@@ -48,8 +56,12 @@ export class WorkspaceUiTools {
             return;
         }
         const kind = params.tool === 'playcraft_open_file' ? 'open_file'
-            : params.tool === 'playcraft_open_preview' ? 'open_preview' : undefined;
-        const allowed = kind === 'open_file' ? ['path', 'range'] : ['artifactId', 'versionId', 'previewId'];
+            : params.tool === 'playcraft_open_preview' ? 'open_preview'
+                : params.tool === 'playcraft_open_delivery' ? 'open_delivery'
+                    : params.tool === 'playcraft_open_task' ? 'open_task' : undefined;
+        const allowed = kind === 'open_file' ? ['path', 'range']
+            : kind === 'open_preview' ? ['artifactId', 'versionId', 'previewId']
+                : kind === 'open_delivery' ? ['channel', 'buildId'] : ['taskId'];
         if (!kind || Object.keys(args).some(key => !allowed.includes(key))) {
             void this.reject(client, requestId, 'invalid_ui_tool_arguments');
             return;
@@ -98,6 +110,8 @@ export class WorkspaceUiTools {
         if (snapshot && (snapshot.viewId !== command.viewId || snapshot.sessionId !== command.sessionId
             || snapshot.workspaceId !== command.workspaceId || snapshot.directoryName !== command.directoryName))
             return { outcome: 'failed', error: 'ui_result_scope_mismatch' };
+        const targetTab = command.kind === 'open_file' ? 'files'
+            : command.kind === 'open_preview' ? 'preview' : command.kind;
         if (result.status === 'opened' && (!snapshot?.panelOpen
             || (command.kind === 'open_file' && (!isAssetTab(snapshot.activeTab) || snapshot.activeFile?.path !== command.path
                 || (command.range && (snapshot.activeFile.range?.startLine !== command.range.startLine
@@ -105,7 +119,11 @@ export class WorkspaceUiTools {
             || (command.kind === 'open_preview' && (snapshot.activeTab !== 'preview' || !snapshot.activePreview
                 || (command.artifactId && snapshot.activePreview.artifactId !== command.artifactId)
                 || (command.versionId && snapshot.activePreview.versionId !== command.versionId)
-                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))))
+                || (command.previewId && snapshot.activePreview.previewId !== command.previewId)))
+            || (command.kind !== 'open_file' && command.kind !== 'open_preview' && snapshot.activeTab !== targetTab)
+            || (command.kind === 'open_delivery' && ((command.channel !== undefined && snapshot.activeDelivery?.channel !== command.channel)
+                || (command.buildId !== undefined && snapshot.activeDelivery?.buildId !== command.buildId)))
+            || (command.kind === 'open_task' && command.taskId !== undefined && snapshot.activeTask?.taskId !== command.taskId)))
             return { outcome: 'failed', error: 'ui_result_target_mismatch' };
         return this.finish(result.commandId, result, fingerprint);
     }
@@ -114,8 +132,7 @@ export class WorkspaceUiTools {
             .map(([commandId, pending]) => this.finish(commandId, { commandId, viewId: pending.command.viewId, status: 'failed', reason })));
     }
     async reject(client, requestId, reason) {
-        await client.respond(requestId, { success: false, contentItems: [{ type: 'inputText', text: JSON.stringify({ status: 'failed', reason }) }] })
-            .catch(() => undefined);
+        await rejectTool(client, requestId, reason);
     }
     async finish(commandId, result, fingerprint) {
         const pending = this.pending.get(commandId);

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

@@ -0,0 +1,44 @@
+export const PREVIEW_DIAGNOSTICS_MARKER = 'data-playcraft-diagnostics';
+/**
+ * Runs only inside a published preview. It reports browser-visible failures and a small
+ * performance sample to the workspace; delivery builds never include this script.
+ */
+export const PREVIEW_DIAGNOSTICS_SCRIPT = `(function(){
+ if(window.__playcraftDiagnosticsV1)return;
+ window.__playcraftDiagnosticsV1=true;
+ var pageId=Math.random().toString(36).slice(2)+Date.now().toString(36);
+ var seq=0,buffer=[],seen={},stopped=false,start=Date.now();
+ function clean(value){try{return String(value).slice(0,2000)}catch(e){return ''}}
+ function emit(type,data){if(stopped||buffer.length>=100)return;var key=type+':'+(data.message||data.url||'');if(seen[key])return;seen[key]=1;buffer.push(Object.assign({type:type,at:Date.now()-start},data));}
+ function flush(){if(!buffer.length)return;var batch=buffer.splice(0,10);seq++;try{window.parent.postMessage({__playcraft:'diagnostics',v:1,pageId:pageId,seq:seq,events:batch},'*')}catch(e){}}
+ var timer=setInterval(flush,500);
+ window.addEventListener('error',function(event){
+   var target=event.target;
+   if(target&&target!==window&&target.tagName){emit('resource',{tag:String(target.tagName).toLowerCase(),url:clean(target.currentSrc||target.src||target.href||'')});return;}
+   emit('error',{message:clean(event.message),source:clean(event.filename),line:event.lineno,col:event.colno});
+ },true);
+ window.addEventListener('unhandledrejection',function(event){var reason=event.reason;emit('unhandledrejection',{message:clean(reason&&reason.message?reason.message:reason)});});
+ window.addEventListener('securitypolicyviolation',function(event){emit('securitypolicyviolation',{message:clean(event.violatedDirective),source:clean(event.blockedURI)});});
+ window.addEventListener('webglcontextlost',function(){emit('webgl-context-lost',{message:'webgl context lost'});},true);
+ function navigation(){
+   try{var entry=performance.getEntriesByType('navigation')[0];if(entry)emit('navigation',{duration:Math.round(entry.duration),domContentLoaded:Math.round(entry.domContentLoadedEventEnd),load:Math.round(entry.loadEventEnd)});}catch(e){}
+   try{var paint=performance.getEntriesByType('paint');for(var i=0;i<paint.length;i++){if(paint[i].name==='first-contentful-paint')emit('paint',{message:'first-contentful-paint',duration:Math.round(paint[i].startTime)});}}catch(e){}
+ }
+ if(document.readyState==='complete')navigation();else window.addEventListener('load',navigation,{once:true});
+ try{var observer=new PerformanceObserver(function(list){var entries=list.getEntries();for(var i=0;i<entries.length;i++){if(entries[i].name==='first-contentful-paint')emit('paint',{message:'first-contentful-paint',duration:Math.round(entries[i].startTime)});}});observer.observe({type:'paint',buffered:true});}catch(e){}
+ var frames=0,fpsStart=performance.now();
+ function sample(){frames++;var now=performance.now();if(now-fpsStart<5000){requestAnimationFrame(sample);}else{emit('fps',{fps:Math.round(frames/((now-fpsStart)/1000))});}}
+ requestAnimationFrame(sample);
+ window.setTimeout(function(){flush();stopped=true;clearInterval(timer);},60000);
+})();`;
+/** Injects only at preview publish time, after the builder has produced a single HTML file. */
+export function injectPreviewDiagnostics(bytes) {
+    const html = bytes.toString('utf8');
+    if (html.includes(PREVIEW_DIAGNOSTICS_MARKER))
+        return bytes;
+    const script = `<script ${PREVIEW_DIAGNOSTICS_MARKER}>${PREVIEW_DIAGNOSTICS_SCRIPT}</script>`;
+    const head = /<head[^>]*>/i.exec(html);
+    const body = /<\/body\s*>/i.exec(html);
+    const at = head ? head.index + head[0].length : body ? body.index : html.length;
+    return Buffer.from(html.slice(0, at) + script + html.slice(at), 'utf8');
+}

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

@@ -10,6 +10,8 @@ import { runDeveloperCommand } from '../workspaces/developer-command.js';
 import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
 import { classifyPreviewOutput, findExternalLocalReferences } from './single-file.js';
 import { saveWorkspacePlayableOutput } from './output.js';
+import { injectPreviewDiagnostics } from './diagnostics.js';
+import { OperationLogStore } from '../workspaces/operation-log.js';
 const BUILD_TIMEOUT_MS = 10 * 60_000;
 /** Build output and the builder's own scratch folder live in the checkout, hidden from Git. */
 const OUTPUT_FOLDER = '.playcraft-preview-out';
@@ -68,13 +70,19 @@ export async function runPreviewPublish(state, operation, root) {
         : { sessionId: operation.sessionId, clientRequestId: operation.clientRequestId };
     const outputDir = join(root, OUTPUT_FOLDER, operation.operationId);
     const output = { log: '' };
+    const operationLog = new OperationLogStore(state.config.stateDir);
+    let logChain = Promise.resolve();
+    const appendLog = (text) => {
+        logChain = logChain.then(() => operationLog.append(operation.operationId, text)).catch(() => undefined);
+    };
+    await operationLog.append(operation.operationId, `$ preview build\n`).catch(() => undefined);
     try {
         await ensureDependencies(state, revisionScope(state, workspaceId, operation.directoryName) ?? workspaceId, root, output);
         await excludeFromGit(root, `/${OUTPUT_FOLDER}/`);
         await excludeFromGit(root, `/${BUILDER_TEMP_FOLDER}/`);
         await excludeFromGit(root, `/${WORKSPACE_ARTIFACT_OUTPUT_DIRECTORY}/`);
-        await buildPreview(state, root, outputDir, operation.operationId, output);
-        const bytes = await readSingleHtml(outputDir);
+        await buildPreview(state, root, outputDir, operation.operationId, output, appendLog);
+        const bytes = injectPreviewDiagnostics(await readSingleHtml(outputDir));
         if (bytes.byteLength > PREVIEW_HTML_MAX_BYTES)
             throw new PreviewFailure('preview_not_single_file');
         if (findExternalLocalReferences(bytes.toString('utf8')).length > 0) {
@@ -133,6 +141,7 @@ export async function runPreviewPublish(state, operation, root) {
     }
     catch (error) {
         const code = error instanceof PreviewFailure ? error.code : 'preview_build_failed';
+        appendLog(`\n[${code}] ${error instanceof Error ? error.message : code}\n`);
         if (code !== 'publish_conflict') {
             await postControl(state, '/runtime/internal/preview-failures', {
                 workspaceId,
@@ -146,6 +155,7 @@ export async function runPreviewPublish(state, operation, root) {
         throw new PreviewFailure(code);
     }
     finally {
+        await logChain;
         await rm(outputDir, { recursive: true, force: true }).catch(() => undefined);
     }
 }
@@ -170,7 +180,7 @@ async function ensureDependencies(state, workspaceId, root, output) {
         throw new PreviewFailure('dependencies_not_ready');
     }
 }
-async function buildPreview(state, root, outputDir, operationId, output) {
+async function buildPreview(state, root, outputDir, operationId, output, onLog) {
     // Tests replace the build; the real one needs a project and the published CLI.
     const planned = process.env.PLAYCRAFT_PREVIEW_BUILD_COMMAND || BUILD_COMMAND;
     const outcome = await runDeveloperCommand(state, {
@@ -179,7 +189,9 @@ async function buildPreview(state, root, outputDir, operationId, output) {
         command: `${planned} --output ${shellQuote(outputDir)} .`,
         timeoutMs: BUILD_TIMEOUT_MS,
         onOutput: (chunk) => {
-            output.log = (output.log + String(chunk)).slice(-64 * 1024);
+            const text = String(chunk);
+            output.log = (output.log + text).slice(-64 * 1024);
+            onLog?.(text);
         },
     });
     if (outcome.code !== 0)

package/dist/workspace-runtime/serve.js

@@ -2,6 +2,7 @@ import { closeCliCredentials } from './workspaces/cli-credentials.js';
 import { randomUUID } from 'node:crypto';
 import { mkdir, readdir } from 'node:fs/promises';
 import { createServer } from 'node:http';
+import { createPlatformAdapter } from '@playcraft/build';
 import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
 import { RuntimeJournal } from './persistence/journal.js';
 import { createCodexAppServerAdapter } from './codex/app-server.js';
@@ -18,6 +19,7 @@ import { WorkspaceGitCredentialBroker } from './workspaces/git-credential-broker
 import { WorkspaceModelBroker } from './codex/model-broker.js';
 import { recoverInterruptedPreviews } from './previews/publish.js';
 import { recoverInterruptedInstalls } from './workspaces/dependencies.js';
+import { DeliveryStore, recoverInterruptedDeliveries } from './workspaces/delivery-store.js';
 import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
 import { workspaceContextFromRoot, workspaceRoot } from './workspaces/registry.js';
 import { recoverInterruptedLibraryImports } from './workspaces/asset-library-import.js';
@@ -26,6 +28,7 @@ import { revisionScope } from './workspaces/registry.js';
 import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
 import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
+import { submitTrustedOperation } from './server/submit-operation.js';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -49,6 +52,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const previousIdentityMatches = journal.epochsSnapshot().some((epoch) => epoch.runtime_id === config.runtimeId && epoch.generation === config.generation && epoch.runtime_epoch === previousEpoch);
         await recoverInterruptedInstalls(journal);
         await recoverInterruptedPreviews(journal);
+        await recoverInterruptedDeliveries(config.stateDir);
         await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
         const state = runtimeState = {
             config: { ...config, protocolMinor: negotiated.protocolMinor },
@@ -253,6 +257,61 @@ function closeServer(server) {
 function formatHost(host) {
     return host.includes(':') ? `[${host}]` : host;
 }
+function deliveryToolHandlers(state) {
+    const contextFor = async (input) => {
+        if (input.workspaceId)
+            return { workspaceId: input.workspaceId, directoryName: input.directoryName ?? 'basic' };
+        if (state.config.workspaceMode !== 'multi' || !input.cwd)
+            throw new Error('feature_unavailable');
+        return workspaceContextFromRoot(state, input.cwd);
+    };
+    return {
+        async build(input) {
+            const { workspaceId, directoryName } = await contextFor(input);
+            if (directoryName === 'root')
+                throw new Error('invalid_workspace_directory');
+            const builds = [];
+            for (const channel of input.channels) {
+                const operation = await submitTrustedOperation(state, {
+                    kind: 'delivery.build',
+                    workspaceId,
+                    directoryName,
+                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+                    clientRequestId: `${input.clientRequestId.slice(0, 80)}:${channel}`,
+                    payload: {
+                        channel,
+                        format: input.format ?? createPlatformAdapter({ platform: channel, format: 'html' }).getDefaultFormat(),
+                        actor: 'agent',
+                    },
+                });
+                let record;
+                for (let attempt = 0; attempt < 40 && !record; attempt++) {
+                    record = await new DeliveryStore(state.config.stateDir, workspaceId).read(operation.operationId);
+                    if (!record)
+                        await new Promise(resolve => setTimeout(resolve, 25));
+                }
+                builds.push({
+                    buildId: operation.operationId,
+                    channel,
+                    status: record?.status ?? operation.status,
+                    ...(record?.queuePosition ? { queuePosition: record.queuePosition } : {}),
+                });
+            }
+            return { builds };
+        },
+        async get(input) {
+            const { workspaceId, directoryName } = await contextFor(input);
+            const store = new DeliveryStore(state.config.stateDir, workspaceId);
+            const record = input.buildId
+                ? await store.read(input.buildId)
+                : (await store.list(directoryName, input.channel, 20))[0];
+            if (!record || record.directoryName !== directoryName)
+                throw new Error('delivery_build_not_found');
+            const log = await store.readLog(record.buildId, 0).catch(() => undefined);
+            return { build: record, ...(log ? { logTail: log.text.slice(-4_000) } : {}) };
+        },
+    };
+}
 function defaultNativeAdapter(state) {
     const config = state.config;
     if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'loopback')
@@ -266,6 +325,7 @@ function defaultNativeAdapter(state) {
         return createCodexAppServerAdapter({
             config,
             workspaceUi: true,
+            deliveryTools: deliveryToolHandlers(state),
             ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             ...(multi ? { loadMcpConfig: async (cwd) => {
                     const { workspaceId } = await workspaceContextFromRoot(state, cwd);

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

@@ -0,0 +1,61 @@
+import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
+import { canExecuteKind, executeOperation } from './dispatch.js';
+import { buildOperationRecord } from './operation-record.js';
+/**
+ * Shared operation acceptance: lease fence, idempotency, capability, record creation and
+ * execution. HTTP supplies its transport/session checks through `validate`; in-sandbox Agent
+ * tools pass none. The callback runs only when a new operation is about to be created.
+ */
+export async function acceptOperationCore(state, parsed, options) {
+    const payloadHash = hashOperationPayload(parsed.payload);
+    const scopeKey = operationScopeKey({
+        environment: state.config.environment,
+        userId: state.config.userId,
+        kind: parsed.kind,
+        clientRequestId: parsed.clientRequestId,
+        workspaceId: parsed.workspaceId,
+        directoryName: parsed.directoryName,
+        sessionId: parsed.sessionId,
+    });
+    return state.journal.exclusive(scopeKey, async () => {
+        // Recheck after a concurrent dispatcher may have advanced the fence while this request waited.
+        if (assertLeaseFence(options.leaseFence, state.acceptedLeaseFence) !== 'ok') {
+            return rejected(409, runtimeError('stale_lease', 'leaseFence is behind the accepted dispatcher'));
+        }
+        const existing = state.journal.getOperation(scopeKey);
+        const decision = resolveIdempotentAccept(existing, payloadHash);
+        if (decision.action === 'conflict') {
+            return rejected(409, runtimeError('idempotency_conflict', 'clientRequestId reused with a different payload', {
+                operationId: decision.operation.operationId,
+            }));
+        }
+        const retryWithRecovery = decision.action === 'reuse' && parsed.kind === 'session.turn'
+            && Boolean(parsed.sessionRecovery) && decision.operation.status === 'failed'
+            && isLostThreadError(decision.operation.error);
+        if (decision.action === 'reuse' && !retryWithRecovery) {
+            if (decision.operation.status === 'uncertain') {
+                return rejected(409, runtimeError('uncertain_operation', decision.operation.error ?? 'native_receipt_lost', {
+                    operationId: decision.operation.operationId,
+                }));
+            }
+            return { rejected: false, operation: decision.operation, executed: decision.operation, reused: true };
+        }
+        const validation = await options.validate?.(scopeKey);
+        if (validation)
+            return { rejected: true, refusal: validation };
+        const executable = canExecuteKind(state, parsed.kind);
+        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable);
+        if (!executable) {
+            const saved = await state.journal.putOperation(scopeKey, operation);
+            return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed() ? 'runtime_destroyed' : state.nativeError ?? 'adapter_not_started', { operationId: saved.operationId }));
+        }
+        state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, options.leaseFence);
+        await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
+        const queued = await state.journal.putOperation(scopeKey, operation);
+        const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
+        return { rejected: false, operation: queued, executed, reused: false };
+    });
+}
+function rejected(status, body) {
+    return { rejected: true, refusal: { status, body } };
+}

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

@@ -4,7 +4,7 @@ import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../work
 import { shareWorkspaceGit } from '../workspaces/shared-git.js';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, } 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';
@@ -31,6 +31,7 @@ import { batchDirectoryHeld } from '../batch/occupancy.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 { runDeliveryBuild, cancelDeliveryBuild, trackDeliveryBuild, DeliveryBuildError } from '../workspaces/delivery-build.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -59,6 +60,8 @@ const LOCAL_KINDS = new Set([
     'terminal.create',
     'parameter.patch',
     'preview.publish',
+    'delivery.build',
+    'delivery.cancel',
     'skills.update',
 ]);
 export function canExecuteKind(state, kind) {
@@ -75,7 +78,7 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
         }
         return executeScopedOperation(state, scopeKey, operation, payload, recovery);
     };
-    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish'].includes(operation.kind)) {
+    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel'].includes(operation.kind)) {
         return run();
     }
     return state.journal.exclusive(`workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, run);
@@ -140,6 +143,12 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'preview.publish') {
         return executePreviewPublish(state, scopeKey, current);
     }
+    if (operation.kind === 'delivery.build') {
+        return executeDeliveryBuild(state, scopeKey, current, payload);
+    }
+    if (operation.kind === 'delivery.cancel') {
+        return executeDeliveryCancel(state, scopeKey, current, payload);
+    }
     if (!state.native?.ready()) {
         return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
     }
@@ -1165,6 +1174,42 @@ async function executePreviewPublish(state, scopeKey, operation) {
     }).catch(() => undefined));
     return accepted;
 }
+async function executeDeliveryBuild(state, scopeKey, operation, payload) {
+    const parsed = deliveryBuildPayloadSchema.safeParse(payload);
+    if (!parsed.success) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_build' }));
+    }
+    if (!operation.workspaceId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace' }));
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    const task = runDeliveryBuild(state, {
+        buildId: operation.operationId,
+        workspaceId: operation.workspaceId,
+        directoryName: operation.directoryName ?? 'basic',
+        payload: parsed.data,
+        actor: parsed.data.actor ?? 'user',
+    }).then(async (result) => {
+        const error = result.record.error
+            ?? (result.record.status === 'succeeded' ? undefined : 'delivery_build_failed');
+        await persist(state, scopeKey, transitionOperation(accepted, result.record.status === 'succeeded' ? 'completed' : 'failed', error ? { error } : {}));
+    }, async (error) => {
+        await persist(state, scopeKey, transitionOperation(accepted, 'failed', {
+            error: error instanceof DeliveryBuildError ? error.code : 'delivery_build_failed',
+        }));
+    }).catch(() => undefined);
+    trackDeliveryBuild(state, task);
+    return accepted;
+}
+async function executeDeliveryCancel(state, scopeKey, operation, payload) {
+    const parsed = deliveryCancelPayloadSchema.safeParse(payload);
+    if (!parsed.success || !operation.workspaceId) {
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_cancel' }));
+    }
+    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    const canceled = await cancelDeliveryBuild(state, operation.workspaceId, operation.directoryName ?? 'basic', parsed.data.buildId);
+    return persist(state, scopeKey, transitionOperation(accepted, canceled ? 'completed' : 'failed', canceled ? {} : { error: 'delivery_build_not_found' }));
+}
 async function executeTerminalCreate(state, scopeKey, operation, payload) {
     const parsed = terminalCreatePayloadSchema.safeParse(payload ?? {});
     if (!parsed.success) {