@playcraft/cli 0.1.21 → 0.1.22

package/dist/commands/tools-batch.js

@@ -0,0 +1,59 @@
+import { readFile } from 'node:fs/promises';
+import { batchCreateSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { handleError } from './tools-utils.js';
+const messages = {
+    en: {
+        create: 'Create a batch draft; confirm the whole batch in the browser',
+        input: 'Path to the batch draft JSON (JavaScript Object Notation, 数据交换格式) file',
+        status: 'Read a batch draft and its generation status',
+        id: 'Batch identifier',
+        created: 'Batch draft created',
+        help: '\nDraft shape: { clientRequestId, title, commonGoal, sourceWorkspaceId, engine, variants: [{ variantId, name, changes, preserves }] }\nUse the current workspace identifier as sourceWorkspaceId and a stable clientRequestId for retries. Maximum 10 variants. Confirm the batch in the browser.\n',
+        confirmation: 'Review the baseline and differences, then approve the whole batch in the browser.',
+    },
+    zh: {
+        create: '创建批次草案；整批确认须在浏览器完成',
+        input: '批次草案 JSON (JavaScript Object Notation, 数据交换格式) 文件路径',
+        status: '查询批次草案及生成状态',
+        id: '批次标识',
+        created: '批次草案已创建',
+        help: '\n草案格式：{ clientRequestId, title, commonGoal, sourceWorkspaceId, engine, variants: [{ variantId, name, changes, preserves }] }\nsourceWorkspaceId 填当前 workspace 标识，重试使用稳定的 clientRequestId。最多 10 个变体，整批在浏览器确认。\n',
+        confirmation: '请在浏览器查看基准和差异清单，然后确认整批。',
+    },
+};
+const language = () => /^zh/i.test(process.env.PLAYCRAFT_LANG ?? process.env.LANG ?? '') ? messages.zh : messages.en;
+export async function createBatchDraft(path, client = new AgentApiClient()) {
+    const draft = batchCreateSchema.parse(JSON.parse(await readFile(path, 'utf8')));
+    return client.post('/create-batch', draft);
+}
+export function registerBatchCommands(tools) {
+    const t = language();
+    tools.command('create-batch')
+        .description(t.create)
+        .requiredOption('--input <path>', t.input)
+        .option('--json', 'JSON (JavaScript Object Notation, 数据交换格式)')
+        .addHelpText('after', t.help)
+        .action(async (opts) => {
+        try {
+            const result = await createBatchDraft(opts.input);
+            console.log(opts.json ? JSON.stringify(result, null, 2) : `${t.created}: ${result.batchId}\n${t.confirmation}`);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    tools.command('get-batch')
+        .description(t.status)
+        .requiredOption('--batch-id <id>', t.id)
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const result = await client.get('/get-batch', { batchId: opts.batchId });
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/tools.js

@@ -1,4 +1,5 @@
 import { registerGenerationCommands } from './tools-generation.js';
+import { registerBatchCommands } from './tools-batch.js';
 import { registerProjectCommands } from './tools-project.js';
 import { register3DCommands } from './tools-3d.js';
 import { registerDetectCommand } from './tools-detect.js';
@@ -9,6 +10,7 @@ export function registerToolsCommands(program) {
         .description('后端 /api/agent/tools；运行 playcraft login 后即可直接使用，也支持 .playcraft.json 或 PLAYCRAFT_SANDBOX_TOKEN 环境变量');
     registerGenerationCommands(tools);
     registerProjectCommands(tools);
+    registerBatchCommands(tools);
     register3DCommands(tools);
     registerDetectCommand(tools);
     registerVideoReviewCommand(tools);

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

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { startLauncherProcess } from './launcher-client.js';
 import { chmod, mkdtemp, rm } from 'node:fs/promises';
-import { join } from 'node:path';
+import { relative, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js';
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
@@ -87,7 +87,7 @@ export function createCodexAppServerAdapter(options) {
     async function threadConfig(cwd, modelConfigId, sessionId) {
         try {
             return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId)
-                ?? { modelConfigId: undefined, activate: () => { } };
+                ?? { ...options.fixedThreadConfig, modelConfigId: undefined, activate: () => { } };
         }
         catch (error) {
             const reason = error instanceof Error ? error.message : '';
@@ -100,7 +100,9 @@ export function createCodexAppServerAdapter(options) {
         const { modelConfigId, activate, ...modelConfig } = await threadConfig(cwd, selectedConfigId, sessionId);
         // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
         if (await readProjectSkillsLockFile(cwd) === null) {
-            if (options.config.workspaceMode === 'multi')
+            const scope = relative(options.config.workspaceRoot, cwd);
+            const orchestration = /^[0-9a-f-]{36}$/i.test(scope);
+            if (options.config.workspaceMode === 'multi' && !orchestration)
                 throw new NativePreparationError('workspace_skills_unavailable');
             return { params: modelConfig, modelConfigId, activate, skillsHash: undefined, discoveryHash: undefined };
         }
@@ -234,14 +236,23 @@ export function createCodexAppServerAdapter(options) {
                 cwd: options.config.workspaceRoot,
                 env: { ...process.env, ...options.env, CODEX_HOME: homeDir, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
                 stdio: ['pipe', 'pipe', 'pipe'],
+                detached: options.processGroup === true,
             });
             await new Promise((resolve, reject) => { local.once('spawn', resolve); local.once('error', reject); });
             child = {
                 pid: local.pid, stdin: local.stdin, stdout: local.stdout, stderr: local.stderr,
                 onExit(listener) { local.once('exit', listener); },
                 async stop() {
-                    if (local.exitCode === null && local.signalCode === null)
-                        local.kill('SIGTERM');
+                    if (local.exitCode === null && local.signalCode === null) {
+                        if (options.processGroup && local.pid) {
+                            try {
+                                process.kill(-local.pid, 'SIGTERM');
+                            }
+                            catch { /* already stopped */ }
+                        }
+                        else
+                            local.kill('SIGTERM');
+                    }
                     await waitForChildExit(local);
                 },
             };

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

@@ -2,9 +2,9 @@ import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
-import { basename } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { z } from 'zod';
-import { workspaceRoot } from '../workspaces/registry.js';
+import { workspaceContextFromRoot } from '../workspaces/registry.js';
 import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const credentialSchema = z.object({
     token: z.string().min(1), expiresAt: z.string().datetime(),
@@ -49,9 +49,9 @@ export class WorkspaceModelBroker {
         return settings;
     }
     async prepareThreadConfig(cwd, modelConfigId, sessionId) {
-        const workspaceId = basename(cwd);
-        if (!this.server || await workspaceRoot(this.state, workspaceId) !== cwd)
+        if (!this.server)
             throw new Error('workspace_not_registered');
+        const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
         if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
             throw new Error('model_config_denied');
         const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
@@ -217,7 +217,7 @@ export class WorkspaceModelBroker {
         }
     }
     cancelSession(cwd, sessionId) {
-        const routeKey = `${basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
+        const routeKey = `${/^(basic|remix-)/.test(basename(cwd)) ? basename(dirname(cwd)) : basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
         const route = this.routes.get(routeKey);
         if (route)
             for (const request of this.sessionRequests.get(route) ?? [])

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

@@ -7,7 +7,7 @@ import { join } from 'node:path';
 import { PREVIEW_HTML_MAX_BYTES, PREVIEW_LOG_TAIL_MAX, previewPublishResultSchema, previewReservationSchema, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
 import { excludeFromGit, readDependencies, scheduleDependencyInstall, } from '../workspaces/dependencies.js';
 import { runDeveloperCommand } from '../workspaces/developer-command.js';
-import { workspaceRoot } from '../workspaces/registry.js';
+import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
 import { classifyPreviewOutput, findExternalLocalReferences } from './single-file.js';
 const BUILD_TIMEOUT_MS = 10 * 60_000;
 /** Build output and the builder's own scratch folder live in the checkout, hidden from Git. */
@@ -36,11 +36,11 @@ export async function previewWorkspaceRoot(state, operation) {
     }
     if (operation.sessionId !== undefined) {
         const session = state.journal.getSession(operation.sessionId);
-        if (!session || (state.config.workspaceMode === 'multi' && session.workspaceId !== operation.workspaceId)) {
+        if (!session || (state.config.workspaceMode === 'multi' && (session.workspaceId !== operation.workspaceId || (session.directoryName ?? 'basic') !== (operation.directoryName ?? 'basic')))) {
             throw new PreviewFailure('session_workspace_mismatch');
         }
     }
-    return workspaceRoot(state, operation.workspaceId);
+    return workspaceRoot(state, operation.workspaceId, operation.directoryName);
 }
 /** Tracks a background publish so tests and shutdown can wait for it. */
 export function trackPreviewPublish(state, task) {
@@ -68,7 +68,7 @@ export async function runPreviewPublish(state, operation, root) {
     const outputDir = join(root, OUTPUT_FOLDER, operation.operationId);
     const output = { log: '' };
     try {
-        await ensureDependencies(state, workspaceId, root, output);
+        await ensureDependencies(state, revisionScope(state, workspaceId, operation.directoryName) ?? workspaceId, root, output);
         await excludeFromGit(root, `/${OUTPUT_FOLDER}/`);
         await excludeFromGit(root, `/${BUILDER_TEMP_FOLDER}/`);
         await buildPreview(state, root, outputDir, operation.operationId, output);
@@ -83,6 +83,7 @@ export async function runPreviewPublish(state, operation, root) {
         const source = await sourceRevision(root);
         const reserved = previewReservationSchema.parse(await postControl(state, '/runtime/internal/preview-reservations', {
             workspaceId,
+            directoryName: operation.directoryName ?? 'basic',
             ...scope,
             operationId: operation.operationId,
             contentDigest,
@@ -112,6 +113,7 @@ export async function runPreviewPublish(state, operation, root) {
         }
         const published = previewPublishResultSchema.parse(await postControl(state, '/runtime/internal/preview-completions', {
             workspaceId,
+            directoryName: operation.directoryName ?? 'basic',
             ...scope,
             operationId: operation.operationId,
             artifactId: reserved.artifactId,
@@ -131,6 +133,7 @@ export async function runPreviewPublish(state, operation, root) {
         if (code !== 'publish_conflict') {
             await postControl(state, '/runtime/internal/preview-failures', {
                 workspaceId,
+                directoryName: operation.directoryName ?? 'basic',
                 ...scope,
                 operationId: operation.operationId,
                 error: code,

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const productionStageNames = ['capture-source', 'prepare', 'generate', 'freeze', 'save', 'build', 'preview'];
+export const productionExecutionRequestSchema = z.object({
+    action: z.enum(['stage', 'stop', 'reconcile']),
+    task: z.object({ taskId: z.string().uuid(), attemptId: z.string().uuid(), batchId: z.string().uuid(), workspaceId: z.string().uuid(),
+        environment: z.string().min(1), userId: z.string().min(1), payload: z.record(z.unknown()), }).passthrough(),
+    lease: z.object({ taskId: z.string().uuid(), attemptId: z.string().uuid(), owner: z.string().min(1), fence: z.number().int().positive() }).strict(),
+    directoryName: z.string().regex(/^(?:basic|remix-[a-z0-9][a-z0-9-]{3,63})$/).default('basic'), generation: z.number().int().positive(), runtimeEpoch: z.number().int().nonnegative(),
+    callbackUrl: z.string().url(), runnerToken: z.string().min(1), payload: z.record(z.unknown()),
+    stage: z.enum(productionStageNames).optional(),
+    stages: z.array(z.object({ stage: z.enum(productionStageNames), requestId: z.string(), status: z.string(),
+        result: z.record(z.unknown()).optional(), payload: z.record(z.unknown()).optional() }).passthrough()).optional(),
+    source: z.object({ workspaceId: z.string().uuid(), generation: z.number().int().positive(), runtimeId: z.string().min(1) }).optional(),
+    model: z.object({ endpoint: z.string().url(), token: z.string().min(1), model: z.string().min(1) }).optional(),
+    git: z.object({ repositoryUrl: z.string().min(1), branchName: z.string().min(1), username: z.string().optional(), password: z.string().optional() }).optional(),
+    repairSnapshot: z.unknown().optional(), repairSource: z.unknown().optional(), repairCommitHash: z.string().optional(),
+}).strict();

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

@@ -0,0 +1,207 @@
+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') {
+    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));
+        if (attempt && !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');
+            if (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 };
+        }
+        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(() => []);
+    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);
+    let groupsStopped = true;
+    for (const receipt of receipts) {
+        for (const process of receipt.processes) {
+            process.stopped = await stopProductionGroup(process);
+            if (!process.stopped)
+                groupsStopped = false;
+        }
+        await write(state, receiptPath(state, receipt.attemptId, receipt.stage), receipt);
+    }
+    if (running)
+        await Promise.race([running.task.catch(() => undefined), new Promise(resolve => setTimeout(resolve, 5000))]);
+    const dispatchStopped = !active.get(state)?.has(attempt.attemptId);
+    attempt.stopped = groupsStopped && dispatchStopped;
+    await write(state, attemptPath(state, attempt.attemptId), attempt);
+    const durable = await attemptReceipts(state, attempt.attemptId);
+    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,70 @@
+import { join } from 'node:path';
+import { createCodexAppServerAdapter } from '../codex/app-server.js';
+import { verifyProductionLease } from './storage.js';
+import { processBirth, stopProductionGroup } from './processes.js';
+export async function runProductionNative(state, input, root, record, track) {
+    if (!input.model)
+        throw new Error('production_model_configuration_required');
+    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,
+        fixedThreadConfig: { model: input.model.model, modelProvider: 'playcraft_production', config: {
+                approval_policy: 'never', sandbox_mode: 'danger-full-access',
+                '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);
+        },
+    });
+    track(() => adapter.close());
+    const sessionId = `production-${input.task.attemptId}`;
+    let completion;
+    const done = new Promise(resolve => { completion = resolve; });
+    const unsubscribe = adapter.onCollected?.(event => {
+        if (event.kind === 'process_exit')
+            completion('unknown');
+        if (event.method === 'turn/completed') {
+            const value = event.params;
+            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 });
+        const turn = await adapter.startTurn({ sessionId, threadId: thread.threadId, text: String(input.payload.prompt ?? ''),
+            clientRequestId: `${input.task.attemptId}:generate`, persistReservation: async () => undefined });
+        if (turn.outcome !== 'accepted')
+            throw new Error('production_native_start_unknown');
+        const timeout = setTimeout(() => completion('unknown'), 30 * 60_000);
+        let checking = false;
+        const leaseCheck = setInterval(() => {
+            if (checking)
+                return;
+            checking = true;
+            void verifyProductionLease(input).catch(async () => { completion('unknown'); await adapter.close?.().catch(() => undefined); }).finally(() => { checking = false; });
+        }, 5000);
+        const status = await done;
+        clearInterval(leaseCheck);
+        clearTimeout(timeout);
+        if (status !== 'completed')
+            throw new Error(status === 'failed' ? 'production_native_failed' : 'production_native_unknown');
+    }
+    finally {
+        unsubscribe?.();
+        await adapter.close?.().catch(() => undefined);
+        for (const group of groups)
+            await record({ ...group, stopped: await stopProductionGroup(group) });
+    }
+}