@playcraft/cli 0.1.28 → 0.1.30

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

@@ -0,0 +1,46 @@
+import { NativeRpcResponseError } from './jsonrpc-stdio.js';
+/** The compact receipt is empty. A separately observed turn supplies its durable identity. */
+export async function requestNativeCompaction(input) {
+    let turnId;
+    let rejectStarted = () => { };
+    let unsubscribe = () => { };
+    let timer;
+    const started = new Promise((resolve, reject) => {
+        rejectStarted = reject;
+        timer = setTimeout(() => reject(new Error('compact_start_timeout')), input.timeoutMs);
+        unsubscribe = input.onCollected(event => {
+            if (event.kind === 'process_exit') {
+                reject(new Error('compact_process_exited'));
+                return;
+            }
+            if (event.method !== 'turn/started')
+                return;
+            const params = record(event.params), turn = record(params.turn);
+            if (params.threadId !== input.threadId || typeof turn.id !== 'string' || !turn.id || turn.id === input.previousTurnId)
+                return;
+            turnId = turn.id;
+            resolve(turn.id);
+        });
+    });
+    try {
+        // Subscribe before sending: Codex may emit the new turn before acknowledging this request.
+        await Promise.all([started, input.client.sendReserved(input.requestId, 'thread/compact/start', {
+                threadId: input.threadId,
+            }, input.timeoutMs)]);
+        return { outcome: 'accepted', threadId: input.threadId, turnId: turnId };
+    }
+    catch (error) {
+        if (error instanceof NativeRpcResponseError && !turnId)
+            return { outcome: 'failed', error: 'compact_start_rejected' };
+        return { outcome: 'uncertain', threadId: input.threadId, ...(turnId ? { turnId } : {}) };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        unsubscribe();
+        rejectStarted(new Error('compact_request_finished'));
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}

package/dist/workspace-runtime/codex/jsonrpc-stdio.js

@@ -1,4 +1,12 @@
 import { EventEmitter } from 'node:events';
+export class NativeRpcResponseError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'NativeRpcResponseError';
+    }
+}
 export function createJsonRpcStdioClient(child) {
     const stdin = child.stdin;
     const stdout = child.stdout;
@@ -10,6 +18,14 @@ export function createJsonRpcStdioClient(child) {
     let turnStarts = 0;
     let buffer = '';
     let closed = false;
+    const onTransportError = () => {
+        for (const [id, waiter] of pending) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('jsonrpc_closed'));
+            pending.delete(id);
+        }
+    };
+    stdin.on('error', onTransportError);
     const onData = (chunk) => {
         buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
         let newline = buffer.indexOf('\n');
@@ -31,14 +47,14 @@ export function createJsonRpcStdioClient(child) {
         catch {
             return;
         }
-        if (message.id !== undefined && pending.has(Number(message.id))) {
+        if (!message.method && message.id !== undefined && pending.has(Number(message.id))) {
             const waiter = pending.get(Number(message.id));
             if (!waiter)
                 return;
             pending.delete(Number(message.id));
             clearTimeout(waiter.timer);
             if (message.error) {
-                waiter.reject(new Error(message.error.message || 'jsonrpc_error'));
+                waiter.reject(new NativeRpcResponseError(message.error.message || 'jsonrpc_error', message.error.code));
                 return;
             }
             waiter.resolve(message.result);
@@ -53,7 +69,7 @@ export function createJsonRpcStdioClient(child) {
         }
     }
     const send = (payload) => {
-        if (closed)
+        if (closed || stdin.destroyed || stdin.writableEnded)
             throw new Error('jsonrpc_closed');
         stdin.write(`${JSON.stringify(payload)}\n`);
     };
@@ -104,7 +120,13 @@ export function createJsonRpcStdioClient(child) {
             return () => emitter.off('serverRequest', listener);
         },
         respond(id, result) {
-            send({ id, result });
+            return new Promise((resolve, reject) => {
+                if (closed || stdin.destroyed || stdin.writableEnded) {
+                    reject(new Error('jsonrpc_closed'));
+                    return;
+                }
+                stdin.write(`${JSON.stringify({ id, result })}\n`, (error) => error ? reject(error) : resolve());
+            });
         },
         async close() {
             if (closed)

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

@@ -66,7 +66,7 @@ export function createLoopbackNativeAdapter() {
                 if (input.text.includes('[approval]')) {
                     const approvalId = `approval_${input.clientRequestId}`;
                     approvals.add(JSON.stringify([input.sessionId, approvalId]));
-                    emit(collectedEvent('approval_request', 'item/tool/requestUserInput', {
+                    emit(collectedEvent('approval_request', 'item/commandExecution/requestApproval', {
                         threadId: input.threadId,
                         turnId,
                         approvalId,
@@ -98,6 +98,9 @@ export function createLoopbackNativeAdapter() {
         },
         async respondApproval(input) {
             const key = JSON.stringify([input.sessionId, input.approvalId]);
+            const accepted = input.response?.kind === 'decision' ? input.response.accepted : input.response ? undefined : input.accepted;
+            if (typeof accepted !== 'boolean')
+                return { outcome: 'failed', approvalId: input.approvalId };
             if (!approvals.has(key))
                 return { outcome: 'failed', approvalId: input.approvalId };
             approvals.delete(key);
@@ -105,7 +108,7 @@ export function createLoopbackNativeAdapter() {
             queueMicrotask(() => {
                 emit(collectedEvent('notification', 'approval.resolved', {
                     approvalId: input.approvalId,
-                    accepted: input.accepted,
+                    accepted,
                     threadId: thread?.[0],
                     turnId: thread?.[1].turnId,
                 }));

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

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+import { platformEndpoint, PLATFORM_ROUTES, workspaceMcpConfigSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { NativePreparationError } from './native-adapter.js';
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonical(entry)]));
+    return value;
+}
+/** MCP (Model Context Protocol, 模型上下文协议) settings are scoped to one native thread. */
+export function nativeMcpConfig(value) {
+    const parsed = workspaceMcpConfigSchema.safeParse(value);
+    if (!parsed.success)
+        throw new NativePreparationError('workspace_mcp_unavailable');
+    return {
+        config: { mcp_servers: parsed.data.mcpServers },
+        hash: createHash('sha256').update(JSON.stringify(canonical(parsed.data))).digest('hex'),
+    };
+}
+/** Resolve current owner settings at every turn boundary without writing secrets to a checkout. */
+export async function loadWorkspaceMcpConfig(state, workspaceId) {
+    const config = state.config;
+    const runtimeEpoch = state.runtimeEpoch;
+    try {
+        const response = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.workspaceMcp), {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch, workspaceId }),
+        });
+        if (!response.ok || state.journal.destroyed() || state.runtimeEpoch !== runtimeEpoch)
+            throw new Error('workspace_mcp_unavailable');
+        return workspaceMcpConfigSchema.parse(await response.json());
+    }
+    catch {
+        throw new NativePreparationError('workspace_mcp_unavailable');
+    }
+}

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

@@ -49,7 +49,7 @@ export class WorkspaceModelBroker {
         activate();
         return settings;
     }
-    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort) {
+    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId) {
         if (!this.server)
             throw new Error('workspace_not_registered');
         const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
@@ -76,7 +76,8 @@ export class WorkspaceModelBroker {
             activate: () => {
                 if (!this.valid(entry) || this.routes.get(routeKey) !== route)
                     throw new Error('model_access_denied');
-                route.selected = { entry, model: credential.model };
+                route.selected = { entry, model: credential.model,
+                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId } } : {}) };
             },
             model: credential.model,
             modelConfigId: credential.configId,
@@ -199,7 +200,11 @@ export class WorkspaceModelBroker {
             try {
                 const upstream = await fetch(platformEndpoint(this.state.config.publicBaseUrl, modelResponsesPath(credential.configId)), {
                     method: 'POST', redirect: 'error', signal: abort.signal,
-                    headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json' },
+                    headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json',
+                        ...(selected?.feedback ? {
+                            'x-playcraft-cloud-session-id': selected.feedback.sessionId,
+                            'x-playcraft-client-request-id': selected.feedback.clientRequestId,
+                        } : {}) },
                     body: JSON.stringify(body),
                 });
                 if (upstream.status === 401 || upstream.status === 403)

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

@@ -0,0 +1,70 @@
+export const NATIVE_APPROVALS_REVIEWER = 'user';
+/** Fixed production/coordinator boundaries may only become narrower. */
+export function executionPolicy(cwd, mode, fixed) {
+    const directory = fixed?.cwd ?? cwd;
+    if (mode === 'read-only')
+        return { cwd: directory, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false } };
+    if (mode === 'auto')
+        return fixed ?? { cwd, approvalPolicy: 'never', sandboxPolicy: { type: 'dangerFullAccess' } };
+    if (fixed?.sandboxPolicy.type === 'readOnly')
+        return { ...fixed, sandboxPolicy: { type: 'readOnly', networkAccess: false } };
+    return { cwd: directory, approvalPolicy: fixed ? 'never' : 'on-request', sandboxPolicy: {
+            type: 'workspaceWrite', writableRoots: fixed?.sandboxPolicy.type === 'workspaceWrite' ? fixed.sandboxPolicy.writableRoots : [directory],
+            networkAccess: false, excludeTmpdirEnvVar: true, excludeSlashTmp: true,
+        } };
+}
+export function threadExecutionParams(execution) {
+    const sandbox = execution.sandboxPolicy.type === 'readOnly' ? 'read-only'
+        : execution.sandboxPolicy.type === 'workspaceWrite' ? 'workspace-write' : 'danger-full-access';
+    const policy = execution.sandboxPolicy;
+    return { cwd: execution.cwd, approvalPolicy: execution.approvalPolicy, approvalsReviewer: NATIVE_APPROVALS_REVIEWER, sandbox,
+        config: policy.type === 'workspaceWrite' ? {
+            'sandbox_workspace_write.writable_roots': policy.writableRoots,
+            'sandbox_workspace_write.network_access': policy.networkAccess,
+            'sandbox_workspace_write.exclude_tmpdir_env_var': policy.excludeTmpdirEnvVar,
+            'sandbox_workspace_write.exclude_slash_tmp': policy.excludeSlashTmp,
+        } : {} };
+}
+export const APPROVAL_METHODS = new Set([
+    'item/commandExecution/requestApproval', 'item/fileChange/requestApproval',
+    'item/permissions/requestApproval', 'item/tool/requestUserInput',
+]);
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/** Returns only the native request's permissions; a browser cannot supply new paths or network access. */
+export function nativeApprovalResponse(method, request, response, canEscalate) {
+    if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval') {
+        if (response.kind !== 'decision' || (response.accepted && !canEscalate))
+            return undefined;
+        const decision = response.accepted ? 'accept' : Array.isArray(request.availableDecisions)
+            && !request.availableDecisions.includes('decline') && request.availableDecisions.includes('cancel') ? 'cancel' : 'decline';
+        if (Array.isArray(request.availableDecisions) && !request.availableDecisions.includes(decision))
+            return undefined;
+        return { decision };
+    }
+    if (method === 'item/permissions/requestApproval') {
+        if (response.kind !== 'permissions' || (response.accepted && !canEscalate))
+            return undefined;
+        const requested = record(request.permissions);
+        if (!request.permissions || Object.keys(requested).some(key => !['network', 'fileSystem'].includes(key)))
+            return undefined;
+        return { permissions: response.accepted ? Object.fromEntries(Object.entries(requested).filter(([, value]) => value != null)) : {}, scope: response.scope };
+    }
+    if (method !== 'item/tool/requestUserInput' || response.kind !== 'user-input' || !Array.isArray(request.questions) || !request.questions.length)
+        return undefined;
+    const questions = request.questions.map(record);
+    const ids = questions.map(question => question.id);
+    if (ids.some(id => typeof id !== 'string' || !id) || new Set(ids).size !== ids.length
+        || Object.keys(response.answers).length !== ids.length || Object.keys(response.answers).some(id => !ids.includes(id)))
+        return undefined;
+    for (const question of questions) {
+        const answers = response.answers[question.id]?.answers;
+        if (!answers || answers.length !== 1 || !answers[0]?.trim())
+            return undefined;
+        const options = Array.isArray(question.options) ? question.options.map(record) : [];
+        if (options.length && question.isOther !== true && !options.some(option => option.label === answers[0]))
+            return undefined;
+    }
+    return { answers: response.answers };
+}

package/dist/workspace-runtime/codex/work-mode.js

@@ -0,0 +1,15 @@
+export function workModeExecution(execution, workMode) {
+    return workMode === 'plan' ? {
+        ...execution, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false },
+    } : execution;
+}
+export function nativeCollaborationMode(model, effort, workMode) {
+    return {
+        mode: workMode === 'plan' ? 'plan' : 'default',
+        settings: {
+            model,
+            reasoning_effort: effort === 'max' ? 'xhigh' : effort ?? null,
+            developer_instructions: null,
+        },
+    };
+}

package/dist/workspace-runtime/persistence/native-subagents.js

@@ -132,13 +132,13 @@ function remember(database, childId, parentId, owner, metadata, confirmed = true
     return true;
 }
 function ownsOperation(session, rootThreadId, found) {
-    return Boolean(found && found.operation.kind === 'session.turn' && found.operation.sessionId === session.sessionId &&
+    return Boolean(found && ['session.turn', 'session.review', 'session.compact'].includes(found.operation.kind) && found.operation.sessionId === session.sessionId &&
         (found.operation.workspaceId === undefined || found.operation.workspaceId === session.workspaceId) && found.operation.nativeThreadId === rootThreadId);
 }
 function readOperation(database, column, value, threadId) {
     if (!value)
         return undefined;
-    const row = database.prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE ${column} = ?${threadId ? ' AND thread_id = ?' : ''}`)
+    const row = database.prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE ${column} = ?${threadId ? ' AND thread_id = ?' : ''}${column === 'turn_id' ? " AND json_extract(operation_json, '$.kind') IN ('session.turn', 'session.review', 'session.compact')" : ''}`)
         .get(...(threadId ? [value, threadId] : [value]));
     if (!row)
         return undefined;

package/dist/workspace-runtime/persistence/sqlite-worker.js

@@ -329,13 +329,13 @@ function quarantineReservedTurns(database) {
         if (!parsed.success)
             continue;
         const operation = parsed.data;
-        if (operation.kind !== 'session.turn' || operation.status !== 'dispatched')
+        if (!['session.turn', 'session.review', 'session.compact', 'session.steer'].includes(operation.kind) || operation.status !== 'dispatched')
             continue;
-        if (!operation.nativeRequestId || operation.nativeTurnId)
+        if (!operation.nativeRequestId || (operation.kind !== 'session.steer' && operation.nativeTurnId))
             continue;
         const uncertain = transitionOperation(operation, 'uncertain', { error: 'native_receipt_lost' });
         putOperation(database, row.scope_key, uncertain);
-        if (operation.sessionId) {
+        if (operation.sessionId && operation.kind !== 'session.steer') {
             const session = readSession(database, operation.sessionId);
             if (session) {
                 upsertRecord(database, 'sessions', operation.sessionId, { ...session, turnBlock: 'uncertain', turnStatus: 'starting' });
@@ -512,8 +512,9 @@ function convertInboxRow(database, ingress, input) {
     const params = input.params ?? JSON.parse(row.payload_json || '{}');
     const payload = linkedPayload(params, input.session, input.subAgent);
     const nativeApprovalId = optionalString(payload.approvalId) || optionalString(payload.itemId) || input.itemId;
-    const childApproval = input.subAgent && nativeApprovalId && input.method?.includes('requestApproval');
-    if (input.subAgent && nativeApprovalId && (childApproval || input.method === 'approval.resolved')) {
+    const approvalRequest = input.method?.includes('requestApproval') || input.method === 'item/tool/requestUserInput';
+    const childApproval = input.subAgent && nativeApprovalId && approvalRequest;
+    if (input.subAgent && nativeApprovalId && (childApproval || input.method === 'approval.resolved' || input.method === 'serverRequest/resolved')) {
         payload.approvalId = `subagent_${createHash('sha256').update(JSON.stringify([input.subAgent.threadId, nativeApprovalId])).digest('hex')}`;
     }
     const type = input.kind === 'process_exit' ? 'process.exited' : input.method || input.kind;
@@ -544,16 +545,44 @@ function convertInboxRow(database, ingress, input) {
             approvalId: payload.approvalId,
             sessionId: input.operation.operation.sessionId,
             runtimeEpoch: input.runtimeEpoch,
-            nativeRequestId: `approval:${nativeApprovalId}`,
+            nativeRequestId: optionalString(payload.requestId) ?? `approval:${nativeApprovalId}`,
             nativeApprovalId,
             nativeThreadId: input.subAgent.threadId,
+            nativeTurnId: input.turnId,
+            rootThreadId: input.subAgent.rootThreadId,
+            rootTurnId: input.operation.operation.nativeTurnId,
+            method: input.method,
+            request: payload,
             status: 'pending',
         });
     }
+    settleNativeApprovals(database, input, payload);
     if (!input.subAgent)
         applyNativeToState(database, { ...input, operation: resolveOperation(database, input, payload) }, payload);
     return event;
 }
+/** An ended native request must never reappear as a pending approval after reconnect. */
+function settleNativeApprovals(database, input, payload) {
+    const resolved = input.method === 'approval.resolved' || input.method === 'serverRequest/resolved';
+    const terminal = Boolean(terminalTurn(input.method ?? '', payload));
+    if (!resolved && !terminal && input.kind !== 'process_exit')
+        return;
+    const rows = database.prepare("SELECT record_key, body_json FROM records WHERE bucket = 'approvals'").all();
+    for (const row of rows) {
+        const approval = asRecord(JSON.parse(row.body_json));
+        if (approval.status !== 'pending')
+            continue;
+        const matchesThread = approval.nativeThreadId === input.threadId;
+        const matchesRequest = (payload.approvalId && approval.approvalId === payload.approvalId)
+            || (payload.requestId !== undefined && String(approval.nativeRequestId) === String(payload.requestId));
+        const endedParent = terminal && approval.rootThreadId === input.threadId && approval.rootTurnId === input.turnId;
+        if (input.kind !== 'process_exit' && !endedParent && (!matchesThread || (resolved ? !matchesRequest
+            : input.turnId && approval.nativeTurnId && approval.nativeTurnId !== input.turnId)))
+            continue;
+        upsertRecord(database, 'approvals', row.record_key, { ...approval,
+            status: input.method === 'approval.resolved' ? payload.accepted === false ? 'rejected' : 'approved' : 'expired' });
+    }
+}
 function applyRecordedTurn(database, threadId, turnId) {
     const rows = database
         .prepare(`SELECT type, payload_json, thread_id, session_id FROM source_events
@@ -561,7 +590,7 @@ function applyRecordedTurn(database, threadId, turnId) {
        ORDER BY source_sequence`)
         .all(threadId, turnId, `%"${turnId}"%`);
     for (const row of rows) {
-        if (!row.type.includes('requestApproval') && !row.type.includes('requestUserInput') && !row.type.includes('completed') && !row.type.includes('interrupted') && row.type !== 'turn.failed' && row.type !== 'approval.resolved') {
+        if (!row.type.includes('requestApproval') && !row.type.includes('requestUserInput') && !row.type.includes('completed') && !row.type.includes('interrupted') && row.type !== 'turn.failed' && row.type !== 'approval.resolved' && row.type !== 'serverRequest/resolved') {
             continue;
         }
         const payload = asRecord(JSON.parse(row.payload_json));
@@ -586,14 +615,19 @@ function resolveOperation(database, input, payload) {
 }
 function applyNativeToState(database, input, payload) {
     const method = input.method ?? '';
+    settleNativeApprovals(database, input, payload);
     const session = input.session;
     if (session?.sessionId) {
         const next = { ...session };
         const approval = method.includes('requestApproval') || method.includes('requestUserInput');
         if (approval)
             next.turnStatus = moveTurn(String(session.turnStatus ?? 'running'), 'waiting_for_user');
-        else if (method === 'approval.resolved')
-            next.turnStatus = moveTurn(String(session.turnStatus ?? 'waiting_for_user'), 'running');
+        else if (method === 'approval.resolved' || method === 'serverRequest/resolved') {
+            const waiting = database.prepare("SELECT 1 FROM records WHERE bucket = 'approvals' AND json_extract(body_json, '$.sessionId') = ? AND json_extract(body_json, '$.status') = 'pending' AND json_extract(body_json, '$.nativeThreadId') = ? LIMIT 1")
+                .get(session.sessionId, session.threadId);
+            if (!waiting)
+                next.turnStatus = moveTurn(String(session.turnStatus ?? 'waiting_for_user'), 'running');
+        }
         else if (method.includes('delta') || method === 'turn/started' || method === 'turn.started') {
             const current = String(session.turnStatus ?? 'starting');
             if (current !== 'waiting_for_user')
@@ -618,7 +652,12 @@ function applyNativeToState(database, input, payload) {
             approvalId,
             sessionId: operation.sessionId,
             runtimeEpoch: operation.runtimeEpoch ?? 0,
-            nativeRequestId: operation.nativeRequestId ?? `approval:${approvalId}`,
+            nativeRequestId: optionalString(payload.requestId) ?? `approval:${approvalId}`,
+            nativeThreadId: input.threadId,
+            nativeTurnId: input.turnId,
+            nativeApprovalId: approvalId,
+            method,
+            request: payload,
             status: 'pending',
         });
         operation = operationRecordSchema.parse({
@@ -902,7 +941,7 @@ function sessionByThread(database, threadId) {
 }
 function operationByTurn(database, turnId, threadId) {
     const row = database
-        .prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE turn_id = ?${threadId ? ' AND thread_id = ?' : ''}`)
+        .prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE turn_id = ?${threadId ? ' AND thread_id = ?' : ''} AND json_extract(operation_json, '$.kind') IN ('session.turn', 'session.review', 'session.compact')`)
         .get(...(threadId ? [turnId, threadId] : [turnId]));
     if (!row)
         return undefined;

package/dist/workspace-runtime/production/native.js

@@ -6,6 +6,7 @@ import { ingestCollected, publishSourceEvents, recordNativeEvents } from '../ser
 import { verifyProductionLease } from './storage.js';
 import { processBirth, stopProductionGroup } from './processes.js';
 import { openDirectoryToDevelopment } from '../workspaces/directory-access.js';
+import { loadWorkspaceMcpConfig } from '../codex/mcp-config.js';
 export async function runProductionNative(state, input, root, record, track) {
     if (!input.model)
         throw new Error('production_model_configuration_required');
@@ -25,6 +26,7 @@ export async function runProductionNative(state, input, root, record, track) {
         homeDir: process.env.PLAYCRAFT_LAUNCHER_SOCKET
             ? `/var/lib/playcraft/codex/production-${input.task.attemptId}` : join(state.config.stateDir, 'production-native', input.task.attemptId),
         model: input.model.model, processGroup: true,
+        loadMcpConfig: () => loadWorkspaceMcpConfig(state, input.task.workspaceId),
         fixedExecution: { cwd: root, approvalPolicy: 'never', sandboxPolicy: { type: 'workspaceWrite', writableRoots: [root],
                 networkAccess: true, excludeTmpdirEnvVar: true, excludeSlashTmp: true } },
         fixedThreadConfig: { model: input.model.model, modelProvider: 'playcraft_production', config: {

package/dist/workspace-runtime/production/save-command.js

@@ -22,3 +22,14 @@ git diff --cached --quiet || git -c core.hooksPath=/dev/null commit -m "Save gen
 git -c protocol.version=0 -c core.hooksPath=/dev/null -c remote.origin.url="$PRODUCTION_REPOSITORY" -c remote.origin.pushurl="$PRODUCTION_REPOSITORY" push --set-upstream origin HEAD:"refs/heads/$PRODUCTION_BRANCH"
 git rev-parse HEAD`;
 }
+/** Commits generated engineering locally inside the sandbox without pushing a branch to remote origin. */
+export function productionLocalCommitCommand() {
+    return `set -eu
+git -c core.hooksPath=/dev/null -c core.fsmonitor=false add -A .
+if [ -n "$(git ls-files -- .playcraft.json playcraft.config.json ':(glob)**/.playcraft.json' ':(glob)**/playcraft.config.json')" ]; then
+  printf 'production_git_private_path\\n' >&2
+  exit 1
+fi
+git diff --cached --quiet || git -c core.hooksPath=/dev/null commit -m "Save generated engineering"
+git rev-parse HEAD`;
+}

package/dist/workspace-runtime/production/stages.js

@@ -10,7 +10,7 @@ import { registerWorkspaceDirectory } from '../workspaces/directories.js';
 import { workspaceContainerRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
 import { excludeFromGit, settleDependencyInstalls } from '../workspaces/dependencies.js';
 import { resolveProductionDependencies, verifyProductionDependencyLocks } from './dependencies.js';
-import { productionSaveCommand } from './save-command.js';
+import { productionLocalCommitCommand } from './save-command.js';
 import { productionOutputStore, verifyProductionLease } from './storage.js';
 import { runProductionCommand } from './processes.js';
 import { runProductionNative } from './native.js';
@@ -105,11 +105,9 @@ export async function executeProductionStage(state, input, processRecord, track)
         return { generated: true };
     }
     if (stage === 'save') {
-        if (!input.git)
-            throw new Error('production_git_scope_required');
         const binding = state.journal.getWorkspace(workspaceId);
         const branch = input.directoryName === 'basic' ? binding.branchName : binding.directories?.find(value => value.directoryName === input.directoryName)?.branchName;
-        if (input.git.branchName !== branch || await git(root, 'symbolic-ref', '--short', 'HEAD') !== branch)
+        if ((input.git && input.git.branchName !== branch) || await git(root, 'symbolic-ref', '--short', 'HEAD') !== branch)
             throw new Error('production_git_binding_mismatch');
         await excludeFromGit(root);
         await excludeFromGit(root, '/.env*');
@@ -117,15 +115,8 @@ export async function executeProductionStage(state, input, processRecord, track)
         await excludeFromGit(root, '/.playcraft-preview-out/');
         await git(root, 'config', 'user.name', 'PlayCraft');
         await git(root, 'config', 'user.email', 'playcraft@localhost');
-        const env = { PRODUCTION_REPOSITORY: input.git.repositoryUrl, PRODUCTION_BRANCH: input.git.branchName,
-            GIT_TERMINAL_PROMPT: '0', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1' };
-        if (input.git.username && input.git.password)
-            Object.assign(env, { GIT_CONFIG_COUNT: '1',
-                GIT_CONFIG_KEY_0: `http.${input.git.repositoryUrl}.extraHeader`,
-                GIT_CONFIG_VALUE_0: `Authorization: Basic ${Buffer.from(`${input.git.username}:${input.git.password}`).toString('base64')}` });
-        if (typeof input.payload.expectedParent === 'string')
-            env.PRODUCTION_EXPECTED_PARENT = input.payload.expectedParent;
-        await run(root, productionSaveCommand(), env, true);
+        const env = { GIT_TERMINAL_PROMPT: '0', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1' };
+        await run(root, productionLocalCommitCommand(), env, true);
         const commitHash = await git(root, 'rev-parse', 'HEAD');
         const snapshot = await freezeBatchCommit({ source: { workspaceId, root }, commitHash, snapshotId: `${input.task.attemptId}-save` });
         return { snapshot, saved: { attemptId: input.task.attemptId, resultVersionId: resultId, workspaceId, sourceDigest: snapshot.checksum, commitHash, pushedCommitHash: commitHash } };
@@ -146,8 +137,17 @@ export async function executeProductionStage(state, input, processRecord, track)
         if (!snapshot || snapshot.commitHash !== saved.commitHash || snapshot.checksum !== saved.sourceDigest)
             throw new Error('production_saved_snapshot_mismatch');
         const destination = join(root, '.playcraft-temp', `production-${input.task.attemptId}`);
+        const removeDestination = async () => {
+            try {
+                await rm(destination, { recursive: true, force: true });
+            }
+            catch {
+                await run(destination, 'chmod -R u+rwX,g+rwX .').catch(() => undefined);
+                await rm(destination, { recursive: true, force: true });
+            }
+        };
         await excludeFromGit(root, '/.playcraft-temp/');
-        await rm(destination, { recursive: true, force: true });
+        await removeDestination();
         try {
             await checkoutBatchCommit({ source: { workspaceId, root }, frozen: snapshot, destination });
             await openDirectoryToDevelopment(destination, (await lstat(state.config.workspaceRoot)).gid);
@@ -174,7 +174,7 @@ export async function executeProductionStage(state, input, processRecord, track)
                     sourceDigest: snapshot.checksum, commitHash: snapshot.commitHash, buildId: `${input.task.attemptId}-build`, succeeded: true } };
         }
         finally {
-            await rm(destination, { recursive: true, force: true });
+            await removeDestination();
         }
     }
     if (stage === 'preview') {
@@ -190,7 +190,7 @@ export async function executeProductionStage(state, input, processRecord, track)
         try {
             const browser = process.env.PLAYCRAFT_PRODUCTION_PREVIEW_COMMAND ?? 'chromium --headless --no-sandbox --disable-gpu --virtual-time-budget=1000 --dump-dom';
             const opened = await run(root, `${browser} ${quote(`file://${previewPath}`)}`);
-            if (!/<html[\s>]/i.test(opened))
+            if (!/<\/?html[\s>]/i.test(opened))
                 throw new Error('production_preview_not_opened');
             return { opened: true, outputDigest: built.outputDigest };
         }

package/dist/workspace-runtime/serve.js

@@ -20,6 +20,7 @@ import { recoverInterruptedInstalls } from './workspaces/dependencies.js';
 import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
 import { workspaceContextFromRoot } from './workspaces/registry.js';
 import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
+import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -191,6 +192,10 @@ function defaultNativeAdapter(state) {
         return createCodexAppServerAdapter({
             config,
             ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
+            ...(multi ? { loadMcpConfig: async (cwd) => {
+                    const { workspaceId } = await workspaceContextFromRoot(state, cwd);
+                    return loadWorkspaceMcpConfig(state, workspaceId);
+                } } : {}),
             loadSkillArtifact: async (cwd, entry) => {
                 const { workspaceId, directoryName } = await workspaceContextFromRoot(state, cwd);
                 return loadWorkspaceSkillArtifact(state, workspaceId, entry, directoryName === 'root' ? 'basic' : directoryName);