@playcraft/cli 0.1.36-beta1 → 0.1.37-beta

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

@@ -0,0 +1,218 @@
+import { mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { hashOperationPayload } from '@playcraft/common/cloud-workspace/runtime';
+import { productionExecutionRequestSchema } from './contracts.js';
+import { executeProductionStage } from './stages.js';
+import { groupExited, stopProductionGroup } from './processes.js';
+import { workspaceDirectoryOccupied } from '../workspaces/directory-maintenance.js';
+import { settleDependencyInstalls } from '../workspaces/dependencies.js';
+import { verifyProductionLease } from './storage.js';
+const execute = promisify(execFile);
+const active = new WeakMap();
+const receiptsRoot = (state) => join(state.config.stateDir, 'production-receipts');
+const attemptPath = (state, id) => join(receiptsRoot(state), `${id}.attempt.json`);
+const receiptPath = (state, id, stage) => join(receiptsRoot(state), `${id}-${stage}.json`);
+async function read(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+async function write(state, path, value) {
+    await mkdir(receiptsRoot(state), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    await writeFile(temporary, JSON.stringify(value), { mode: 0o600 });
+    await rename(temporary, path);
+}
+export async function productionCapability(state) {
+    if (state.config.workspaceMode !== 'multi' || state.journal.destroyed())
+        throw new Error('production_executor_unavailable');
+    const command = process.env.PLAYCRAFT_PRODUCTION_CODEX_COMMAND ?? process.env.PLAYCRAFT_CODEX_COMMAND ?? 'codex';
+    const binary = command.endsWith('.mjs') || command.endsWith('.js') ? process.execPath : command;
+    await Promise.all([execute('git', ['--version']), execute('pnpm', ['--version']),
+        execute(binary, binary === process.execPath ? [command, '--version'] : ['--version'])]);
+    return { available: true, protocol: 1 };
+}
+export async function productionDirectoryBusy(state, workspaceId, directoryName = 'basic', excludeAttemptId, ignoreSourceCaptures = false) {
+    if (!workspaceId)
+        return false;
+    const files = await readdir(receiptsRoot(state)).catch(error => {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    for (const file of files.filter(value => value.endsWith('.attempt.json'))) {
+        const attempt = await read(join(receiptsRoot(state), file));
+        // Missing attemptId is still occupancy. Comparing it with !== treats undefined !== undefined as "not this attempt".
+        const excluded = excludeAttemptId !== undefined && attempt?.attemptId === excludeAttemptId;
+        if (attempt && !excluded && !(ignoreSourceCaptures && attempt.sourceCapture)
+            && !attempt.stopped && attempt.workspaceId === workspaceId && attempt.directoryName === directoryName)
+            return true;
+    }
+    return false;
+}
+export async function executeSandboxProduction(state, raw) {
+    const input = productionExecutionRequestSchema.parse(raw);
+    if (input.task.environment !== state.config.environment || input.task.userId !== state.config.userId
+        || input.generation !== state.config.generation || input.runtimeEpoch !== state.runtimeEpoch
+        || input.lease.taskId !== input.task.taskId || input.lease.attemptId !== input.task.attemptId)
+        throw new Error('production_scope_mismatch');
+    return state.journal.exclusive(`directory:${input.task.workspaceId}:${input.directoryName}`, () => state.journal.exclusive(`production:${input.task.attemptId}`, async () => {
+        const path = attemptPath(state, input.task.attemptId);
+        let attempt = await read(path);
+        if (attempt && (attempt.taskId !== input.task.taskId || attempt.workspaceId !== input.task.workspaceId
+            || attempt.directoryName !== input.directoryName || attempt.fence > input.lease.fence
+            || (attempt.fence === input.lease.fence && attempt.owner !== input.lease.owner)))
+            throw new Error('production_scope_mismatch');
+        if (input.action !== 'stage')
+            return stopOrReconcile(state, input, attempt);
+        if (!input.stage)
+            throw new Error('invalid_production_stage');
+        if (attempt?.stopped || attempt?.cancelling)
+            return { status: 'failed', result: { error: 'production_execution_stopped' } };
+        const file = receiptPath(state, input.task.attemptId, input.stage);
+        const old = await read(file);
+        const payloadHash = hashOperationPayload(input.payload);
+        if (old) {
+            if (old.payloadHash !== payloadHash)
+                throw new Error('production_payload_conflict');
+            // Existing intent only reports evidence. It never authorizes a second native turn.
+            return { status: old.status, result: old.result };
+        }
+        if (active.get(state)?.has(input.task.attemptId))
+            throw new Error('production_stage_still_running');
+        await verifyProductionLease(input);
+        if (!attempt) {
+            if (input.stage === 'capture-source' || input.stage === 'prepare')
+                await settleDependencyInstalls(state);
+            if (state.journal.getWorkspace(input.task.workspaceId)?.directories?.some(directory => directory.directoryName === input.directoryName && directory.status === 'reclaimed'))
+                throw new Error('production_directory_reclaimed');
+            const manifest = input.task.payload.manifest;
+            const sourceCapture = input.stage === 'capture-source' && manifest && typeof manifest === 'object'
+                && 'executionMode' in manifest && manifest.executionMode === 'direct-source';
+            if (!sourceCapture && await workspaceDirectoryOccupied(state, input.task.workspaceId, input.directoryName))
+                throw new Error('production_directory_occupied');
+            attempt = { taskId: input.task.taskId, attemptId: input.task.attemptId, workspaceId: input.task.workspaceId,
+                directoryName: input.directoryName, owner: input.lease.owner, fence: input.lease.fence, stopped: false,
+                ...(sourceCapture ? { sourceCapture: true } : {}) };
+        }
+        attempt.owner = input.lease.owner;
+        attempt.fence = input.lease.fence;
+        await write(state, path, attempt);
+        const receipt = { status: 'unknown', result: { error: 'production_stage_running' },
+            taskId: input.task.taskId, attemptId: input.task.attemptId, requestId: `${input.task.attemptId}:${input.stage}`,
+            stage: input.stage, workspaceId: input.task.workspaceId, directoryName: input.directoryName,
+            fence: input.lease.fence, payloadHash, startedAt: new Date().toISOString(), processes: [] };
+        await write(state, file, receipt);
+        const running = active.get(state) ?? new Map();
+        active.set(state, running);
+        const entry = { task: Promise.resolve(receipt), stops: [] };
+        entry.task = runStage(state, input, receipt, entry).finally(() => running.delete(input.task.attemptId));
+        running.set(input.task.attemptId, entry);
+        // Returning from the lock lets stop and reconciliation reach the in-flight native group.
+        return { status: 'unknown', result: { error: 'production_stage_running' } };
+    })).then(async (result) => {
+        const current = active.get(state)?.get(input.task.attemptId);
+        return input.action === 'stage' && current ? current.task : result;
+    });
+}
+async function runStage(state, input, receipt, running) {
+    const file = receiptPath(state, input.task.attemptId, input.stage);
+    let writes = Promise.resolve();
+    const recordProcess = async (process) => {
+        const at = receipt.processes.findIndex(value => value.pid === process.pid);
+        if (at === -1)
+            receipt.processes.push(process);
+        else
+            receipt.processes[at] = process;
+        writes = writes.then(() => write(state, file, receipt));
+        await writes;
+        const attempt = await read(attemptPath(state, input.task.attemptId));
+        if (attempt?.cancelling && !process.stopped) {
+            process.stopped = await stopProductionGroup(process);
+            throw new Error('production_execution_stopped');
+        }
+    };
+    try {
+        receipt.result = await executeProductionStage(state, input, recordProcess, stop => running.stops.push(stop));
+        await verifyProductionLease(input);
+        receipt.status = 'completed';
+    }
+    catch (error) {
+        const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message) ? error.message : 'production_stage_failed';
+        receipt.status = code.includes('unknown') || code.includes('unavailable') ? 'unknown' : 'failed';
+        receipt.result = { error: code };
+    }
+    if (receipt.processes.some(process => !process.stopped && !groupExited(process.pid))) {
+        receipt.status = 'unknown';
+        receipt.result = { error: 'production_stop_unconfirmed' };
+    }
+    receipt.finishedAt = new Date().toISOString();
+    await writes;
+    await write(state, file, receipt);
+    return { status: receipt.status, result: receipt.result };
+}
+async function attemptReceipts(state, attemptId) {
+    const files = await readdir(receiptsRoot(state)).catch(error => {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    const receipts = [];
+    for (const file of files.filter(value => value.startsWith(`${attemptId}-`) && value.endsWith('.json'))) {
+        const receipt = await read(join(receiptsRoot(state), file));
+        if (receipt)
+            receipts.push(receipt);
+    }
+    return receipts;
+}
+async function stopOrReconcile(state, input, old) {
+    const attempt = old ?? { taskId: input.task.taskId, attemptId: input.task.attemptId, workspaceId: input.task.workspaceId,
+        directoryName: input.directoryName, owner: input.lease.owner, fence: input.lease.fence, stopped: false };
+    attempt.owner = input.lease.owner;
+    attempt.fence = input.lease.fence;
+    attempt.cancelling = true;
+    await write(state, attemptPath(state, attempt.attemptId), attempt);
+    const running = active.get(state)?.get(attempt.attemptId);
+    await Promise.allSettled(running?.stops.map(stop => stop()) ?? []);
+    const receipts = await attemptReceipts(state, attempt.attemptId);
+    // The stage owns receipt writes; an earlier snapshot must not overwrite its terminal receipt.
+    for (const receipt of receipts) {
+        for (const process of receipt.processes) {
+            await stopProductionGroup(process);
+        }
+    }
+    if (running)
+        await Promise.race([running.task.catch(() => undefined), new Promise(resolve => setTimeout(resolve, 5000))]);
+    const dispatchStopped = !active.get(state)?.has(attempt.attemptId);
+    // A launch can publish its receipt after cancellation's first snapshot.
+    const durable = await attemptReceipts(state, attempt.attemptId);
+    // An unfinished receipt may omit a process whose registration could not be persisted.
+    attempt.stopped = dispatchStopped && durable.every(receipt => Boolean(receipt.finishedAt)
+        && receipt.processes.every(process => process.stopped || groupExited(process.pid)));
+    await write(state, attemptPath(state, attempt.attemptId), attempt);
+    return { status: attempt.stopped ? 'completed' : 'unknown', result: {
+            executionStopped: attempt.stopped, managedWritesStopped: attempt.stopped,
+            receipts: Object.fromEntries(durable.map(receipt => [receipt.stage, { status: receipt.status, result: receipt.result }])),
+        } };
+}
+export async function sandboxProductionReceipt(state, operationId, identity) {
+    if (!/^[a-f0-9-]{36}:(capture-source|prepare|generate|freeze|save|build|preview)$/.test(operationId))
+        throw new Error('production_receipt_invalid');
+    const [attemptId, stage] = operationId.split(':');
+    const receipt = await read(receiptPath(state, attemptId, stage));
+    if (!receipt || receipt.taskId !== identity.taskId || receipt.attemptId !== identity.attemptId || receipt.workspaceId !== identity.workspaceId
+        || receipt.directoryName !== identity.directoryName || receipt.fence > identity.fence)
+        throw new Error('production_receipt_scope_mismatch');
+    const attempt = await read(attemptPath(state, identity.attemptId));
+    if (!attempt || attempt.owner !== identity.owner || attempt.fence !== identity.fence)
+        throw new Error('production_receipt_scope_mismatch');
+    return { status: receipt.status, result: receipt.result };
+}

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

@@ -0,0 +1,60 @@
+import { readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+const LOCKS = [
+    ['package-lock.json', 'npm'], ['npm-shrinkwrap.json', 'npm'], ['pnpm-lock.yaml', 'pnpm'],
+    ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'],
+];
+const hash = (body) => createHash('sha256').update(body).digest('hex');
+async function optional(path) {
+    try {
+        return await readFile(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+/** Resolve one locked toolchain. A conflicting lock or floating declaration never silently selects npm. */
+export async function resolveProductionDependencies(root) {
+    const packageBody = await readFile(join(root, 'package.json'));
+    const pkg = JSON.parse(packageBody.toString());
+    const bodies = new Map();
+    const managers = new Set();
+    for (const [name, manager] of LOCKS) {
+        const body = await optional(join(root, name));
+        if (body) {
+            bodies.set(name, body);
+            managers.add(manager);
+        }
+    }
+    if (!managers.size)
+        throw new Error('production_dependency_lock_required');
+    if (managers.size !== 1)
+        throw new Error('production_dependency_locks_conflict');
+    const manager = [...managers][0];
+    if (manager !== 'pnpm')
+        throw new Error('production_pnpm_required_convert_first');
+    const declared = typeof pkg.packageManager === 'string'
+        ? /^(npm|pnpm|yarn|bun)@(\d+\.\d+\.\d+)(?:\+sha(?:224|512)\.[a-fA-F0-9]+)?$/.exec(pkg.packageManager) : undefined;
+    if (pkg.packageManager !== undefined && !declared)
+        throw new Error('production_package_manager_declaration_invalid');
+    if (declared && declared[1] !== manager)
+        throw new Error('production_package_manager_lock_mismatch');
+    const modernYarn = false;
+    const pnpmLock = bodies.get('pnpm-lock.yaml')?.toString();
+    const oldPnpm = /^lockfileVersion:\s*['\"]?6(?:\.|['\"]?\s*$)/m.test(pnpmLock ?? '');
+    const version = declared?.[2] ?? (oldPnpm ? '8.15.9' : '9.15.9');
+    return { manager, version, reference: declared ? String(pkg.packageManager) : `${manager}@${version}`, modernYarn,
+        locks: Object.fromEntries([...bodies].map(([name, body]) => [name, hash(body)])), packageDigest: hash(packageBody) };
+}
+export async function verifyProductionDependencyLocks(root, policy) {
+    for (const [name] of LOCKS) {
+        const body = await optional(join(root, name));
+        if ((body ? hash(body) : undefined) !== policy.locks[name])
+            throw new Error('production_dependency_lock_changed');
+    }
+    if (hash(await readFile(join(root, 'package.json'))) !== policy.packageDigest)
+        throw new Error('production_dependency_manifest_changed');
+}

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

@@ -0,0 +1,212 @@
+import { join } from 'node:path';
+import { lstat, mkdir } from 'node:fs/promises';
+import { hashOperationPayload, operationScopeKey, productionSessionId, transitionOperation } from '@playcraft/common/cloud-workspace/runtime';
+import { createCodexAppServerAdapter } from '../codex/app-server.js';
+import { ingestCollected, publishSourceEvents, recordNativeEvents } from '../server/dispatch.js';
+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');
+    const temporaryRoot = join(root, '.playcraft-temp');
+    const existing = await lstat(temporaryRoot).catch(error => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (existing && (!existing.isDirectory() || existing.isSymbolicLink()))
+        throw new Error('production_source_path_invalid');
+    await mkdir(temporaryRoot, { recursive: true });
+    await openDirectoryToDevelopment(temporaryRoot, (await lstat(root)).gid);
+    const groups = [];
+    const adapter = createCodexAppServerAdapter({ config: { ...state.config, workspaceMode: 'single', workspaceRoot: root },
+        command: process.env.PLAYCRAFT_PRODUCTION_CODEX_COMMAND,
+        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: {
+                approval_policy: 'never', sandbox_mode: 'workspace-write',
+                'sandbox_workspace_write.writable_roots': [root],
+                '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: join(temporaryRoot, 'tool-requests'), PLAYCRAFT_SKIP_UPDATE_CHECK: '1',
+                    TMPDIR: temporaryRoot, npm_config_cache: join(temporaryRoot, 'npm-cache'), npm_config_store_dir: join(temporaryRoot, 'pnpm-store') },
+                'model_providers.playcraft_production': { name: 'PlayCraft Production', base_url: input.model.endpoint,
+                    wire_api: 'responses', requires_openai_auth: false, http_headers: { Authorization: `Bearer ${input.model.token}` } },
+            } },
+        onSkillProcessRestart: async (process) => {
+            const group = { pid: process.pid, birth: await processBirth(process.pid), stopped: false };
+            groups.push(group);
+            await record(group);
+        },
+    });
+    const sessionId = productionSessionId(input.task.attemptId);
+    const prompt = String(input.payload.prompt ?? '');
+    const now = new Date().toISOString();
+    const operation = {
+        operationId: `${input.task.attemptId}:generate`, clientRequestId: `${input.task.attemptId}:generate`,
+        environment: input.task.environment, userId: input.task.userId, workspaceId: input.task.workspaceId,
+        directoryName: input.directoryName, sessionId, kind: 'session.turn', status: 'dispatched',
+        generation: state.config.generation, runtimeEpoch: state.runtimeEpoch,
+        payloadHash: hashOperationPayload({ text: prompt }), createdAt: now, updatedAt: now,
+    };
+    const scopeKey = operationScopeKey(operation);
+    let collecting = Promise.resolve();
+    let notifying;
+    let pendingNotifications = [];
+    const notify = (events) => {
+        // Notifications only wake the source archive; every event already belongs to the durable journal.
+        pendingNotifications = [...pendingNotifications, ...events].slice(-100);
+        notifying ??= (async () => {
+            while (pendingNotifications.length) {
+                const page = pendingNotifications;
+                pendingNotifications = [];
+                await publishSourceEvents(state, page);
+            }
+        })().finally(() => {
+            notifying = undefined;
+            if (pendingNotifications.length)
+                notify([]);
+        });
+    };
+    let archiveError;
+    let shutdownError;
+    let cancelled = false;
+    let rootThreadId;
+    let rootTurnId;
+    let completedTurn;
+    let timeout;
+    let leaseCheck;
+    let completion;
+    const done = new Promise(resolve => { completion = resolve; });
+    track(async () => {
+        cancelled = true;
+        completion('unknown');
+        await adapter.close?.();
+        await collecting;
+    });
+    const unsubscribe = adapter.onCollected?.(event => {
+        if (event.kind === 'process_exit')
+            completion('unknown');
+        else {
+            const params = event.params && typeof event.params === 'object'
+                ? event.params : {};
+            // The prompt is recorded before dispatch; Codex may echo the same user message afterward.
+            if (params.item?.type !== 'userMessage' || params.threadId !== rootThreadId) {
+                collecting = collecting.then(async () => notify(await ingestCollected(state, {
+                    ...event, params: { ...params, directoryName: input.directoryName },
+                }, false))).catch(error => {
+                    archiveError ??= error;
+                    completion('unknown');
+                });
+            }
+        }
+        if (event.method === 'turn/completed') {
+            const value = event.params;
+            if (value.threadId === rootThreadId && value.turn?.id) {
+                completedTurn = value.turn;
+                if (value.turn.id === rootTurnId)
+                    completion(value.turn.status === 'completed' ? 'completed' : 'failed');
+            }
+        }
+    });
+    try {
+        await adapter.start();
+        const process = adapter.executionProcess?.();
+        if (!process)
+            throw new Error('production_process_not_started');
+        const group = { pid: process.pid, birth: await processBirth(process.pid), stopped: false };
+        groups.push(group);
+        await record(group);
+        const thread = await adapter.startThread({ sessionId, cwd: root });
+        rootThreadId = thread.threadId;
+        // A production thread lives in its own Codex home and must never resume through the main adapter.
+        await state.journal.putSession({ sessionId, workspaceId: input.task.workspaceId, directoryName: input.directoryName,
+            threadId: thread.threadId, cwd: root, recoverability: 'history_only', turnStatus: 'starting' });
+        const creation = { ...operation, operationId: `${input.task.attemptId}:session.create`,
+            clientRequestId: `${input.task.attemptId}:session.create`, kind: 'session.create', status: 'completed',
+            payloadHash: hashOperationPayload({}), nativeThreadId: thread.threadId };
+        await state.journal.putOperation(operationScopeKey(creation), creation);
+        await state.journal.putOperation(scopeKey, { ...operation, nativeThreadId: thread.threadId });
+        notify(await recordNativeEvents(state, creation, [{ type: 'session.created', occurredAt: now, payload: {
+                    sessionId, threadId: thread.threadId, batchId: input.task.batchId, attemptId: input.task.attemptId,
+                    taskId: input.task.taskId, readonly: true, recoverability: 'history_only',
+                } }], false));
+        notify(await recordNativeEvents(state, operation, [{ type: 'item/completed', occurredAt: now, payload: {
+                    item: { id: `${sessionId}-prompt`, type: 'userMessage', content: [{ type: 'text', text: prompt }] },
+                } }], false));
+        const turn = await adapter.startTurn({ sessionId, threadId: thread.threadId, text: prompt,
+            clientRequestId: operation.clientRequestId, persistReservation: async ({ nativeRequestId }) => {
+                await state.journal.putOperation(scopeKey, { ...operation, nativeThreadId: thread.threadId, nativeRequestId });
+            } });
+        if (turn.outcome !== 'accepted')
+            throw new Error(turn.outcome === 'failed' ? 'production_native_failed' : 'production_native_start_unknown');
+        rootTurnId = turn.turnId;
+        const reserved = state.journal.getOperation(scopeKey);
+        const released = await state.journal.bindTurn({ scopeKey, sessionId, threadId: thread.threadId, turnId: turn.turnId,
+            operation: transitionOperation(reserved, 'accepted', { nativeThreadId: thread.threadId, nativeTurnId: turn.turnId }) });
+        if (released.length)
+            notify(released);
+        if (completedTurn?.id === rootTurnId)
+            completion(completedTurn.status === 'completed' ? 'completed' : 'failed');
+        timeout = setTimeout(() => completion('unknown'), 30 * 60_000);
+        let checking = false;
+        let consecutiveLeaseFailures = 0;
+        leaseCheck = setInterval(() => {
+            if (checking)
+                return;
+            checking = true;
+            void verifyProductionLease(input).then(() => { consecutiveLeaseFailures = 0; }).catch(async () => {
+                consecutiveLeaseFailures += 1;
+                if (consecutiveLeaseFailures >= 2) {
+                    completion('unknown');
+                    await adapter.close?.().catch(() => undefined);
+                }
+            }).finally(() => { checking = false; });
+        }, 5000);
+        const status = await done;
+        if (status !== 'completed')
+            throw new Error(status === 'failed' ? 'production_native_failed' : 'production_native_unknown');
+    }
+    finally {
+        clearInterval(leaseCheck);
+        clearTimeout(timeout);
+        await adapter.close?.().catch(error => { shutdownError = error; });
+        unsubscribe?.();
+        await collecting;
+        for (const group of groups)
+            await record({ ...group, stopped: await stopProductionGroup(group) });
+        const latest = state.journal.getOperation(scopeKey);
+        if (latest && ['dispatched', 'accepted', 'uncertain'].includes(latest.status)) {
+            const status = cancelled ? 'interrupted' : 'failed';
+            await state.journal.putOperation(scopeKey, transitionOperation(latest, status, {
+                error: cancelled ? 'production_execution_stopped' : 'production_native_unknown',
+            }));
+            const session = state.journal.getSession(sessionId);
+            if (session) {
+                await state.journal.putSession({ ...session, turnStatus: status, turnBlock: undefined });
+                notify(await recordNativeEvents(state, latest, [{ type: `turn.${status}`, occurredAt: new Date().toISOString(),
+                        payload: { turnId: latest.nativeTurnId, error: cancelled ? 'production_execution_stopped' : 'production_native_unknown' } }], false));
+            }
+        }
+        if (archiveError)
+            throw new Error('production_chat_archive_failed');
+        if (shutdownError) {
+            const error = shutdownError;
+            const known = new Set(['launcher_output_drain_unconfirmed', 'launcher_instance_changed',
+                'execution_identity_mismatch', 'launcher_request_timeout', 'launcher_connection_closed',
+                'codex_group_stop_unconfirmed', 'codex_stdio_stop_unconfirmed', 'EACCES', 'EPERM', 'ENOTEMPTY', 'EIO']);
+            const reason = [error?.code, error?.message].find(value => typeof value === 'string' && known.has(value));
+            // Exception text can contain credentials or command output; only fixed machine codes leave the guest.
+            console.error(JSON.stringify({ event: 'production.native_shutdown_failed', taskId: input.task.taskId,
+                attemptId: input.task.attemptId, stage: input.stage, reason: reason ?? 'unknown' }));
+            throw new Error('production_native_stop_unknown');
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+import { startLauncherProcess } from '../codex/launcher-client.js';
+export async function processBirth(pid) {
+    if (process.platform !== 'linux') {
+        return promisify(execFile)('ps', ['-p', String(pid), '-o', 'lstart='], { timeout: 2000 }).then(value => value.stdout.trim() || undefined, () => undefined);
+    }
+    try {
+        const stat = await readFile(`/proc/${pid}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function groupExited(pid) {
+    try {
+        process.kill(-pid, 0);
+        return false;
+    }
+    catch (error) {
+        return error.code === 'ESRCH';
+    }
+}
+export async function stopProductionGroup(record) {
+    if (record.stopped || groupExited(record.pid))
+        return true;
+    if (record.birth && await processBirth(record.pid) !== record.birth)
+        return false;
+    for (const signal of ['SIGTERM', 'SIGKILL']) {
+        try {
+            process.kill(-record.pid, signal);
+        }
+        catch { /* Recheck whether the whole group exited. */ }
+        const deadline = Date.now() + 2000;
+        while (Date.now() < deadline) {
+            if (groupExited(record.pid))
+                return true;
+            await delay(25);
+        }
+    }
+    return groupExited(record.pid);
+}
+/** Only the save stage receives repository credentials; build and install receive none. */
+export async function runProductionCommand(state, input) {
+    const launcher = !input.trusted ? process.env.PLAYCRAFT_LAUNCHER_SOCKET : undefined;
+    const launched = launcher ? await startLauncherProcess({ socketPath: launcher, processId: input.processId,
+        runtimeEpoch: state.runtimeEpoch, argv: ['/usr/bin/bash', '-lc', input.command], cwd: input.cwd, env: input.env ?? {} }) : undefined;
+    const local = launched ? undefined : spawn('bash', ['-lc', input.command], { cwd: input.cwd,
+        env: { PATH: process.env.PATH, HOME: state.config.stateDir, ...input.env }, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const exited = new Promise(resolve => {
+        if (launched)
+            launched.onExit(resolve);
+        else {
+            local.once('error', () => resolve(undefined));
+            local.once('close', resolve);
+        }
+    });
+    const pid = launched?.pid ?? local?.pid;
+    if (!pid)
+        throw new Error('production_process_not_started');
+    const record = { pid, birth: await processBirth(pid), stopped: false };
+    let output = '';
+    const collect = (chunk) => { output = (output + String(chunk)).slice(-64 * 1024); };
+    (launched?.stdout ?? local.stdout).on('data', collect);
+    (launched?.stderr ?? local.stderr).on('data', collect);
+    launched?.stdin?.end();
+    let stopping;
+    const stop = () => stopping ??= launched
+        ? launched.stop().then(() => true, () => false)
+        : stopProductionGroup(record);
+    // Register before persisting: cancellation can arrive while the launch receipt is written.
+    input.track(async () => {
+        if (await stop()) {
+            record.stopped = true;
+            await input.record(record);
+        }
+    });
+    let timedOut = false;
+    let timeout;
+    try {
+        await input.record(record);
+        const code = await Promise.race([exited, new Promise(resolve => {
+                timeout = setTimeout(() => {
+                    timedOut = true;
+                    void stop().then(() => resolve(undefined), () => resolve(undefined));
+                }, input.timeoutMs);
+            })]);
+        const stopped = await stop();
+        await input.record({ ...record, stopped });
+        return { code: timedOut ? undefined : code, output, stopped };
+    }
+    catch (error) {
+        record.stopped = await stop();
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

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

@@ -0,0 +1,35 @@
+export function productionSaveCommand() {
+    return `set -eu
+status=0
+remote=$(git -c protocol.version=0 -c core.hooksPath=/dev/null ls-remote --exit-code --heads "$PRODUCTION_REPOSITORY" "refs/heads/$PRODUCTION_BRANCH") || status=$?
+if [ "$status" != 0 ] && [ "$status" != 2 ]; then exit "$status"; fi
+if [ "\${PRODUCTION_EXPECTED_PARENT+x}" = x ]; then
+  actual=$(printf '%s' "$remote" | cut -f1)
+  test "$actual" = "$PRODUCTION_EXPECTED_PARENT" || { printf 'production_git_parent_changed\\n' >&2; exit 1; }
+fi
+if [ -n "$remote" ]; then
+  parent=$(printf '%s' "$remote" | cut -f1)
+  git -c protocol.version=0 -c core.hooksPath=/dev/null fetch --no-tags --no-recurse-submodules "$PRODUCTION_REPOSITORY" "refs/heads/$PRODUCTION_BRANCH"
+  test "$(git rev-parse FETCH_HEAD)" = "$parent"
+  git -c core.hooksPath=/dev/null -c core.fsmonitor=false reset --soft FETCH_HEAD
+fi
+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 -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`;
+}