@playcraft/cli 0.1.58-beta → 0.1.59-beta

package/dist/utils/agent-generation-provenance.js

@@ -13,7 +13,7 @@ export async function agentGenerationProvenanceHeaders(path, body, requestId, cl
         return {};
     }
     const assetCreate = normalized === '/workspace-assets' && payload?.action === 'create';
-    if (!isWorkspaceGenerationPath(normalized) && !assetCreate)
+    if (!isWorkspaceGenerationPath(normalized) && !assetCreate && normalized !== '/create-batch')
         return {};
     const endpoint = process.env.PLAYCRAFT_AGENT_GENERATION_ENDPOINT;
     const capability = process.env.PLAYCRAFT_AGENT_GENERATION_CAPABILITY;

package/dist/workspace-runtime/batch/generate.js

@@ -86,7 +86,7 @@ export async function generateBatchMember(state, body) {
             // private
             await mkdir(tempDir, { recursive: true, mode: 0o700 });
             const policy = memberExecutionPolicy(root, tempDir);
-            await bindMemberPolicy(state, sessionId, policy);
+            await bindMemberPolicy(state, sessionId, policy, { runId: command.runId, ownerFence: command.ownerFence });
             const modelConfigId = command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? command.model : undefined;
             const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) };
             const turnKey = operation(state, { kind: 'session.turn', clientRequestId: `batch-turn:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: turnPayload });

package/dist/workspace-runtime/batch/policy.js

@@ -1,4 +1,4 @@
-import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 const memory = new WeakMap();
@@ -29,38 +29,87 @@ function parsePolicy(raw) {
         return undefined;
     return value;
 }
-export async function bindMemberPolicy(state, sessionId, policy) {
+export async function bindMemberPolicy(state, sessionId, policy, owner) {
     const path = policyPath(state, sessionId);
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, JSON.stringify(policy), { mode: 0o600 });
+    const binding = { ...owner, policy };
+    writeFileSync(temporary, JSON.stringify(binding), { mode: 0o600 });
     renameSync(temporary, path);
     const map = memory.get(state) ?? new Map();
-    map.set(sessionId, policy);
+    map.set(sessionId, binding);
     memory.set(state, map);
 }
-/** Synchronous: the shared session adapter reapplies this on every thread start and resume. */
+function readBinding(raw) {
+    const value = JSON.parse(raw);
+    if (!('policy' in value)) {
+        const policy = parsePolicy(raw);
+        return policy ? { policy } : undefined;
+    }
+    const policy = parsePolicy(JSON.stringify(value.policy));
+    return policy && typeof value.runId === 'string' && /^[0-9a-f-]{36}$/i.test(value.runId)
+        && Number.isInteger(value.ownerFence) && value.ownerFence >= 0 ? { ...value, policy } : undefined;
+}
+function memberRecord(state, runId, sessionId) {
+    if (typeof runId !== 'string' || !/^[0-9a-f-]{36}$/i.test(runId))
+        throw new Error('member_policy_record_invalid');
+    const record = JSON.parse(readFileSync(join(state.config.stateDir, 'batch-members', `${runId}.json`), 'utf8'));
+    if (record.runId !== runId || record.sessionId !== sessionId || !Number.isInteger(record.ownerFence)
+        || typeof record.holding !== 'boolean' || typeof record.writersStopped !== 'boolean')
+        throw new Error('member_policy_record_invalid');
+    return record;
+}
+function sessionMembers(state, sessionId) {
+    return readdirSync(join(state.config.stateDir, 'batch-members')).filter(name => name.endsWith('.json'))
+        .map(name => JSON.parse(readFileSync(join(state.config.stateDir, 'batch-members', name), 'utf8')))
+        .filter(record => record.sessionId === sessionId)
+        .map(record => memberRecord(state, record.runId, sessionId));
+}
+/** Re-read the owning Run on every lookup; a cached policy is never proof of an active member. */
 export function trustedMemberPolicy(state, sessionId) {
-    const cached = memory.get(state)?.get(sessionId);
-    if (cached)
-        return cached;
     try {
-        const parsed = parsePolicy(readFileSync(policyPath(state, sessionId), 'utf8'));
-        if (!parsed) {
-            return {
-                cwd: state.config.workspaceRoot,
-                approvalPolicy: 'never',
-                sandboxPolicy: { type: 'readOnly', networkAccess: false },
-            };
+        let binding = memory.get(state)?.get(sessionId);
+        if (!binding) {
+            let raw;
+            try {
+                raw = readFileSync(policyPath(state, sessionId), 'utf8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            }
+            binding = readBinding(raw);
+            if (!binding)
+                throw new Error('member_policy_invalid');
+            const map = memory.get(state) ?? new Map();
+            map.set(sessionId, binding);
+            memory.set(state, map);
         }
-        const map = memory.get(state) ?? new Map();
-        map.set(sessionId, parsed);
-        memory.set(state, map);
-        return parsed;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
+        if (binding.runId) {
+            const record = memberRecord(state, binding.runId, sessionId);
+            if (record.holding || !record.writersStopped) {
+                if (record.ownerFence !== binding.ownerFence)
+                    throw new Error('member_policy_owner_mismatch');
+                return binding.policy;
+            }
+            if (sessionMembers(state, sessionId).some(member => member.holding || !member.writersStopped))
+                throw new Error('member_policy_owner_mismatch');
+            return undefined;
+        }
+        // Profiles written before Run ownership was recorded still use durable member facts.
+        const records = sessionMembers(state, sessionId);
+        if (!records.length)
+            throw new Error('member_policy_record_missing');
+        const active = records.filter(record => record.holding || !record.writersStopped);
+        if (!active.length)
             return undefined;
+        if (active.length !== 1 || binding.policy.sandboxPolicy.type !== 'workspaceWrite'
+            || !binding.policy.sandboxPolicy.writableRoots.includes(join(state.config.stateDir, 'batch-temp', active[0].runId)))
+            throw new Error('member_policy_owner_mismatch');
+        return binding.policy;
+    }
+    catch {
         return {
             cwd: state.config.workspaceRoot,
             approvalPolicy: 'never',

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)
@@ -412,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')
@@ -479,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)) {
@@ -702,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' };
             });
@@ -731,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' };
             });
@@ -741,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' };
                 }
@@ -777,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;
@@ -832,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();
@@ -973,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)
@@ -983,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 {
@@ -1040,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/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));