@playcraft/cli 0.1.55-beta → 0.1.57-beta

package/dist/assets/client.js

@@ -120,7 +120,9 @@ export async function downloadAssetTask(client, scope, taskId, output, versionId
     const staging = await mkdtemp(join(dirname(destination), '.playcraft-asset-'));
     let createdDestination = false;
     try {
-        const files = bundle?.files ?? [{ ...entry, path: 'output', fileId: undefined }];
+        const multiple = !bundle && !versionId && Boolean(task.outputs);
+        const directory = Boolean(bundle || multiple);
+        const files = bundle?.files ?? (multiple ? task.outputs.map(file => ({ ...file, path: file.name })) : [{ ...entry, path: 'output', fileId: undefined }]);
         const paths = [];
         for (const file of files) {
             const temporary = resolve(staging, file.path);
@@ -128,11 +130,11 @@ export async function downloadAssetTask(client, scope, taskId, output, versionId
             if (!inside || inside === '..' || inside.startsWith(`..${sep}`))
                 throw new Error(t('invalidContent'));
             await mkdir(dirname(temporary), { recursive: true });
-            await client.download(assetContentRoute({ ...scope, taskId, ...(bundle ? { fileId: file.fileId } : {}), ...(versionId ? { versionId } : {}) }), temporary);
+            await client.download(assetContentRoute({ ...scope, taskId, ...(directory ? { fileId: file.fileId } : {}), ...(versionId ? { versionId } : {}) }), temporary);
             await verifyFile(temporary, file);
-            paths.push(bundle ? join(destination, file.path) : destination);
+            paths.push(directory ? join(destination, file.path) : destination);
         }
-        if (bundle) {
+        if (directory) {
             // mkdir is exclusive; an existing directory or symbolic link cannot be replaced.
             await mkdir(destination);
             createdDestination = true;

package/dist/commands/build.js

@@ -6,6 +6,10 @@ import { BaseBuilder, ViteBuilder, PlayableBuilder, PlayableAnalyzer, EngineDete
 import { loadBuildConfig } from '../build-config.js';
 import { cleanupBuildTempDirectory, createBuildTempDirectory } from './build-temp.js';
 import inquirer from 'inquirer';
+import { tmpdir } from 'node:os';
+import { generatedWorkspace } from '../workspace-runtime/workspaces/artifact-receipts.js';
+import { isolateWorkspaceForBuild } from '../workspace-runtime/workspaces/delivery-build.js';
+import { finalizeWorkspacePlayable, workspacePlayableSignature } from '../workspace-runtime/previews/finalize.js';
 /**
  * 类型守卫：检查对象是否符合 PlayableScriptsConfig 类型
  */
@@ -245,6 +249,38 @@ async function analyzeBaseBuild(baseBuildDir, ammoReplacement) {
 export async function buildCommand(projectPath, options) {
     // 解析项目路径 - 在 spinner 之前执行以便调试
     const resolvedProjectPath = path.resolve(projectPath);
+    const workspace = options.workspaceArtifact !== false && process.env.PLAYCRAFT_BUILD_ISOLATED !== '1' && options.mode === 'full' && options.platform === 'playcraft'
+        && (!options.format || options.format === 'html') ? await generatedWorkspace(resolvedProjectPath) : undefined;
+    const requestedOutput = options.output ? path.resolve(options.output) : path.join(resolvedProjectPath, 'dist');
+    const canonicalOutput = [path.join(resolvedProjectPath, 'dist'), path.join(resolvedProjectPath, 'dist/playable')].includes(requestedOutput);
+    if (workspace?.root === resolvedProjectPath) {
+        const prefix = requestedOutput.endsWith(path.sep) ? requestedOutput : `${requestedOutput}${path.sep}`;
+        if (requestedOutput === workspace.root || workspace.root.startsWith(prefix))
+            throw new Error('invalid_build_output');
+        const scratch = await fs.mkdtemp(path.join(tmpdir(), 'playcraft-workspace-build-'));
+        try {
+            const signature = canonicalOutput ? await workspacePlayableSignature(workspace.root) : undefined;
+            const project = path.join(scratch, 'project'), output = path.join(scratch, 'output');
+            await isolateWorkspaceForBuild(workspace.root, project);
+            await buildCommand(project, { ...options, workspaceArtifact: false, output });
+            if (canonicalOutput) {
+                const entries = await fs.readdir(output, { withFileTypes: true });
+                if (entries.length !== 1 || !entries[0].isFile() || !entries[0].name.endsWith('.html'))
+                    throw new Error('preview_not_single_file');
+                await finalizeWorkspacePlayable(workspace.root, await fs.readFile(path.join(output, entries[0].name)), 'playcraft build', { expectedSignature: signature });
+            }
+            else {
+                if (options.clean === true)
+                    await fs.rm(requestedOutput, { recursive: true, force: true });
+                await fs.cp(output, requestedOutput, { recursive: true });
+            }
+            console.log(canonicalOutput ? path.join(workspace.root, 'dist/playable/index.html') : requestedOutput);
+            return;
+        }
+        finally {
+            await fs.rm(scratch, { recursive: true, force: true });
+        }
+    }
     console.log(`[DEBUG] projectPath: ${projectPath}`);
     console.log(`[DEBUG] resolvedProjectPath: ${resolvedProjectPath}`);
     console.log(`[DEBUG] cwd: ${process.cwd()}`);
@@ -982,6 +1018,8 @@ export async function buildCommand(projectPath, options) {
         if (error.stack) {
             console.error(pc.dim(error.stack));
         }
+        if (options.workspaceArtifact === false)
+            throw error;
         process.exit(1);
     }
 }

package/dist/commands/tools-3d.js

@@ -46,6 +46,7 @@ export function register3DCommands(tools) {
         .description('Generate a 3D model from a text prompt or input image (uses HunyuanTo3D or configured provider)')
         .option('--prompt <text>', 'Text description of the 3D model to generate')
         .option('--input <path>', 'Input image (local path or URL) for image-to-3D generation')
+        .option('--view-image <view=path>', 'Additional local reference for hy-3d-3.1: left|right|back|top|bottom|left_front|right_front; repeat for multiple views', (value, previous) => [...previous, value], [])
         .requiredOption('--output <path>', 'Output model file path')
         .option('--model <ref>', 'Model ref in provider/model-id format (e.g. tencent-cloud/hy-3d-3.1)')
         .option('--format <fmt>', 'Output format: glb|obj|stl|fbx|usdz (default: glb)', 'glb')
@@ -77,6 +78,20 @@ export function register3DCommands(tools) {
                 payload.enablePBR = true;
             if (opts.polygonType)
                 payload.polygonType = opts.polygonType;
+            if (opts.viewImage.length) {
+                const views = new Set(['left', 'right', 'back', 'top', 'bottom', 'left_front', 'right_front']);
+                const seen = new Set();
+                if (!opts.input || opts.viewImage.length > 7 || opts.model && opts.model !== 'tencent-cloud/hy-3d-3.1')
+                    throw new Error('--view-image requires --input and hy-3d-3.1 (at most 7 unique views)');
+                payload.multiViewImages = opts.viewImage.map((value) => {
+                    const separator = value.indexOf('='), view = value.slice(0, separator), imagePath = value.slice(separator + 1);
+                    if (separator < 1 || !imagePath || !views.has(view) || seen.has(view))
+                        throw new Error('--view-image expects a unique view=path, e.g. back=./back.png');
+                    seen.add(view);
+                    return { view: view,
+                        imageBase64: readFileSync(imagePath).toString('base64'), mimeType: mimeTypeForImagePath(imagePath) };
+                });
+            }
             if (opts.input) {
                 let inputImageBase64;
                 let inputImageMimeType = opts.inputMime;

package/dist/commands/tools-generation.js

@@ -6,6 +6,7 @@ import { captureGeneratedArtifact } from '../workspace-runtime/workspaces/artifa
 import { resolveImageBackgroundRequirement, validateImageDeliveryOptions } from '@playcraft/common/prefab';
 import { assertImageAssetOutputPaths, readImageAssetContext } from '../utils/image-asset-context.js';
 import { AgentApiClient } from '../utils/agent-api-client.js';
+import { isUnsafeImageRetryError } from '../utils/image-generation-retry.js';
 import { MAX_REFERENCE_IMAGES, collectReferenceImagePaths, parseImageTargetFieldPath, collectReferenceImagePayloads, sniffImageExtension, extensionForImageMime, resolveImageOutputPath, handleError, raceWithTimeout, } from './tools-utils.js';
 function isMasterCompositeStripRequest(opts) {
     if (opts.aspectRatio === '45:16')
@@ -285,7 +286,7 @@ export function registerGenerationCommands(tools) {
                     lastError = e;
                     const msg = e instanceof Error ? e.message : String(e);
                     const isTimeout = msg.includes('timed out');
-                    const cannotRetry = /source_transparency_invalid|output_transparency_invalid|transparency_unsupported|"retryable"\s*:\s*false/.test(msg);
+                    const cannotRetry = isUnsafeImageRetryError(e);
                     if (isTimeout || cannotRetry) {
                         console.error(`Attempt ${attempt + 1} stopped: ${msg}`);
                         break;
@@ -433,7 +434,7 @@ export function registerGenerationCommands(tools) {
     tools.command('generate-sfx')
         .description('AI 生成音效（SFX），使用 ElevenLabs Sound Effects')
         .requiredOption('--prompt <text>', '音效描述，仅英文，如 "crisp UI click, short tail, no voice"')
-        .option('--duration <seconds>', '时长（秒，0.5-30）', parseFloat)
+        .option('--duration <seconds>', '时长（秒，0.5-22；省略时由供应商自动决定）', parseFloat)
         .option('--loop', '生成可循环的音效', false)
         .requiredOption('--output <path>', '保存路径，如 ./assets/audio/click.mp3')
         .action(async (opts) => {

package/dist/utils/agent-api-client.js

@@ -9,8 +9,10 @@ import { homedir } from 'os';
 import { loadGlobalConfig } from '../config.js';
 import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
 import { AGENT_TOOL_OPERATION_PROTOCOL, AGENT_TOOL_OPERATION_HEADERS, AGENT_TOOL_OPERATION_CAPABILITIES_PATH, } from '@playcraft/common/agent-tools';
-import { beginToolOperation } from './tool-operation-journal.js';
+import { beginToolOperation, findToolOperation } from './tool-operation-journal.js';
 import { businessEndpoint } from './environment-endpoints.js';
+import { cloudRuntimeCredentialHint, isWorkspaceGenerationPath, withGenerationWorkspaceScope } from './generation-workspace-scope.js';
+import { agentGenerationProvenanceHeaders } from './agent-generation-provenance.js';
 import { redactDiagnosticText } from './error-diagnostics.js';
 import { AccountActivationError, parseErrorPayload, pendingAccountActivationError, } from '../auth/account-activation.js';
 /**
@@ -37,6 +39,7 @@ export class AgentApiClient {
     token;
     credentialFile;
     playcraftEnv;
+    cloudRuntimeCredential;
     constructor() {
         const localConfig = AgentApiClient.loadLocalConfig();
         const globalConfig = loadGlobalConfig();
@@ -59,6 +62,7 @@ export class AgentApiClient {
         this.token = token;
         this.credentialFile = localConfig.credentialFile;
         this.playcraftEnv = (process.env.PLAYCRAFT_ENV || localConfig.env || '').trim();
+        this.cloudRuntimeCredential = cloudRuntimeCredentialHint(token, token === localConfig.token ? localConfig : undefined);
     }
     /** 根据 token 类型构造鉴权 headers */
     authHeaders() {
@@ -85,12 +89,26 @@ export class AgentApiClient {
     }
     async post(path, body, options) {
         const url = this.toolsRequestUrl(path);
-        const serializedBody = JSON.stringify(body);
-        if (serializedBody === undefined)
+        const originalBody = JSON.stringify(body);
+        if (originalBody === undefined)
             throw new Error('Tool request body is required');
         const recoverId = options?.requestId ?? process.env.PLAYCRAFT_TOOL_REQUEST_ID;
+        const newRequest = options?.newRequest ?? process.env.PLAYCRAFT_TOOL_NEW_REQUEST === '1';
+        const originalReceipt = recoverId !== undefined && !newRequest && isWorkspaceGenerationPath(path)
+            ? findToolOperation(url.pathname, originalBody, recoverId) : undefined;
+        let serializedBody = originalReceipt ? originalBody : JSON.stringify(await withGenerationWorkspaceScope(path, body, this.cloudRuntimeCredential));
+        if (serializedBody === undefined)
+            throw new Error('Tool request body is required');
+        if (serializedBody !== originalBody && !newRequest) {
+            const previous = findToolOperation(url.pathname, originalBody, recoverId);
+            if (previous && recoverId !== undefined)
+                serializedBody = originalBody;
+            else if (previous)
+                throw new Error(`Previous unscoped tool request ${previous.requestId} is still unconfirmed. ` +
+                    `Rerun this command with PLAYCRAFT_TOOL_REQUEST_ID=${previous.requestId} to read its settled receipt before starting a workspace generation. No generation was sent.`);
+        }
         const operation = beginToolOperation(url.pathname, serializedBody, recoverId, {
-            newRequest: options?.newRequest ?? process.env.PLAYCRAFT_TOOL_NEW_REQUEST === '1',
+            newRequest,
         });
         const unknownOutcome = `Tool request ${operation.requestId}: the outcome is unknown. Rerun the same command to ` +
             `continue this request: it returns the result if the request finished, or finishes it if ` +
@@ -135,6 +153,7 @@ export class AgentApiClient {
                 headers: {
                     'Content-Type': 'application/json',
                     ...this.authHeaders(),
+                    ...await agentGenerationProvenanceHeaders(path, serializedBody, operation.requestId, this.cloudRuntimeCredential, options?.signal),
                     [AGENT_TOOL_OPERATION_HEADERS.protocol]: AGENT_TOOL_OPERATION_PROTOCOL,
                     [AGENT_TOOL_OPERATION_HEADERS.requestId]: operation.requestId,
                     ...(operation.settledOnly ? { [AGENT_TOOL_OPERATION_HEADERS.settledOnly]: 'true' } : {}),
@@ -163,11 +182,15 @@ export class AgentApiClient {
                 const pending = pendingAccountActivationError(res.status, parseErrorPayload(text));
                 if (pending)
                     throw pending;
+                if (isWorkspaceGenerationPath(path) && res.headers.get('x-playcraft-generation-outcome') === 'failed') {
+                    operation.reject();
+                    throw new ToolRequestError(`API ${res.status}: ${text}`);
+                }
                 const code = errorCode(text);
-                if (res.status === 409 && code === 'business_operation_in_progress')
+                if (res.status === 409 && (code === 'business_operation_in_progress' || code === 'asset_generation_in_progress'))
                     throw new ToolRequestError(`API 409: ${text}\nTool request ${operation.requestId} is still running. Rerun the ` +
                         'same command later to get its result.');
-                if (res.status === 409 && code === 'business_operation_requires_reconciliation')
+                if (res.status === 409 && (code === 'business_operation_requires_reconciliation' || code === 'asset_generation_outcome_unknown'))
                     throw new ToolRequestError(recoverId !== undefined
                         ? // A receipt query never runs the request, even for a tool that can be safely redone.
                             `API 409: ${text}\nTool request ${operation.requestId} has no settled result yet. ` +
@@ -331,8 +354,8 @@ function responseErrorReason(text) {
 }
 function errorCode(text) {
     try {
-        const message = JSON.parse(text).message;
-        return typeof message === 'string' ? message : undefined;
+        const payload = JSON.parse(text);
+        return typeof payload.code === 'string' ? payload.code : typeof payload.message === 'string' ? payload.message : undefined;
     }
     catch {
         return undefined;

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

@@ -0,0 +1,45 @@
+import { hashOperationPayload, AGENT_GENERATION_PROVENANCE_HEADER } from '@playcraft/common/cloud-workspace/runtime';
+import { isWorkspaceGenerationPath } from './generation-workspace-scope.js';
+/** Attribution is optional; only the controlled local broker can attest an execution. */
+export async function agentGenerationProvenanceHeaders(path, body, requestId, cloudRuntime, signal) {
+    if (!cloudRuntime)
+        return {};
+    const normalized = path.startsWith('/') ? path : `/${path}`;
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        return {};
+    }
+    const assetCreate = normalized === '/workspace-assets' && payload?.action === 'create';
+    if (!isWorkspaceGenerationPath(normalized) && !assetCreate)
+        return {};
+    const endpoint = process.env.PLAYCRAFT_AGENT_GENERATION_ENDPOINT;
+    const capability = process.env.PLAYCRAFT_AGENT_GENERATION_CAPABILITY;
+    if (!endpoint || !capability || capability.length > 128 || endpoint.length > 1024)
+        return {};
+    try {
+        const url = new URL(endpoint);
+        if (url.protocol !== 'http:' || url.hostname !== '127.0.0.1' || !url.port || url.username || url.password
+            || url.search || url.hash || !/\/[0-9a-f-]{36}\/[0-9a-f]{32}\/generation-provenance$/.test(url.pathname))
+            return {};
+        const response = await fetch(url, {
+            method: 'POST', redirect: 'error',
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000),
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${capability}` },
+            body: JSON.stringify({ toolPath: `/agent/tools${normalized}`,
+                toolRequestId: assetCreate ? payload.clientRequestId : requestId, payloadHash: hashOperationPayload(payload) }),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            return {};
+        }
+        const value = await response.json();
+        return typeof value.proof === 'string' && value.proof.length > 0 && value.proof.length <= 8192
+            ? { [AGENT_GENERATION_PROVENANCE_HEADER]: value.proof } : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/utils/generation-workspace-scope.js

@@ -0,0 +1,50 @@
+import { basename, dirname } from 'node:path';
+import { workspaceDirectoryRegistrationSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { generatedWorkspace } from '../workspace-runtime/workspaces/artifact-receipts.js';
+const generationPaths = new Set([
+    '/generate-image', '/generate-sfx', '/generate-bgm', '/generate-3d',
+    '/generate-texture', '/generate-motion', '/generate-avatar',
+]);
+const workspaceScopeSchema = workspaceDirectoryRegistrationSchema.pick({ workspaceId: true, directoryName: true });
+export function isWorkspaceGenerationPath(path) {
+    return generationPaths.has(path.startsWith('/') ? path : `/${path}`);
+}
+/** Credential metadata only selects routing; the business service still authenticates and authorizes it. */
+export function cloudRuntimeCredentialHint(token, metadata) {
+    if (token.startsWith('playcraft_pat_'))
+        return false;
+    if (metadata?.kind === 'cloud-runtime-cli' || typeof metadata?.runtimeId === 'string' && metadata.runtimeId.trim())
+        return true;
+    const parts = token.split('.');
+    if (parts.length !== 3 || parts[1].length > 16 * 1024)
+        return false;
+    try {
+        const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+        return Boolean(payload && typeof payload === 'object' && 'kind' in payload && payload.kind === 'cloud-runtime-cli');
+    }
+    catch {
+        return false;
+    }
+}
+/** Add the current engineering checkout before the durable operation hashes its request. */
+export async function withGenerationWorkspaceScope(path, body, requiresWorkspace, cwd = process.cwd()) {
+    if (!isWorkspaceGenerationPath(path))
+        return body;
+    const context = await generatedWorkspace(cwd);
+    if (!context) {
+        if (requiresWorkspace)
+            throw new Error('Cloud workspace generation requires a current engineering directory; run this command from basic or a remix directory. No generation was sent.');
+        return body;
+    }
+    const parsed = workspaceScopeSchema.safeParse({ workspaceId: context.workspaceId, directoryName: basename(context.root) });
+    if (!parsed.success || basename(dirname(context.root)) !== context.workspaceId)
+        throw new Error('Cloud workspace generation requires a valid basic or remix checkout under its workspace. No generation was sent.');
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        throw new Error('Tool generation request must be an object');
+    if ('workspace' in body && body.workspace !== undefined) {
+        const explicit = workspaceScopeSchema.safeParse(body.workspace);
+        if (!explicit.success || explicit.data.workspaceId !== parsed.data.workspaceId || explicit.data.directoryName !== parsed.data.directoryName)
+            throw new Error('Tool generation workspace does not match the current engineering directory. No generation was sent.');
+    }
+    return { ...body, workspace: parsed.data };
+}

package/dist/utils/image-generation-retry.js

@@ -0,0 +1,7 @@
+/** An uncertain generation may still be billed; retrying must never create another operation. */
+export function isUnsafeImageRetryError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /source_transparency_invalid|output_transparency_invalid|transparency_unsupported|"retryable"\s*:\s*false/.test(message)
+        || /business_operation_(?:in_progress|requires_reconciliation)|asset_generation_(?:in_progress|outcome_unknown)/.test(message)
+        || /outcome is unknown|outcome remains unconfirmed|still unconfirmed|needs reconciliation|no settled result|settled result is not available/i.test(message);
+}

package/dist/utils/tool-operation-journal.js

@@ -97,9 +97,40 @@ export function beginToolOperation(path, serializedBody, recoverId, options = {}
         release: () => inFlight.delete(requestId),
     };
 }
-function findUnconfirmed(directory, path, inputHash) {
+/** Read an existing identity without creating an intent or changing its receipt state. */
+export function findToolOperation(path, serializedBody, requestId) {
+    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
+    if (!isAbsolute(directory))
+        throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
+    const inputHash = createHash('sha256').update(serializedBody).digest('hex');
+    if (requestId === undefined)
+        return findUnconfirmed(directory, path, inputHash, true);
+    if (!isAgentToolRequestId(requestId))
+        return undefined;
+    try {
+        const entry = JSON.parse(readFileSync(join(directory, `${requestId.toLowerCase()}.json`), 'utf8'));
+        if (entry.version === 1 && entry.requestId === requestId.toLowerCase() && entry.path === path && entry.inputHash === inputHash
+            && ['unconfirmed', 'completed', 'rejected'].includes(entry.state))
+            return entry;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return undefined;
+}
+function findUnconfirmed(directory, path, inputHash, includeActive = false) {
     let latest;
-    for (const name of readdirSync(directory)) {
+    let files;
+    try {
+        files = readdirSync(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+    for (const name of files) {
         if (!name.endsWith('.json'))
             continue;
         try {
@@ -112,8 +143,7 @@ function findUnconfirmed(directory, path, inputHash) {
                 (!latest || entry.updatedAt > latest.updatedAt) &&
                 // Still being sent, here or by another live process: that run is not interrupted.
                 // Checked last, so only this command's candidates cost a process probe.
-                !inFlight.has(entry.requestId) &&
-                !holderAlive(entry.holder))
+                (includeActive || !inFlight.has(entry.requestId) && !holderAlive(entry.holder)))
                 latest = entry;
         }
         catch {

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

@@ -5,23 +5,12 @@ import { randomUUID } from 'node:crypto';
 import { sandboxBatchMemberPrepareSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { registerWorkspaceDirectory } from '../workspaces/directories.js';
 import { workspaceContainerRoot } from '../workspaces/registry.js';
+import { dependencyInstallCommand, planInstall } from '../workspaces/dependencies.js';
 import { copyCredentialHelpers, gitRead, gitWrite } from './git.js';
 import { restoreArchive } from './source-capture.js';
 import { groupExited, runProcessGroup } from './processes.js';
 import { filesystemObjectStore, memberStatus, readMember, readSnapshot, readStopMarker, serializeRun, sourceCacheDir, writeMember, } from './records.js';
 const BRANCH = /^remix\/draft-[a-f0-9]{16}$/;
-const LOCKS = [
-    'pnpm-lock.yaml',
-    'package-lock.json',
-    'npm-shrinkwrap.json',
-    'yarn.lock',
-    'bun.lock',
-    'bun.lockb',
-];
-export function frozenInstallCommand() {
-    return (process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ??
-        'pnpm install --frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --ignore-scripts');
-}
 function hashCommand(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
@@ -117,43 +106,6 @@ async function resumeBranch(repositoryUrl, branchName, commit, destination, sour
     }
     await gitWrite(destination, ['checkout', '-B', branchName, commit]);
 }
-export async function assertMemberDependencies(root) {
-    let manifest;
-    try {
-        manifest = await readFile(join(root, 'package.json'), 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return 'skip';
-        throw error;
-    }
-    let names = [];
-    try {
-        const pkg = JSON.parse(manifest);
-        names = [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
-    }
-    catch {
-        throw new Error('dependency_lock_mismatch');
-    }
-    const present = [];
-    for (const lock of LOCKS)
-        if (await lstat(join(root, lock)).catch(() => undefined))
-            present.push(lock);
-    if (present.length > 1)
-        throw new Error('dependency_locks_conflict');
-    if (present.length === 0)
-        return 'skip';
-    if (present[0] !== 'pnpm-lock.yaml')
-        throw new Error('dependency_lock_mismatch');
-    const lock = await readFile(join(root, 'pnpm-lock.yaml'), 'utf8');
-    if (names.some((name) => !lock.includes(`${name}:`) &&
-        !lock.includes(`/${name}@`) &&
-        !lock.includes(`'${name}'`) &&
-        !lock.includes(`"${name}"`))) {
-        throw new Error('dependency_lock_mismatch');
-    }
-    return 'install';
-}
 export async function prepareBatchMember(state, body, options) {
     if (!body ||
         typeof body !== 'object' ||
@@ -241,9 +193,14 @@ export async function prepareBatchMember(state, body, options) {
                 branchName: command.branchName,
                 sourceCommit: command.resumeFromCommit ?? snapshot.commitHash,
             }, state.acceptedLeaseFence);
-            const plan = await assertMemberDependencies(root);
-            if (plan === 'install') {
-                const installed = await runProcessGroup(root, frozenInstallCommand(), 'install', async (process) => {
+            const plan = await planInstall(root);
+            if (plan.kind === 'install') {
+                // Keep control-user installs script-free. pnpm validates the frozen manifest and lock.
+                const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} --ignore-scripts`;
+                const installCommand = process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ?? (plan.hasLockfile
+                    ? frozen
+                    : `${dependencyInstallCommand(state)} --lockfile-only --ignore-scripts && ${frozen}`);
+                const installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
                     record = await writeMember(state, {
                         ...record,
                         processes: [...record.processes, process],

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

@@ -5,7 +5,7 @@ export const WORKSPACE_DELIVERY_TOOLS = [
     {
         type: 'function',
         name: 'playcraft_build_delivery',
-        description: 'Start one formal channel delivery build. Returns build identifiers immediately; poll playcraft_get_delivery for status and validation results. This writes a delivery record under dist/delivery/.',
+        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit; each channel reuses the options of its latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. Returns build ids immediately; poll playcraft_get_delivery for status, checks and failure details.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -24,7 +24,7 @@ export const WORKSPACE_DELIVERY_TOOLS = [
     {
         type: 'function',
         name: 'playcraft_get_delivery',
-        description: 'Read the latest delivery build, or one build by id, including status, validation summary, error and a truncated build log.',
+        description: 'Read one export by build id, or the latest export of a channel (or of any channel) on this branch: status, current stage while running, channel check findings, and for a failed export the failed stage, command, exit code and the end of its stderr/stdout.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -109,8 +109,9 @@ export class WorkspaceDeliveryTools {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
         }
+        // Sandbox builds are UUIDs; platform exports use the build queue's ids.
         if (input.buildId !== undefined && (typeof input.buildId !== 'string'
-            || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(input.buildId))) {
+            || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(input.buildId))) {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
         }
@@ -138,7 +139,8 @@ export class WorkspaceDeliveryTools {
     }
 }
 function errorReason(cause) {
-    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
-        return cause.code;
+    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string') {
+        return cause.message.startsWith(cause.code) ? cause.message.slice(0, 500) : cause.code;
+    }
     return 'delivery_tool_failed';
 }

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { agentGenerationProvenanceRequestSchema, PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
+import { prepareLauncherOrigin, verifyLauncherOrigin } from './launcher-client.js';
+const requestSchema = agentGenerationProvenanceRequestSchema.pick({ toolPath: true, toolRequestId: true, payloadHash: true });
+/** Only an unambiguous, newly launched shell in a controlled turn receives attribution. */
+export class WorkspaceGenerationProvenanceBroker {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    async prepare() {
+        const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+        const root = this.state.native?.executionProcess?.();
+        return socketPath && root ? prepareLauncherOrigin({ socketPath, rootPid: root.pid, runtimeEpoch: this.state.runtimeEpoch }) : undefined;
+    }
+    operation(context) {
+        const active = this.state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind)
+            && ['dispatched', 'accepted', 'uncertain'].includes(operation.status)
+            && operation.generation === this.state.config.generation && operation.runtimeEpoch === this.state.runtimeEpoch);
+        if (active.length !== 1)
+            return undefined;
+        const operation = active[0];
+        const session = this.state.journal.getSession(context.sessionId);
+        if (operation.kind !== 'session.turn' || operation.sessionId !== context.sessionId || operation.clientRequestId !== context.clientRequestId
+            || !operation.nativeThreadId || !operation.nativeTurnId || !operation.workspaceId || !operation.directoryName
+            || !session || session.threadId !== operation.nativeThreadId || session.activeTurnId !== operation.nativeTurnId
+            || session.cwd !== context.cwd || !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
+            return undefined;
+        return operation;
+    }
+    async forward(request, response, context, valid) {
+        const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+        const deny = () => { response.writeHead(403, { 'cache-control': 'no-store' }); response.end(); };
+        try {
+            const operation = this.operation(context);
+            if (!valid() || !socketPath || !context.boundaryId || !operation || request.socket.remoteAddress !== '127.0.0.1'
+                || !request.socket.localPort || !request.socket.remotePort)
+                return deny();
+            let text = '';
+            for await (const chunk of request) {
+                text += chunk.toString();
+                if (text.length > 2048)
+                    return deny();
+            }
+            const parsed = requestSchema.safeParse(JSON.parse(text));
+            if (!parsed.success || !await verifyLauncherOrigin({ socketPath, boundaryId: context.boundaryId,
+                runtimeEpoch: this.state.runtimeEpoch, serverPort: request.socket.localPort, clientPort: request.socket.remotePort, cwd: context.cwd }))
+                return deny();
+            // The socket lookup may take time. Never attest a turn which ended or changed meanwhile.
+            if (!valid() || this.operation(context)?.operationId !== operation.operationId)
+                return deny();
+            const config = this.state.config;
+            const input = agentGenerationProvenanceRequestSchema.parse({ ...parsed.data,
+                runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: this.state.runtimeEpoch,
+                workspaceId: operation.workspaceId, directoryName: operation.directoryName,
+                sessionId: context.sessionId, sessionClientRequestId: context.clientRequestId,
+                nativeThreadId: operation.nativeThreadId, nativeTurnId: operation.nativeTurnId });
+            const upstream = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.agentGenerationProvenance), {
+                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(input),
+            });
+            if (!upstream.ok) {
+                await upstream.body?.cancel();
+                return deny();
+            }
+            const value = z.object({ proof: z.string().min(1).max(8192) }).strict().parse(await upstream.json());
+            if (!valid() || this.operation(context)?.operationId !== operation.operationId)
+                return deny();
+            response.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(value));
+        }
+        catch {
+            if (!response.headersSent)
+                deny();
+            else
+                response.destroy();
+        }
+    }
+}

package/dist/workspace-runtime/codex/launcher-client.js

@@ -33,6 +33,24 @@ function request(socketPath, message) {
         });
     });
 }
+/** The private launcher owns the boundary; development shells never receive its identity. */
+export async function prepareLauncherOrigin(input) {
+    try {
+        const reply = await request(input.socketPath, { action: 'origin-boundary', rootPid: input.rootPid, runtimeEpoch: input.runtimeEpoch });
+        return typeof reply.boundaryId === 'string' ? reply.boundaryId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function verifyLauncherOrigin(input) {
+    try {
+        return (await request(input.socketPath, { ...input, action: 'origin-verify', socketPath: undefined })).verified === true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function startLauncherProcess(input) {
     const socket = createConnection(input.socketPath);
     const stdout = new PassThrough();