@playcraft/cli 0.1.57-beta → 0.1.59-beta

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

@@ -32,6 +32,10 @@ const ENGINEERING_BATCH_INSTRUCTIONS = [
     'The platform freezes the current source and generates each planned variant in its own Remix directory. Submission authorizes automatic generation without another prompt approval. Keep the source unchanged for this batch; do not replace independent variants with theme switching in the source.',
     'Pass --team-id when the trusted batch request context supplies teamId. Creation means queued; use playcraft tools get-batch --batch-id <the actual batch identifier> for results. On an uncertain creation, reuse the same clientRequestId. Report creation failures without falling back to editing the source.',
 ].join('\n');
+const MEMBER_EXECUTION_INSTRUCTIONS = [
+    'You are implementing one assigned variant in an independent Remix directory which the platform has already created.',
+    'Apply the assigned changes directly to the current working directory. The originating source is a separate directory; source freezing, variant planning and directory creation have already been handled by the platform.',
+].join('\n');
 function codexReasoningEffort(effort) {
     return effort === 'max' ? 'xhigh' : effort;
 }
@@ -40,11 +44,65 @@ function asRecord(value) {
         ? value
         : {};
 }
+function nativeContextHash(params) {
+    return createHash('sha256').update(JSON.stringify(params.developerInstructions ?? '')).digest('hex');
+}
 function isReadOnlySnapshot(value) {
     const settings = asRecord(value);
     const policy = asRecord(settings.sandboxPolicy ?? settings.sandbox);
     return settings.approvalPolicy === 'never' && policy.type === 'readOnly' && policy.networkAccess === false;
 }
+const DEFAULT_PREDICTION_TIMEOUT_MS = 15_000;
+const PREDICTION_INSTRUCTIONS = [
+    "You predict the user's most likely next message in this coding session.",
+    'Use only the conversation below. Do not answer it, continue the work, or call tools.',
+    "Write in the user's language as short imperative requests, at most 80 characters each.",
+    'Return JSON only, with no markdown fences, exactly in this shape:',
+    '{"suggestions":["...","..."]}',
+    'Provide 1 to 3 suggestions ordered by likelihood, without explanations.',
+].join('\n');
+const PREDICTION_OUTPUT_SCHEMA = {
+    type: 'object',
+    additionalProperties: false,
+    required: ['suggestions'],
+    properties: {
+        suggestions: {
+            type: 'array',
+            minItems: 1,
+            maxItems: 3,
+            items: { type: 'string', minLength: 1, maxLength: 160 },
+        },
+    },
+};
+/** Parses the structured prediction turn without trusting markdown fences or extra prose. */
+export function parsePredictionSuggestions(text) {
+    const cleaned = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '').trim();
+    const start = cleaned.indexOf('{');
+    const end = cleaned.lastIndexOf('}');
+    if (start < 0 || end <= start)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(cleaned.slice(start, end + 1));
+    }
+    catch {
+        return [];
+    }
+    const candidates = asRecord(parsed).suggestions;
+    if (!Array.isArray(candidates))
+        return [];
+    return candidates
+        .filter((value) => typeof value === 'string')
+        .map(value => value.trim())
+        .filter(Boolean)
+        .slice(0, 3);
+}
+function predictionPrompt(items) {
+    const recent = items.slice(-8)
+        .map(item => `${item.role.toUpperCase()}: ${item.text.slice(0, 4000)}`)
+        .join('\n\n');
+    return `${PREDICTION_INSTRUCTIONS}\n\nConversation (oldest first):\n${recent || '(no earlier messages)'}`;
+}
 function waitForChildExit(child, processGroup = false) {
     if ((child.exitCode !== null || child.signalCode !== null) && child.stdout?.destroyed && child.stderr?.destroyed)
         return Promise.resolve();
@@ -89,6 +147,34 @@ export function createCodexAppServerAdapter(options) {
     const threads = new Map();
     const approvals = new Map();
     const childParents = new Map();
+    const predictions = new Map();
+    const predictionByParent = new Map();
+    const predictionTimeoutMs = options.predictionTimeoutMs ?? DEFAULT_PREDICTION_TIMEOUT_MS;
+    function settlePrediction(threadId, error) {
+        const prediction = predictions.get(threadId);
+        if (!prediction || prediction.settled)
+            return;
+        prediction.settled = true;
+        clearTimeout(prediction.timer);
+        predictions.delete(threadId);
+        if (predictionByParent.get(prediction.parentThreadId) === threadId)
+            predictionByParent.delete(prediction.parentThreadId);
+        const suggestions = error ? [] : parsePredictionSuggestions(prediction.chunks.join(''));
+        prediction.resolve(suggestions.length
+            ? { outcome: 'ok', suggestions }
+            : { outcome: 'failed', error: error ?? 'prediction_empty' });
+    }
+    async function cancelPredictionForThread(parentThreadId) {
+        const threadId = predictionByParent.get(parentThreadId);
+        const prediction = threadId ? predictions.get(threadId) : undefined;
+        if (!threadId || !prediction || !rpc)
+            return;
+        const turnId = prediction.turnId;
+        settlePrediction(threadId, 'prediction_cancelled');
+        if (turnId)
+            await rpc.request('turn/interrupt', { threadId, turnId }, 10_000).catch(() => undefined);
+        await rpc.request('thread/unsubscribe', { threadId }, 10_000).catch(() => undefined);
+    }
     let child;
     let rpc;
     let readyFlag = false;
@@ -153,9 +239,9 @@ export function createCodexAppServerAdapter(options) {
         startPromise ??= start();
         await startPromise;
     }
-    async function threadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId) {
+    async function threadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId, originCwd) {
         try {
-            return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId)
+            return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId, originCwd)
                 ?? { ...options.fixedThreadConfig, modelConfigId: undefined, activate: () => { } };
         }
         catch (error) {
@@ -166,7 +252,20 @@ export function createCodexAppServerAdapter(options) {
         }
     }
     async function lockedThreadConfig(cwd, selectedConfigId, sessionId, reasoningEffort, clientRequestId, permissionMode = 'auto') {
-        const { modelConfigId, activate, ...providedModelConfig } = await threadConfig(cwd, selectedConfigId, sessionId, reasoningEffort, clientRequestId);
+        const scope = relative(options.config.workspaceRoot, cwd);
+        const orchestration = options.config.workspaceMode === 'multi' && /^[0-9a-f-]{36}$/i.test(scope);
+        let coordinatorDirectory;
+        if (orchestration) {
+            const key = JSON.stringify([cwd, sessionId]);
+            coordinatorDirectory = coordinatorDirectories.get(key);
+            if (!coordinatorDirectory) {
+                coordinatorDirectory = await mkdtemp(join(tmpdir(), 'playcraft-batch-coordinator-'));
+                // The sandbox launches native commands as its development identity, not the controller.
+                await chmod(coordinatorDirectory, 0o777);
+                coordinatorDirectories.set(key, coordinatorDirectory);
+            }
+        }
+        const { modelConfigId, activate, ...providedModelConfig } = await threadConfig(cwd, selectedConfigId, sessionId, reasoningEffort, clientRequestId, coordinatorDirectory);
         let mcp;
         if (options.loadMcpConfig) {
             try {
@@ -183,19 +282,11 @@ export function createCodexAppServerAdapter(options) {
                 ...mcp?.config,
                 ...(reasoningEffort ? { model_reasoning_effort: codexReasoningEffort(reasoningEffort) } : {}),
             } };
-        const scope = relative(options.config.workspaceRoot, cwd);
-        const orchestration = options.config.workspaceMode === 'multi' && /^[0-9a-f-]{36}$/i.test(scope);
-        const engineeringBatch = !options.fixedExecution && options.config.workspaceMode === 'multi'
+        const unattended = Boolean(options.fixedExecution || (sessionId && options.trustedExecution?.(sessionId)));
+        const engineeringBatch = !unattended && options.config.workspaceMode === 'multi'
             && /^[0-9a-f-]{36}\/(?:basic|remix-[a-z0-9][a-z0-9-]{3,63})$/i.test(scope);
         if (orchestration) {
-            const key = JSON.stringify([cwd, sessionId]);
-            let directory = coordinatorDirectories.get(key);
-            if (!directory) {
-                directory = await mkdtemp(join(tmpdir(), 'playcraft-batch-coordinator-'));
-                // The sandbox launches native commands as its development identity, not the controller.
-                await chmod(directory, 0o777);
-                coordinatorDirectories.set(key, directory);
-            }
+            const directory = coordinatorDirectory;
             const execution = executionPolicy(directory, permissionMode, { cwd: directory, approvalPolicy: 'never', sandboxPolicy: {
                     type: 'workspaceWrite', writableRoots: [directory], networkAccess: true,
                     excludeTmpdirEnvVar: true, excludeSlashTmp: true,
@@ -205,7 +296,8 @@ export function createCodexAppServerAdapter(options) {
                 'sandbox_workspace_write.network_access': true,
                 'sandbox_workspace_write.exclude_tmpdir_env_var': true,
                 'sandbox_workspace_write.exclude_slash_tmp': true,
-                'shell_environment_policy.set': { PLAYCRAFT_TOOL_REQUEST_DIR: directory, PLAYCRAFT_SKIP_UPDATE_CHECK: '1', TMPDIR: directory }, };
+                'shell_environment_policy.set': { ...asRecord(asRecord(modelConfig.config)['shell_environment_policy.set']),
+                    PLAYCRAFT_TOOL_REQUEST_DIR: directory, PLAYCRAFT_SKIP_UPDATE_CHECK: '1', TMPDIR: directory }, };
             const developerInstructions = [
                 'You coordinate PlayCraft batches. The workspace engineering directories are read-only in this conversation.',
                 `Workspace identity: ${scope}. Engineering source root: ${JSON.stringify(cwd)}. Default source directory: basic.`,
@@ -228,7 +320,7 @@ export function createCodexAppServerAdapter(options) {
             const execution = resolveSessionExecution(cwd, permissionMode, sessionId ? options.trustedExecution?.(sessionId) : undefined, options.fixedExecution);
             const selected = threadExecutionParams(execution);
             return { params: { ...modelConfig, ...selected, config: withModelShell({ ...modelConfig.config, ...selected.config }, modelConfigId),
-                    ...(options.workspaceUi && !options.fixedExecution ? { developerInstructions: WORKSPACE_UI_INSTRUCTIONS } : {}) },
+                    ...((unattended || options.workspaceUi) ? { developerInstructions: unattended ? MEMBER_EXECUTION_INSTRUCTIONS : WORKSPACE_UI_INSTRUCTIONS } : {}) },
                 execution, modelConfigId, activate, skillsHash: undefined, discoveryHash: undefined, mcpHash: mcp?.hash };
         }
         try {
@@ -249,7 +341,8 @@ export function createCodexAppServerAdapter(options) {
                 ...frozen.skills.map(skill => JSON.stringify(skill)),
                 ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
                 ...(engineeringBatch ? [ENGINEERING_BATCH_INSTRUCTIONS] : []),
-                ...(options.workspaceUi && !options.fixedExecution ? [WORKSPACE_UI_INSTRUCTIONS] : []),
+                ...(unattended ? [MEMBER_EXECUTION_INSTRUCTIONS] : []),
+                ...(options.workspaceUi && !unattended ? [WORKSPACE_UI_INSTRUCTIONS] : []),
             ].join('\n');
             const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
             const execution = resolveSessionExecution(cwd, permissionMode, sessionId ? options.trustedExecution?.(sessionId) : undefined, options.fixedExecution);
@@ -312,6 +405,7 @@ export function createCodexAppServerAdapter(options) {
     async function resumePreparedThread(threadId, thread, prepared) {
         const resumed = await rpc.request('thread/resume', {
             threadId, ...prepared.params,
+            ...(dynamicTools.length ? { dynamicTools } : {}),
         }, 30_000);
         if (resumed.thread?.id !== threadId)
             throw new NativePreparationError('workspace_skills_unavailable');
@@ -320,6 +414,7 @@ export function createCodexAppServerAdapter(options) {
         thread.skillsHash = prepared.skillsHash;
         thread.discoveryHash = prepared.discoveryHash;
         thread.mcpHash = prepared.mcpHash;
+        thread.contextHash = nativeContextHash(prepared.params);
     }
     async function start() {
         if (closed)
@@ -372,6 +467,7 @@ export function createCodexAppServerAdapter(options) {
         }
         else {
             // Local execution owns its fresh profile; managed launcher profiles are prepared for the development identity by the image.
+            // private
             await mkdir(homeDir, { recursive: true, mode: 0o700 });
             if (closed)
                 throw new Error('codex_not_started');
@@ -411,6 +507,30 @@ export function createCodexAppServerAdapter(options) {
         const nativeClient = rpc;
         rpc.onNotification((method, params) => {
             const payload = asRecord(params);
+            const predictionThreadId = typeof payload.threadId === 'string' ? payload.threadId : undefined;
+            const prediction = predictionThreadId ? predictions.get(predictionThreadId) : undefined;
+            if (prediction && predictionThreadId) {
+                if (method === 'turn/started') {
+                    const turnId = asRecord(payload.turn).id;
+                    if (typeof turnId === 'string')
+                        prediction.turnId = turnId;
+                }
+                else if (method === 'item/agentMessage/delta' && typeof payload.delta === 'string') {
+                    prediction.chunks.push(payload.delta);
+                }
+                else if (method === 'item/completed') {
+                    const message = asRecord(payload.item);
+                    if (message.type === 'agentMessage' && typeof message.text === 'string' && !prediction.chunks.length)
+                        prediction.chunks.push(message.text);
+                }
+                else if (method === 'turn/completed') {
+                    settlePrediction(predictionThreadId);
+                }
+                else if (method === 'error') {
+                    settlePrediction(predictionThreadId, 'prediction_failed');
+                }
+                return;
+            }
             if (method === 'turn/started' && typeof payload.threadId === 'string') {
                 const thread = threads.get(payload.threadId), turnId = asRecord(payload.turn).id;
                 if (thread?.turnActive && typeof turnId === 'string')
@@ -478,6 +598,15 @@ export function createCodexAppServerAdapter(options) {
         });
         rpc.onServerRequest((id, method, params) => {
             const payload = asRecord(params);
+            const prediction = typeof payload.threadId === 'string' ? predictions.get(payload.threadId) : undefined;
+            if (prediction) {
+                const threadId = String(payload.threadId);
+                const turnId = prediction.turnId;
+                settlePrediction(threadId, 'prediction_tool_request');
+                if (turnId)
+                    void nativeClient.request('turn/interrupt', { threadId, turnId }, 10_000).catch(() => undefined);
+                return;
+            }
             if (method === 'item/tool/call') {
                 const thread = typeof payload.threadId === 'string' ? threads.get(payload.threadId) : undefined;
                 if (deliveryTools && isWorkspaceDeliveryTool(payload.tool)) {
@@ -701,7 +830,7 @@ export function createCodexAppServerAdapter(options) {
                     throw new Error('native_receipt_lost');
                 prepared.activate();
                 threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: false, loaded: true });
+                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, contextHash: nativeContextHash(prepared.params), resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: false, loaded: true });
                 threads.get(threadId).readOnlyConfirmed = isReadOnlySnapshot(result);
                 return { threadId, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto' };
             });
@@ -730,7 +859,7 @@ export function createCodexAppServerAdapter(options) {
                     return undefined;
                 prepared.activate();
                 threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: true, loaded: true });
+                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, contextHash: nativeContextHash(prepared.params), resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: true, loaded: true });
                 threads.get(input.threadId).readOnlyConfirmed = readOnlyConfirmed;
                 return { modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto' };
             });
@@ -740,6 +869,8 @@ export function createCodexAppServerAdapter(options) {
                 await ensureStarted();
                 if (!rpc)
                     throw new Error('codex_not_started');
+                // A real turn always wins over a speculative prediction for the same thread.
+                await cancelPredictionForThread(input.threadId);
                 if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
                     return { outcome: 'failed', error: 'unknown_thread' };
                 }
@@ -776,6 +907,12 @@ export function createCodexAppServerAdapter(options) {
                         else if (mcpChanged || (thread.skillsHash && (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash))) {
                             await restartForSkills(input.threadId, prepared.modelConfigId, reasoningEffort, mcpChanged ? 'mcp' : 'skills', mcpChanged ? prepared : undefined);
                         }
+                        if (thread.loaded && thread.contextHash !== nativeContextHash(prepared.params)) {
+                            if (!thread.hasNativeHistory)
+                                return { outcome: 'failed', error: 'unknown_thread' };
+                            await rpc.request('thread/unsubscribe', { threadId: input.threadId }, 30_000);
+                            thread.loaded = false;
+                        }
                         if (!thread.loaded)
                             await resumePreparedThread(input.threadId, thread, prepared);
                         thread.skillsHash = prepared.skillsHash;
@@ -831,6 +968,122 @@ export function createCodexAppServerAdapter(options) {
                 }
             });
         },
+        async startPrediction(input) {
+            await ensureStarted();
+            if (!rpc)
+                return { outcome: 'failed', error: 'prediction_unavailable' };
+            const reader = rpc;
+            const parent = threads.get(input.threadId);
+            if (!parent || parent.sessionId !== input.sessionId)
+                return { outcome: 'failed', error: 'unknown_thread' };
+            if (parent.turnActive)
+                return { outcome: 'failed', error: 'turn_already_active' };
+            if (predictionByParent.has(input.threadId))
+                await cancelPredictionForThread(input.threadId);
+            let items = [];
+            try {
+                // Recent turns only: full thread/read hydration is deprecated for paginated threads
+                // and grows with the whole session. The summary view still carries user/agent text.
+                const page = await reader.request('thread/turns/list', { threadId: input.threadId, limit: 4 }, 15_000);
+                for (const turn of [...(page.data ?? [])].reverse()) {
+                    for (const rawItem of turn.items ?? []) {
+                        const item = asRecord(rawItem);
+                        if (item.type === 'userMessage') {
+                            const text = (Array.isArray(item.content) ? item.content : [])
+                                .map(part => asRecord(part))
+                                .filter(part => part.type === 'text' && typeof part.text === 'string')
+                                .map(part => String(part.text)).join('\n').trim();
+                            if (text)
+                                items.push({ role: 'user', text });
+                        }
+                        else if (item.type === 'agentMessage' && typeof item.text === 'string' && item.text.trim()) {
+                            items.push({ role: 'assistant', text: item.text });
+                        }
+                    }
+                }
+                items = items.slice(-8);
+            }
+            catch {
+                // Older builds without paginated turn listing: fall back to the whole thread.
+                try {
+                    const read = await reader.request('thread/read', { threadId: input.threadId, includeTurns: true }, 15_000);
+                    items = projectNativeThread(input.threadId, read.thread ?? read)?.items ?? [];
+                }
+                catch {
+                    // An empty transcript still lets the model propose generic next steps.
+                }
+            }
+            let forkId;
+            try {
+                const forked = await withPreparation(async () => {
+                    await ensureStarted();
+                    if (!rpc)
+                        throw new Error('codex_not_started');
+                    // Prediction forks cannot combine with config overrides; they inherit the
+                    // parent thread's model provider, i.e. the workspace broker route.
+                    return await rpc.request('thread/fork', {
+                        threadId: input.threadId,
+                        ephemeral: true,
+                        excludeTurns: true,
+                        threadSource: 'composer_predictions',
+                        experimentalPredictionMode: true,
+                    }, 30_000);
+                });
+                forkId = forked.thread?.id;
+            }
+            catch {
+                return { outcome: 'failed', error: 'prediction_unavailable' };
+            }
+            if (!forkId)
+                return { outcome: 'failed', error: 'prediction_unavailable' };
+            const predictionThreadId = forkId;
+            const client = rpc;
+            if (!client)
+                return { outcome: 'failed', error: 'prediction_unavailable' };
+            childParents.set(predictionThreadId, input.threadId);
+            const result = new Promise((resolve) => {
+                const timer = setTimeout(() => {
+                    const pending = predictions.get(predictionThreadId);
+                    if (pending?.turnId)
+                        void client.request('turn/interrupt', {
+                            threadId: predictionThreadId, turnId: pending.turnId,
+                        }, 10_000).catch(() => undefined);
+                    settlePrediction(predictionThreadId, 'prediction_timeout');
+                }, predictionTimeoutMs);
+                timer.unref?.();
+                predictions.set(predictionThreadId, {
+                    parentThreadId: input.threadId, chunks: [], settled: false, resolve, timer,
+                });
+                predictionByParent.set(input.threadId, predictionThreadId);
+            });
+            try {
+                const started = await client.request('turn/start', {
+                    threadId: predictionThreadId,
+                    input: [{ type: 'text', text: predictionPrompt(items) }],
+                    outputSchema: PREDICTION_OUTPUT_SCHEMA,
+                    turnTrigger: 'prediction',
+                    clientUserMessageId: `prediction_${randomUUID()}`,
+                    approvalPolicy: 'never',
+                    sandboxPolicy: { type: 'readOnly', networkAccess: false },
+                }, 30_000);
+                const pending = predictions.get(predictionThreadId);
+                if (pending && started.turn?.id)
+                    pending.turnId = started.turn.id;
+            }
+            catch {
+                settlePrediction(predictionThreadId, 'prediction_unavailable');
+            }
+            try {
+                return await result;
+            }
+            finally {
+                predictions.delete(predictionThreadId);
+                if (predictionByParent.get(input.threadId) === predictionThreadId)
+                    predictionByParent.delete(input.threadId);
+                childParents.delete(predictionThreadId);
+                await client.request('thread/unsubscribe', { threadId: predictionThreadId }, 10_000).catch(() => undefined);
+            }
+        },
         async startReview(input) {
             return withPreparation(async () => {
                 await ensureStarted();
@@ -972,6 +1225,7 @@ export function createCodexAppServerAdapter(options) {
         },
         async interrupt(input) {
             await ensureStarted();
+            await cancelPredictionForThread(input.threadId);
             const thread = threads.get(input.threadId);
             // Nothing is sent when no turn of this session runs here, so that answer is definite.
             if (thread?.sessionId !== input.sessionId || !thread.turnActive)
@@ -982,11 +1236,13 @@ export function createCodexAppServerAdapter(options) {
             // A turn that is still starting has no id yet; the last one is already over.
             if (!turnId || turnId === thread.lastCompletedTurnId)
                 return { outcome: 'uncertain' };
+            if (input.expectedTurnId !== undefined && input.expectedTurnId !== turnId)
+                return { outcome: 'failed', error: 'turn_changed' };
             try {
                 await uiTools.cancel(input.threadId);
                 await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
                 const cwd = threads.get(input.threadId)?.cwd;
-                if (cwd)
+                if (cwd && (input.expectedTurnId === undefined || threads.get(input.threadId)?.lastTurnId === turnId))
                     options.modelBroker?.cancelSession(cwd, input.sessionId);
             }
             catch {
@@ -1039,6 +1295,8 @@ export function createCodexAppServerAdapter(options) {
         },
         close() {
             closing ??= (async () => {
+                for (const threadId of [...predictions.keys()])
+                    settlePrediction(threadId, 'prediction_unavailable');
                 closed = true;
                 readyFlag = false;
                 await uiTools.cancel(undefined, 'ui_runtime_disconnected');

package/dist/workspace-runtime/codex/config-toml.js

@@ -77,7 +77,9 @@ export async function writePortableCodexCatalog(input) {
     }
     await mkdir(input.directory, { recursive: true });
     const path = join(input.directory, 'portable-models.json');
+    // private
     await writeFile(path, body, { encoding: 'utf8', mode: 0o644 });
+    // private
     await writeFile(join(input.directory, 'portable-models.version.json'), JSON.stringify({
         version,
         sha256: createHash('sha256').update(body).digest('hex'),
@@ -85,6 +87,7 @@ export async function writePortableCodexCatalog(input) {
     return path;
 }
 export async function writePlaycraftCodexConfig(input) {
+    // private
     await mkdir(input.homeDir, { recursive: true, mode: 0o700 });
     const path = join(input.homeDir, 'config.toml');
     const body = [
@@ -102,6 +105,7 @@ export async function writePlaycraftCodexConfig(input) {
         'requires_openai_auth = false',
         '',
     ].join('\n');
+    // private
     await writeFile(path, body, { encoding: 'utf8', mode: 0o600 });
     return path;
 }

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

@@ -5,7 +5,7 @@ export const WORKSPACE_DELIVERY_TOOLS = [
     {
         type: 'function',
         name: 'playcraft_build_delivery',
-        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit; each channel reuses the options of its latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. Returns build ids immediately; poll playcraft_get_delivery for status, checks and failure details.',
+        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit; each channel reuses the options of its latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. If the result is pending at workspace.save, finish the current turn without polling so the save can run, then continue the export in a later turn. Once build ids are returned, poll playcraft_get_delivery for status, checks and failure details.',
         inputSchema: {
             type: 'object',
             properties: {

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

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

package/dist/workspace-runtime/codex/loopback.js

@@ -87,6 +87,8 @@ export function createLoopbackNativeAdapter() {
             if (!thread || thread.sessionId !== input.sessionId)
                 return { outcome: 'uncertain' };
             const turnId = thread.turnId;
+            if (input.expectedTurnId !== undefined && input.expectedTurnId !== turnId)
+                return { outcome: 'failed', error: 'turn_changed' };
             queueMicrotask(() => {
                 emit(collectedEvent('notification', 'turn/completed', {
                     threadId: input.threadId,

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

@@ -52,7 +52,7 @@ export class WorkspaceModelBroker {
         activate();
         return settings;
     }
-    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId) {
+    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId, originCwd) {
         if (!this.server)
             throw new Error('workspace_not_registered');
         const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
@@ -61,11 +61,12 @@ export class WorkspaceModelBroker {
         const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
         let route = this.routes.get(routeKey);
         const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
-        const cacheKey = `${workspaceId}:${selected ?? 'default'}:${reasoningEffort ?? 'default'}`;
+        const cacheKey = `${workspaceId}:${selected ?? 'default'}:${reasoningEffort ?? 'default'}:${sessionId ?? ''}:${clientRequestId ?? ''}`;
         let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected
+            && item.sessionId === sessionId && item.clientRequestId === clientRequestId
             && item.reasoningEffort === reasoningEffort);
         if (!entry || entry.epoch !== this.state.runtimeEpoch) {
-            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected, reasoningEffort };
+            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected, reasoningEffort, sessionId, clientRequestId };
             this.entries.set(cacheKey, entry);
         }
         // Resolve current model metadata and permission at every native turn boundary.
@@ -82,7 +83,7 @@ export class WorkspaceModelBroker {
                 if (!this.valid(entry) || this.routes.get(routeKey) !== route)
                     throw new Error('model_access_denied');
                 route.selected = { entry, model: credential.model,
-                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId, cwd, boundaryId } } : {}) };
+                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId, cwd, boundaryId, ...(originCwd ? { originCwd } : {}) } } : {}) };
             },
             model: credential.model,
             modelConfigId: credential.configId,
@@ -125,6 +126,8 @@ export class WorkspaceModelBroker {
             headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
             body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
                 runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+                ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
+                ...(entry.clientRequestId ? { clientRequestId: entry.clientRequestId } : {}),
                 ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}),
                 ...(entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {}) }),
         });