@playcraft/cli 0.1.58-beta → 0.1.60-beta

package/dist/cli-root-help.js

@@ -7,6 +7,7 @@ export function getCliTopicsHelpText() {
         '  素材       tools generate-*  |  image <子命令>  |  audio <子命令>  |  prefab <子命令>',
         '  素材库     library list/search/facets/get/files/download',
         '  生成任务   assets estimate/generate/tasks/get/wait/cancel/download | assets animation',
+        '  Remix 参考 references list/search/import（发现参考并读取当前工程中的固定快照）',
         '  视频理解   video models | video understand | video jobs get/cancel',
         '  平台       build, build-base, build-playable, build-all, analyze, inspect, upgrade',
         '             tools 除 generate-* 外（Git / 沙箱构建 / 发布 / 列表 / Prefab 等，需后端 API）',

package/dist/commands/references.js

@@ -0,0 +1,55 @@
+import { executeReferenceCommand } from '../references/client.js';
+import { referenceErrorMessage, referenceMessage as message } from '../references/messages.js';
+import { RemixReferenceToolError } from '../references/protocol.js';
+export function referenceCommandFailure(action, code) {
+    return { schemaVersion: 'playcraft.references.v1', command: `references.${action}`, ok: false,
+        error: { code, message: referenceErrorMessage(code) } };
+}
+export function registerReferenceCommands(program) {
+    const references = program.command('references').description(message('description'));
+    const run = async (action, options, q) => {
+        try {
+            const result = await executeReferenceCommand({ action, cwd: process.cwd(),
+                ...(options.workspace ? { workspaceId: options.workspace } : {}),
+                ...(options.directory ? { directoryName: options.directory } : {}),
+                ...(action === 'search' ? { source: options.source, ...(q === undefined ? {} : { q }),
+                    ...(options.tag?.length ? { tagCategory: options.tagCategory ?? 'Gameplay', tagValues: options.tag }
+                        : options.tagCategory === undefined ? {} : { tagCategory: options.tagCategory }),
+                    page: Number(options.page), limit: Number(options.limit) } : {}),
+                ...(action === 'import' ? { projectUuid: options.project, branchName: options.branch } : {}) });
+            const output = { schemaVersion: 'playcraft.references.v1', command: `references.${action}`, ...result };
+            if (options.json)
+                console.log(JSON.stringify(output));
+            else if (action === 'import') {
+                const reference = result.reference;
+                console.log(`${reference.name}\n${reference.resolvedPath}`);
+            }
+            else {
+                for (const item of result.items)
+                    console.log(`${item.name}\t${item.resolvedPath ?? `${item.projectUuid}\t${item.branchName}`}`);
+            }
+        }
+        catch (error) {
+            const code = error instanceof RemixReferenceToolError ? error.code
+                : error instanceof Error && /^remix_reference_[a-z_]+$/.test(error.message) ? error.message : 'remix_reference_tool_failed';
+            const output = referenceCommandFailure(action, code);
+            if (options.json)
+                console.log(JSON.stringify(output));
+            else
+                console.error(output.error.message);
+            process.exitCode = 1;
+        }
+    };
+    const scope = (command) => command.option('--workspace <id>', message('workspace'))
+        .option('--directory <name>', message('directory')).option('--json', message('json'));
+    scope(references.command('list').description(message('list'))).action(options => run('list', options));
+    scope(references.command('search [query]').description(message('search'))
+        .option('--source <source>', message('source'), 'recommended')
+        .option('--tag <value>', message('tag'), (value, previous) => [...previous, value], [])
+        .option('--tag-category <name>', message('tagCategory'))
+        .option('--page <n>', message('page'), '1').option('--limit <n>', message('limit'), '12'))
+        .action((q, options) => run('search', options, q));
+    scope(references.command('import').description(message('import'))
+        .requiredOption('--project <uuid>', message('project')).requiredOption('--branch <name>', message('branch')))
+        .action(options => run('import', options));
+}

package/dist/index.js

@@ -32,6 +32,7 @@ import { registerPradCommands } from './commands/prad.js';
 import { register3DCommands } from './commands/3d.js';
 import { registerWorkspaceRuntimeCommands } from './commands/workspace-runtime.js';
 import { registerWorkspaceCommands } from './commands/workspace.js';
+import { registerReferenceCommands, referenceCommandFailure } from './commands/references.js';
 import { registerVideoCommands } from './commands/video.js';
 import { registerPlayableCommands } from './commands/playable.js';
 import { registerPreviewRuntimeCommands } from './commands/preview-runtime.js';
@@ -44,7 +45,8 @@ const program = new Command();
 const structuredVideoTopic = ['video', 'playable'].includes(process.argv[2] ?? '');
 const assetTopic = ['assets', 'library'].includes(process.argv[2] ?? '');
 const registryTopic = process.argv[2] === 'skills' && process.argv[3] === 'registry';
-if (structuredVideoTopic)
+const referenceTopic = process.argv[2] === 'references';
+if (structuredVideoTopic || referenceTopic)
     program.exitOverride();
 program.name('playcraft').description(CLI_ROOT_DESCRIPTION).version(packageJson.version);
 // Registry upload commands use --version for the skill, after the command name.
@@ -53,7 +55,7 @@ if (registryTopic)
 registerRootProgramHelp(program);
 // 版本检查（非阻塞，后台执行）
 // 只在非 upgrade 命令时检查，避免重复提示
-if (!structuredVideoTopic && !assetTopic && !registryTopic && !process.argv.includes('upgrade') && !process.argv.includes('workspace-runtime')) {
+if (!structuredVideoTopic && !assetTopic && !registryTopic && !referenceTopic && !process.argv.includes('upgrade') && !process.argv.includes('workspace-runtime')) {
     checkForUpdates(packageJson);
 }
 // create 命令
@@ -391,10 +393,26 @@ registerPradCommands(program);
 register3DCommands(program);
 registerWorkspaceRuntimeCommands(program);
 registerWorkspaceCommands(program);
+registerReferenceCommands(program);
 registerVideoCommands(program);
 registerPlayableCommands(program);
 registerPreviewRuntimeCommands(program);
-if (structuredVideoTopic) {
+if (referenceTopic) {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        if (!(error instanceof CommanderError))
+            throw error;
+        if (error.exitCode === 0)
+            process.exitCode = 0;
+        else {
+            console.log(JSON.stringify(referenceCommandFailure(process.argv[3] ?? 'unknown', 'invalid_remix_reference_tool_request')));
+            process.exitCode = 64;
+        }
+    }
+}
+else if (structuredVideoTopic) {
     try {
         await program.parseAsync(process.argv);
     }

package/dist/references/client.js

@@ -0,0 +1,69 @@
+import { lstat, readFile, realpath } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { listWorkspaceRemixReferences } from '../workspace-runtime/workspaces/remix-references.js';
+import { localRemixReference, RemixReferenceToolError, remixReferenceToolRequestSchema } from './protocol.js';
+async function localRoot(cwd) {
+    let current = await realpath(cwd);
+    for (;;) {
+        if (await lstat(join(current, '.git')).catch(() => undefined)
+            || await lstat(join(current, '.playcraft/workspace-context.json')).catch(() => undefined)
+            || await lstat(join(current, '.playcraft/remix-references.json')).catch(() => undefined))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return realpath(cwd);
+        current = parent;
+    }
+}
+async function localList(input) {
+    const root = await localRoot(input.cwd);
+    const directoryName = /^remix-[a-z0-9][a-z0-9-]{3,63}$/.test(basename(root)) ? basename(root) : 'basic';
+    if (input.directoryName !== undefined && input.directoryName !== directoryName)
+        throw new RemixReferenceToolError('remix_reference_scope_mismatch');
+    if (input.workspaceId !== undefined) {
+        const context = await readFile(join(root, '.playcraft/workspace-context.json'), 'utf8').then(value => JSON.parse(value)).catch(() => undefined);
+        if (context?.workspaceId !== input.workspaceId)
+            throw new RemixReferenceToolError('remix_reference_scope_mismatch');
+    }
+    const items = await listWorkspaceRemixReferences(root, directoryName);
+    return { ok: true, directoryName, items: items.map(item => localRemixReference(root, item)) };
+}
+/** The current shell receives only a local reference capability; control credentials stay in memory. */
+export async function executeReferenceCommand(input) {
+    const parsed = remixReferenceToolRequestSchema.safeParse(input);
+    if (!parsed.success)
+        throw new RemixReferenceToolError('invalid_remix_reference_tool_request');
+    if (parsed.data.action === 'list')
+        return localList(parsed.data);
+    const endpoint = process.env.PLAYCRAFT_REMIX_REFERENCES_ENDPOINT;
+    const capability = process.env.PLAYCRAFT_REMIX_REFERENCES_CAPABILITY;
+    if (!endpoint && !capability) {
+        throw new RemixReferenceToolError('remix_reference_agent_required');
+    }
+    let url;
+    try {
+        url = new URL(endpoint ?? '');
+        if (!capability || capability.length > 128 || 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}\/remix-references$/.test(url.pathname))
+            throw new Error();
+    }
+    catch {
+        throw new RemixReferenceToolError('workspace_remix_references_unavailable');
+    }
+    let response;
+    try {
+        response = await fetch(url, { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(150_000),
+            headers: { authorization: `Bearer ${capability}`, 'content-type': 'application/json' }, body: JSON.stringify(parsed.data) });
+    }
+    catch {
+        throw new RemixReferenceToolError('workspace_remix_references_unavailable');
+    }
+    const value = await response.json().catch(() => undefined);
+    if (!response.ok || value?.ok !== true) {
+        const error = value?.error;
+        throw new RemixReferenceToolError(typeof error?.code === 'string' && /^[a-z_]{1,128}$/.test(error.code)
+            ? error.code : 'workspace_remix_references_unavailable');
+    }
+    return value;
+}

package/dist/references/messages.js

@@ -0,0 +1,57 @@
+const messages = {
+    en: {
+        description: 'Discover and import Remix source references for the current cloud workspace',
+        list: 'List verified local Remix references and their paths', search: 'Search accessible recommended or community Remixes',
+        import: 'Import a fixed Remix source snapshot into the current engineering directory',
+        query: 'Search names, branches, tags, creators or templates', source: 'recommended or community', project: 'Source project identifier', branch: 'Exact source branch',
+        tag: 'Match a tag value; repeat to match any of the values', tagCategory: 'Tag category; defaults to Gameplay when --tag is used',
+        workspace: 'Current cloud workspace identifier (must match this conversation)', directory: 'Current engineering directory (must match this conversation)',
+        page: 'Page number', limit: 'Maximum results, 1–50', json: 'Print JSON (JavaScript Object Notation, JavaScript 对象表示法)',
+        agentRequired: 'Search and import require a current Agent message in a supported cloud workspace. Reconnect or upgrade the workspace and retry in the Agent conversation.',
+        unavailable: 'Remix references are unavailable. Reconnect or upgrade the cloud workspace and retry.',
+        invalid: 'Invalid reference command arguments. Check the source, project, branch, workspace and directory.',
+        scope: 'The requested workspace or directory does not match the current Agent conversation.',
+        readonly: 'Import requires execute mode with write permission. Search and local listing remain available.',
+        turn: 'Cannot verify this command’s active Agent message. Wait for other conversations to finish, then retry from the current message.',
+        busy: 'Another conversation, production task or exclusive operation is using this directory. Retry after it finishes.',
+        sourceUnavailable: 'The selected Remix is unavailable or no longer accessible. Search again and choose an available result.',
+        tooLarge: 'The selected Remix exceeds the reference size or file limit.',
+        changed: 'The reference files changed or could not be verified. Restore the fixed snapshot or import a new version.',
+        failed: 'The Remix reference operation failed. Retry from the current Agent message.',
+    },
+    zh: {
+        description: '为当前云工作区发现并导入 Remix 源码参考',
+        list: '列出已验证的本地 Remix 参考及路径', search: '搜索可访问的推荐或社区 Remix', import: '把固定版本的 Remix 源码参考导入当前工程',
+        query: '搜索名称、分支、标签、创建者或模板', source: 'recommended（推荐）或 community（社区）', project: '来源项目标识', branch: '准确的来源分支名',
+        tag: '匹配的标签值；可重复指定，匹配任意一个值', tagCategory: '标签分类；使用 --tag 时默认为 Gameplay',
+        workspace: '当前云工作区标识（必须与本对话一致）', directory: '当前工程目录（必须与本对话一致）',
+        page: '页码', limit: '最多返回数量，1–50', json: '输出 JSON (JavaScript Object Notation, JavaScript 对象表示法)',
+        agentRequired: '搜索与导入需要受支持云工作区中的当前 Agent 消息。请重新连接或升级工作区，再在 Agent 对话中执行。',
+        unavailable: 'Remix 参考能力不可用，请重新连接或升级云工作区后重试。',
+        invalid: '参考命令参数无效，请检查来源、项目、分支、工作区及工程目录。',
+        scope: '指定的工作区或工程目录与当前 Agent 对话不一致。',
+        readonly: '导入需要执行模式及写入权限；仍可搜索和列出本地参考。',
+        turn: '无法核验该参考命令所属的当前 Agent 消息，请等待其他对话结束后，从当前消息重新执行。',
+        busy: '其他对话、生产任务或独占操作正在使用该工程，请等待结束后重试。',
+        sourceUnavailable: '所选 Remix 不可用或已无访问权限，请重新搜索并选择可用结果。',
+        tooLarge: '所选 Remix 超过参考文件数量或大小限制。',
+        changed: '参考文件已变化或无法通过校验，请恢复固定快照或导入新版本。',
+        failed: 'Remix 参考操作失败，请从当前 Agent 消息重试。',
+    },
+};
+export function referenceMessage(key) {
+    return messages[(process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en').startsWith('zh') ? 'zh' : 'en'][key];
+}
+export function referenceErrorMessage(code) {
+    const key = code === 'remix_reference_agent_required' ? 'agentRequired'
+        : code === 'remix_reference_scope_mismatch' ? 'scope'
+            : code === 'invalid_remix_reference_query' || code === 'invalid_remix_reference_import' || code === 'invalid_remix_reference_tool_request' ? 'invalid'
+                : code === 'remix_reference_readonly' || code === 'workspace_permission_denied' ? 'readonly'
+                    : code === 'remix_reference_turn_unavailable' ? 'turn'
+                        : ['turn_already_active', 'batch_workspace_readonly', 'directory_busy'].includes(code) ? 'busy'
+                            : ['remix_reference_unavailable', 'remix_reference_source_changed', 'remix_reference_unsupported', 'remix_reference_incomplete', 'workspace_access_denied'].includes(code) ? 'sourceUnavailable'
+                                : ['remix_reference_too_large', 'remix_reference_limit'].includes(code) ? 'tooLarge'
+                                    : ['remix_reference_changed', 'remix_reference_manifest_invalid', 'remix_reference_path_conflict', 'remix_reference_git_attributes'].includes(code) ? 'changed'
+                                        : code === 'workspace_remix_references_unavailable' ? 'unavailable' : 'failed';
+    return referenceMessage(key);
+}

package/dist/references/protocol.js

@@ -0,0 +1,32 @@
+import { join } from 'node:path';
+import { z } from 'zod';
+const scope = {
+    cwd: z.string().min(1).max(4096),
+    workspaceId: z.string().uuid().optional(),
+    directoryName: z.string().regex(/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/).optional(),
+};
+export const remixReferenceToolRequestSchema = z.discriminatedUnion('action', [
+    z.object({ ...scope, action: z.literal('list') }).strict(),
+    z.object({ ...scope, action: z.literal('search'), source: z.enum(['recommended', 'community']),
+        tagCategory: z.string().trim().min(1).max(128).optional(),
+        tagValues: z.array(z.string().trim().min(1).max(255)).min(1).max(20).optional(),
+        q: z.string().max(200).optional(), page: z.number().int().min(1).max(10000).default(1),
+        limit: z.number().int().min(1).max(50).default(12) }).strict(),
+    z.object({ ...scope, action: z.literal('import'), projectUuid: z.string().uuid(),
+        branchName: z.string().min(1).max(255) }).strict(),
+]).refine(input => input.action !== 'search' || (input.tagCategory === undefined) === (input.tagValues === undefined));
+export class RemixReferenceToolError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'RemixReferenceToolError';
+    }
+}
+export function localRemixReference(root, reference) {
+    const { files, omittedFiles, ...metadata } = reference;
+    return { ...metadata, source: { ...metadata.source,
+            recommended: metadata.source.recommended ?? metadata.source.category === 'recommended' },
+        resolvedPath: join(root, reference.path), fileCount: files.length,
+        omittedFileCount: omittedFiles?.length ?? 0 };
+}

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

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

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

@@ -1,12 +1,12 @@
 import { setTimeout as delay } from 'node:timers/promises';
 import { sandboxBatchMemberStopSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { groupExited, stopProcessGroup } from './processes.js';
+import { processHasExited, stopProcessGroup } from './processes.js';
 import { settleObservedGenerate } from './generate.js';
 import { memberStatus, readMember, serializeRun, writeMember, writeStopMarker } from './records.js';
 async function prove(record) {
     let stopped = true;
     for (const process of record.processes) {
-        if (process.stopped || groupExited(process.pid))
+        if (processHasExited(process))
             process.stopped = true;
         else {
             process.stopped = await stopProcessGroup(process);
@@ -32,7 +32,7 @@ export async function readBatchMemberStatus(state, runId) {
         if (settled.state !== 'running')
             return memberStatus(settled);
     }
-    const processes = record.processes.map(process => ({ ...process, stopped: process.stopped || groupExited(process.pid) }));
+    const processes = record.processes.map(process => ({ ...process, stopped: processHasExited(process) }));
     const live = processes.some(process => !process.stopped);
     let next = { ...record, processes };
     if (live && (record.writersStopped || record.state === 'completed' || record.state === 'stopped' || record.state === 'needs_user' || record.state === 'failed')) {

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

@@ -6,7 +6,7 @@ import { hashOperationPayload, sandboxBatchMemberDeliverSchema, } from '@playcra
 import { claimBatchDirectory, withDirectoryOwner } from '../server/directory-access.js';
 import { runDeveloperCommand } from '../workspaces/developer-command.js';
 import { workspaceRoot } from '../workspaces/registry.js';
-import { groupExited, runProcessGroup, stopProcessGroup } from './processes.js';
+import { processHasExited, runProcessGroup, stopProcessGroup } from './processes.js';
 import { stopMemberWriters } from './writer-proof.js';
 import { memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
 /** Base build writes dist/index.html. Channel packaging stays on export playable (`--mode full`). */
@@ -71,7 +71,7 @@ async function readBuiltHtml(root) {
 async function prove(record) {
     let stopped = true;
     for (const process of record.processes) {
-        if (!(process.stopped || groupExited(process.pid))) {
+        if (!processHasExited(process)) {
             process.stopped = await stopProcessGroup(process);
             if (!process.stopped)
                 stopped = false;
@@ -133,6 +133,7 @@ export async function deliverBatchMember(state, body) {
                 processes: existing?.processes ?? [],
                 sessionId: existing?.sessionId,
                 operationId: existing?.operationId,
+                evidence: existing?.evidence,
                 commandHash: { ...existing?.commandHash, deliver: hash },
                 snapshotDigest: existing?.snapshotDigest,
                 branchName: existing?.branchName,
@@ -184,7 +185,7 @@ export async function deliverBatchMember(state, body) {
                     writersStopped: true,
                     holding: false,
                     error: undefined,
-                    evidence: { verified: true },
+                    evidence: { ...record.evidence, verified: true },
                 });
                 return memberStatus(record);
             }

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

@@ -9,7 +9,7 @@ import { workspaceRoot } from '../workspaces/registry.js';
 import { snapshotWorkspaceTree } from '../workspaces/git.js';
 import { requireBatchContentChanges } from './content-changes.js';
 import { bindMemberPolicy, memberExecutionPolicy } from './policy.js';
-import { groupExited, stopProcessGroup } from './processes.js';
+import { processHasExited, stopProcessGroup } from './processes.js';
 import { memberStatus, readMember, readStopMarker, serializeRun, writeMember } from './records.js';
 import { stopMemberWriters } from './writer-proof.js';
 function hashCommand(value) {
@@ -45,7 +45,7 @@ function threadIdOf(event) {
 async function proveStopped(record) {
     let stopped = true;
     for (const process of record.processes) {
-        if (process.stopped || groupExited(process.pid))
+        if (processHasExited(process))
             process.stopped = true;
         else {
             const did = await stopProcessGroup(process);
@@ -86,7 +86,7 @@ export async function generateBatchMember(state, body) {
             // private
             await mkdir(tempDir, { recursive: true, mode: 0o700 });
             const policy = memberExecutionPolicy(root, tempDir);
-            await bindMemberPolicy(state, sessionId, policy);
+            await bindMemberPolicy(state, sessionId, policy, { runId: command.runId, ownerFence: command.ownerFence });
             const modelConfigId = command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? command.model : undefined;
             const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) };
             const turnKey = operation(state, { kind: 'session.turn', clientRequestId: `batch-turn:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: turnPayload });
@@ -101,6 +101,7 @@ export async function generateBatchMember(state, body) {
                 writersStopped: false, holding: true, stopRequested: false, processes: existing?.processes ?? [], sessionId,
                 operationId: prior?.operationId, commandHash: { ...existing?.commandHash, generate: hash },
                 snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName, headCommit: existing?.headCommit,
+                evidence: existing?.evidence,
                 sourceCommit, beforeTree,
                 updatedAt: new Date().toISOString(),
             });

package/dist/workspace-runtime/batch/install-log.js

@@ -0,0 +1,49 @@
+import { mkdir, open } from 'node:fs/promises';
+import { join } from 'node:path';
+function redact(text) {
+    return text
+        .replace(/\x1b\[[0-9;]*m/g, '')
+        .replace(/(https?:\/\/[^\s?#]+)[?#][^\s]*/gi, '$1?[redacted]')
+        .replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1[redacted]@')
+        .replace(/\bBearer\s+[^\s"']+/gi, 'Bearer [redacted]')
+        .replace(/\b(authorization|_authToken|api[_-]?key|password|secret|(?:access[_-]?|refresh[_-]?)?token)["']?\s*[:=]\s*(?:"[^"\r\n]*"|'[^'\r\n]*'|[^\s,;]+)/gi, '$1=[redacted]');
+}
+/** Stream complete lines so credentials split across output chunks are redacted before persistence. */
+export async function createInstallLog(stateDir, runId, command) {
+    const directory = join(stateDir, 'batch-temp', runId);
+    // private: batch-temp is controller-owned diagnostics state, like the build log beside it.
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const logPath = join(directory, 'install.log');
+    // private
+    const file = await open(logPath, 'a', 0o600);
+    let pending = Promise.resolve();
+    let partial = '';
+    let logTail = '';
+    const write = (text) => {
+        const safe = redact(text);
+        logTail = (logTail + safe).slice(-8192);
+        pending = pending.then(async () => { await file.write(safe); });
+    };
+    const append = (chunk) => {
+        partial += String(chunk);
+        const newline = partial.lastIndexOf('\n');
+        if (newline < 0)
+            return;
+        write(partial.slice(0, newline + 1));
+        partial = partial.slice(newline + 1);
+    };
+    write(`\n[install] ${new Date().toISOString()}\n$ ${command}\n`);
+    return {
+        append,
+        async finish(exitCode) {
+            write(partial + `\n[install] exit code=${exitCode ?? 'unknown'}\n`);
+            try {
+                await pending;
+            }
+            finally {
+                await file.close();
+            }
+            return { exitCode, logPath, logTail };
+        },
+    };
+}

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

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

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

@@ -10,7 +10,8 @@ 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 { processHasExited, runProcessGroup } from './processes.js';
+import { createInstallLog } from './install-log.js';
 import { stopMemberWriters } from './writer-proof.js';
 import { filesystemObjectStore, memberStatus, readMember, readSnapshot, readStopMarker, serializeRun, sourceCacheDir, writeMember, } from './records.js';
 const BRANCH = /^remix\/draft-[a-f0-9]{16}$/;
@@ -143,7 +144,7 @@ export async function prepareBatchMember(state, body, options) {
             existing.commandHash?.prepare &&
             existing.commandHash.prepare !== hash)
             throw new Error('batch_command_conflict');
-        if (existing?.processes.some((process) => process.role === 'install' && !process.stopped && !groupExited(process.pid)))
+        if (existing?.processes.some((process) => process.role === 'install' && !processHasExited(process)))
             return memberStatus(existing);
         const snapshot = command.snapshot;
         await claimBatchDirectory(state, command);
@@ -204,27 +205,42 @@ export async function prepareBatchMember(state, body, options) {
                 await writeWorkspaceCliContext(root, command.workspaceId);
                 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`;
+                    // Keep preparation script-free and avoid hardlinks to legacy control-owned cache files.
+                    const flags = '--package-import-method=copy --ignore-scripts';
+                    const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} ${flags}`;
                     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],
-                        });
-                    });
+                        : `${dependencyInstallCommand(state)} --lockfile-only ${flags} && ${frozen}`);
+                    const log = await createInstallLog(state.config.stateDir, command.runId, installCommand);
+                    let installed;
+                    try {
+                        installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
+                            record = {
+                                ...record,
+                                processes: [...record.processes.filter(item => process.launcher
+                                        ? item.launcher?.processId !== process.launcher.processId
+                                        : item.pid !== process.pid), process],
+                            };
+                            record = await writeMember(state, record);
+                        }, { state, processId: `batch-install-${command.runId}-${randomUUID()}`, onOutput: log.append });
+                    }
+                    catch (error) {
+                        log.append(`\n[install] ${error instanceof Error ? error.message : String(error)}\n`);
+                    }
+                    const installation = await log.finish(installed?.code ?? null);
                     record = await writeMember(state, {
                         ...record,
-                        processes: record.processes.map((process) => process.pid === installed.process.pid
+                        evidence: { ...record.evidence, installation },
+                        processes: record.processes.map((process) => installed && process.pid === installed.process.pid
                             ? { ...installed.process, role: 'install' }
                             : process),
                     });
                     if (await readStopMarker(state, command.runId))
                         return memberStatus(await sealStopped(state, command, record));
-                    if (installed.code !== 0)
+                    if (!installed || installed.code !== 0 || (installed.process.launcher && !installed.process.stopped)) {
+                        console.warn(JSON.stringify({ event: 'batch_install_failed', runId: command.runId, ...installation }));
                         throw new Error('batch_install_failed');
+                    }
                 }
                 const writersStopped = await stopMemberWriters(state, record);
                 if (!writersStopped)