@playcraft/cli 0.1.44-beta → 0.1.46-beta

package/dist/commands/tools-batch.js

@@ -15,7 +15,6 @@ const messages = {
         requestRequired: 'Prompt creation requires a stable --client-request-id; reuse it when retrying the same request.',
         help: '\nUse --prompt with --workspace-id and a stable --client-request-id. The platform plans and generates independent Remix directories while preserving the source. An omitted count defaults to 3; maximum 10. --input also accepts existing structured drafts.\n',
         confirmation: 'Generation is queued. Read the batch status to track its results.',
-        review: 'This existing draft requires baseline approval in the browser.',
         sync: 'Apply the latest source snapshot to an existing batch',
         syncDone: 'Batch sync requested',
     },
@@ -31,7 +30,6 @@ const messages = {
         requestRequired: '使用 prompt 创建时必须提供稳定的 --client-request-id，重试同一请求时复用该标识。',
         help: '\n使用 --prompt、--workspace-id 和稳定的 --client-request-id。平台自动规划，在副本中生成独立 Remix，保持来源不变。未指定数量默认 3 个，最多 10 个。--input 也兼容现有结构化草案。\n',
         confirmation: '生成已排队，可查询批次状态追踪各项成果。',
-        review: '此历史草案需要在浏览器确认基准。',
         sync: '将来源最新快照同步到已有批次',
         syncDone: '已请求同步到批次',
     },
@@ -69,7 +67,7 @@ export function registerBatchCommands(tools) {
                 sourceWorkspaceId: opts.workspaceId, sourceDirectoryName: opts.sourceDirectory,
                 ...(opts.teamId ? { teamId: opts.teamId } : {}),
             });
-            console.log(opts.json ? JSON.stringify(result, null, 2) : `${t.created}: ${result.batchId}\n${result.manifest.autoStart ? t.confirmation : t.review}`);
+            console.log(opts.json ? JSON.stringify(result, null, 2) : `${t.created}: ${result.batchId}\n${t.confirmation}`);
         }
         catch (error) {
             handleError(error);

package/dist/workspace-runtime/{production → batch}/content-changes.js

@@ -1,6 +1,4 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execute = promisify(execFile);
+import { gitRead } from './git.js';
 const reference = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
 const excludedDirectories = new Set(['node_modules', 'dist', 'build', 'coverage', 'docs', 'test', 'tests', '__tests__']);
 const contentExtension = /\.(?:[cm]?[jt]sx?|vue|svelte|html?|css|s[ac]ss|less|json5?|ya?ml|xml|glsl|wgsl|vert|frag|lua|py|svg|png|jpe?g|webp|avif|gif|bmp|mp[34]|wav|ogg|m4a|webm|glb|gltf|fbx|obj|bin|atlas|woff2?|ttf|otf)$/i;
@@ -13,15 +11,11 @@ function contentPath(path) {
         return false;
     return contentExtension.test(name);
 }
-/** A completed native turn is useful only when code, runtime configuration, or assets changed. */
-export async function requireProductionContentChanges(root, before, after) {
+/** A completed batch member must change code, runtime configuration, or assets. */
+export async function requireBatchContentChanges(root, before, after) {
     if (!reference.test(before) || !reference.test(after))
-        throw new Error('production_change_reference_invalid');
-    const { stdout } = await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root,
-        'diff', '--raw', '--no-abbrev', '--no-renames', '-z', before, after, '--'], {
-        timeout: 90_000, maxBuffer: 64 * 1024 * 1024,
-        env: { PATH: process.env.PATH, HOME: root, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
-    });
+        throw new Error('batch_change_reference_invalid');
+    const stdout = await gitRead(root, ['diff', '--raw', '--no-abbrev', '--no-renames', '-z', before, after, '--']);
     const records = stdout.split('\0'), paths = [];
     for (let index = 0; index + 1 < records.length; index += 2) {
         const [oldMode, newMode, oldBlob, newBlob] = records[index].slice(1).split(' ');
@@ -31,6 +25,6 @@ export async function requireProductionContentChanges(root, before, after) {
             paths.push(path);
     }
     if (!paths.length)
-        throw new Error('production_generation_no_content_change');
+        throw new Error('batch_generation_no_content_change');
     return paths;
 }

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

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { hashOperationPayload, sandboxBatchMemberDeliverSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { findExternalLocalReferences } from '../previews/single-file.js';
 import { workspaceRoot } from '../workspaces/registry.js';
+import { requireBatchContentChanges } from './content-changes.js';
 import { gitRead, gitWrite } from './git.js';
 import { groupExited, runProcessGroup, stopProcessGroup } from './processes.js';
 import { filesystemObjectStore, memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
@@ -62,12 +63,15 @@ export async function deliverBatchMember(state, body, options) {
             directoryName: command.directoryName, phase: 'deliver', state: 'running', writersStopped: false, holding: true, stopRequested: false,
             processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId, commandHash: { ...existing?.commandHash, deliver: hash },
             snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName, updatedAt: new Date().toISOString(),
+            sourceCommit: existing?.sourceCommit ?? state.journal.getWorkspace(command.workspaceId)?.directories?.find(directory => directory.directoryName === command.directoryName)?.sourceCommit,
+            beforeTree: existing?.beforeTree,
         });
         const buildRoot = join(state.config.stateDir, 'batch-builds', `${command.runId}-${randomUUID()}`);
         try {
             const savedCommit = command.fromCommit ?? await saveExact(root);
             if (command.fromCommit)
                 await gitRead(root, ['cat-file', '-e', `${command.fromCommit}^{commit}`]);
+            await requireBatchContentChanges(root, record.sourceCommit ?? '', savedCommit);
             if (await readStopMarker(state, command.runId))
                 return memberStatus(await markStopped(state, command, record));
             let pushedCommit;
@@ -79,7 +83,7 @@ export async function deliverBatchMember(state, body, options) {
                 catch {
                     throw new Error('batch_push_failed');
                 }
-                const remote = (await gitRead(root, ['ls-remote', 'origin', `refs/heads/${branch}`])).slice(0, savedCommit.length);
+                const remote = (await gitWrite(root, ['ls-remote', 'origin', `refs/heads/${branch}`])).slice(0, savedCommit.length);
                 if (remote !== savedCommit)
                     throw new Error('batch_push_failed');
                 pushedCommit = savedCommit;
@@ -146,5 +150,6 @@ async function markStopped(state, command, existing) {
         holding: false, stopRequested: true, processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId,
         headCommit: existing?.headCommit, evidence: existing?.evidence, commandHash: existing?.commandHash, snapshotDigest: existing?.snapshotDigest,
         branchName: existing?.branchName, updatedAt: new Date().toISOString(),
+        sourceCommit: existing?.sourceCommit, beforeTree: existing?.beforeTree,
     });
 }

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

@@ -35,7 +35,7 @@ async function pushHiddenRef(cache, sourceRoot, remote, commit, ref) {
     catch {
         throw new Error('batch_source_push_failed');
     }
-    const remoteHash = (await gitRead(cache, ['ls-remote', remote, ref]).catch(() => '')).slice(0, commit.length);
+    const remoteHash = (await gitWrite(cache, ['ls-remote', remote, ref]).catch(() => '')).slice(0, commit.length);
     if (remoteHash !== commit)
         throw new Error('batch_source_push_failed');
 }

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

@@ -5,6 +5,8 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { hashOperationPayload, operationScopeKey, sandboxBatchMemberGenerateSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { attachNativeCollector, executeOperation } from '../server/dispatch.js';
 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 { memberStatus, readMember, readStopMarker, serializeRun, writeMember } from './records.js';
@@ -83,12 +85,15 @@ export async function generateBatchMember(state, body) {
         const prior = state.journal.getOperation(turnKey.scopeKey);
         if (prior && prior.payloadHash !== turnKey.record.payloadHash)
             throw new Error('batch_command_conflict');
+        const sourceCommit = existing?.sourceCommit ?? state.journal.getWorkspace(command.workspaceId)?.directories?.find(directory => directory.directoryName === command.directoryName)?.sourceCommit;
+        const beforeTree = existing?.beforeTree ?? (prior ? sourceCommit : await snapshotWorkspaceTree(root));
         let record = await writeMember(state, {
             runId: command.runId, ownerFence: command.ownerFence, occupancyId: command.occupancyId, workspaceId: command.workspaceId,
             directoryName: command.directoryName, phase: 'generate', state: prior ? (prior.status === 'uncertain' ? 'unknown' : prior.status === 'completed' ? 'completed' : 'running') : 'running',
             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,
+            sourceCommit, beforeTree,
             updatedAt: new Date().toISOString(),
         });
         if (prior)
@@ -172,8 +177,7 @@ async function finishGenerate(state, record, started, root, early) {
             return writeMember(state, { ...record, state: 'stopping', writersStopped: false, holding: true, operationId: started.operationId });
         if (await readStopMarker(state, record.runId))
             return stoppedRecord(state, record, record);
-        const head = await import('./git.js').then(git => git.gitRead(root, ['rev-parse', 'HEAD'])).then(value => value.trim()).catch(() => record.headCommit);
-        return writeMember(state, { ...record, state: 'completed', writersStopped: true, holding: true, operationId: started.operationId, headCommit: head, error: undefined });
+        return completeGeneration(state, { ...record, operationId: started.operationId }, root);
     }
     const writersStopped = await proveStopped(record);
     return writeMember(state, {
@@ -187,11 +191,27 @@ async function reconcileGenerate(state, record) {
     if (record.state === 'unknown' && session?.turnStatus === 'completed') {
         const writersStopped = await proveStopped(record);
         if (writersStopped && !await readStopMarker(state, record.runId)) {
-            return writeMember(state, { ...record, state: 'completed', writersStopped: true, holding: true, error: undefined });
+            const root = await workspaceRoot(state, record.workspaceId, record.directoryName);
+            return completeGeneration(state, record, root);
         }
     }
     return record;
 }
+async function completeGeneration(state, record, root) {
+    try {
+        const afterTree = await snapshotWorkspaceTree(root);
+        await requireBatchContentChanges(root, record.beforeTree ?? '', afterTree);
+        await requireBatchContentChanges(root, record.sourceCommit ?? '', afterTree);
+    }
+    catch (error) {
+        const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message) ? error.message : 'batch_generation_failed';
+        return writeMember(state, { ...record, state: 'failed', writersStopped: true, holding: false, error: code });
+    }
+    if (await readStopMarker(state, record.runId))
+        return stoppedRecord(state, record, record);
+    const head = await import('./git.js').then(git => git.gitRead(root, ['rev-parse', 'HEAD'])).then(value => value.trim()).catch(() => record.headCommit);
+    return writeMember(state, { ...record, state: 'completed', writersStopped: true, holding: true, headCommit: head, error: undefined });
+}
 async function stoppedRecord(state, command, existing) {
     if (existing)
         await proveStopped(existing);
@@ -201,5 +221,6 @@ async function stoppedRecord(state, command, existing) {
         stopRequested: true, processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId,
         headCommit: existing?.headCommit, evidence: existing?.evidence, commandHash: existing?.commandHash, snapshotDigest: existing?.snapshotDigest,
         branchName: existing?.branchName, updatedAt: new Date().toISOString(),
+        sourceCommit: existing?.sourceCommit, beforeTree: existing?.beforeTree,
     });
 }

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

@@ -1,6 +1,6 @@
 import { listMembers } from './records.js';
 /** True while a member Run still holds the directory. Other sandbox write entries must refuse it. */
-export async function batchDirectoryHeld(state, workspaceId, directoryName) {
+export async function batchDirectoryHeld(state, workspaceId, directoryName = 'basic') {
     if (!workspaceId)
         return false;
     const members = await listMembers(state);

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

@@ -140,6 +140,7 @@ export async function prepareBatchMember(state, body, options) {
             workspaceId: command.workspaceId, directoryName: command.directoryName, phase: 'prepare', state: 'running',
             writersStopped: false, holding: true, stopRequested: false, processes: existing?.processes ?? [],
             commandHash: { ...existing?.commandHash, prepare: hash }, snapshotDigest: snapshot.digest, branchName: command.branchName,
+            sourceCommit: snapshot.commitHash, beforeTree: existing?.beforeTree,
             updatedAt: new Date().toISOString(),
         });
         const parent = await workspaceContainerRoot(state, command.workspaceId);
@@ -197,6 +198,7 @@ async function sealStopped(state, command, existing) {
         state: 'stopped', writersStopped: true, holding: false, stopRequested: true, processes: existing?.processes ?? [],
         sessionId: existing?.sessionId, operationId: existing?.operationId, headCommit: existing?.headCommit, evidence: existing?.evidence,
         commandHash: existing?.commandHash, snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName,
+        sourceCommit: existing?.sourceCommit, beforeTree: existing?.beforeTree,
         updatedAt: new Date().toISOString(),
     });
 }

package/dist/workspace-runtime/server/dispatch.js

@@ -5,7 +5,7 @@ import { shareWorkspaceGit } from '../workspaces/shared-git.js';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { closeCliCredentials } from '../workspaces/cli-credentials.js';
+import { closeCliCredentials, ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
 import { resolveWorkspaceAttachments } from '../workspaces/attachments.js';
@@ -27,7 +27,7 @@ import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces
 import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPreviewPublish, } from '../previews/publish.js';
 import { spawnBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
-import { productionDirectoryBusy } from '../production/controller.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { BinaryWorkspaceWriteError, observeWorkspaceBinaryFile, writeWorkspaceBinaryFile } from '../workspaces/binary-write.js';
 import { importWorkspaceLibraryAssets } from '../workspaces/asset-library-import.js';
 import { createWorkspaceDirectory, WorkspaceDirectoryCreateError } from '../workspaces/directory-create.js';
@@ -174,7 +174,7 @@ async function executeRemixReferenceImport(state, scopeKey, operation, payload)
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_remix_reference' }));
     if (workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
-    if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+    if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
     try {
         const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
@@ -374,6 +374,15 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             clientRequestId: operation.clientRequestId, sourceDirectoryName: binding.directoryName ?? 'basic',
             ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}`
         : '';
+    if (state.config.workspaceMode === 'multi') {
+        try {
+            // The control service has adopted this epoch before dispatching the turn.
+            await ensureCliCredentials(state);
+        }
+        catch {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'cli_credentials_unavailable' }));
+        }
+    }
     // Taken before the native turn exists, so nothing the agent writes can precede it.
     await beginTurnChanges(state, sessionId, {
         root, workspaceId: operation.workspaceId, directoryName: binding.directoryName ?? 'basic',
@@ -589,7 +598,7 @@ async function executeCompact(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'session_workspace_mismatch' }));
     if (sessionTurnBusy(binding))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
-    if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+    if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
     const adapter = native(state);
     if (!adapter.startCompact)
@@ -644,7 +653,7 @@ async function executeSteer(state, scopeKey, operation, payload) {
     if (state.journal.listOperations().some(({ operation: other }) => other.kind === 'session.steer'
         && other.sessionId === sessionId && other.expectedTurnId === parsed.data.expectedTurnId && other.status === 'uncertain'))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'steer_receipt_uncertain' }));
-    if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+    if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
     const adapter = native(state);
     if (!adapter.steer)
@@ -753,7 +762,7 @@ async function executeDirectoryCreate(state, scopeKey, operation, payload) {
     if (!parsed.success)
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_path' }));
     try {
-        if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+        if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
         const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
         const created = await createWorkspaceDirectory(root, parsed.data);
@@ -781,7 +790,7 @@ async function executeAssetLibraryImport(state, scopeKey, operation, payload) {
         const assertCurrent = async () => {
             if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
                 throw new Error('stale_lease');
-            if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+            if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
                 throw new Error('batch_workspace_readonly');
         };
         await assertCurrent();
@@ -824,7 +833,7 @@ async function executeFileBinaryWrite(state, scopeKey, operation, payload) {
     return state.journal.exclusive(`file:${scope ?? 'single'}:${input.path}`, async () => {
         try {
             // Recheck after waiting for the workspace/file locks.
-            if (await productionDirectoryBusy(state, operation.workspaceId, operation.directoryName))
+            if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
                 throw Object.assign(new Error('batch_workspace_readonly'), { code: 'batch_workspace_readonly' });
             const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
             const observed = await observeWorkspaceBinaryFile(root, input.path);

package/dist/workspace-runtime/server/http.js

@@ -24,7 +24,7 @@ import { listWorkspaceRemixReferences, RemixReferenceError } from '../workspaces
 import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.js';
 import { join } from 'node:path';
 import { terminalHost } from './terminal-host.js';
-import { productionCapability, productionDirectoryBusy, executeSandboxProduction, sandboxProductionReceipt } from '../production/controller.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { dispatchBatchRoute } from '../batch/routes.js';
 import { cleanupWorkspaceDirectories, syncWorkspaceDirectories } from '../workspaces/directory-maintenance.js';
 import { registerWorkspaceDirectory, restoreWorkspaceDirectory } from '../workspaces/directories.js';
@@ -56,21 +56,6 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, batch.status, batch.body);
             return;
         }
-        if (request.method === 'GET' && url.pathname === '/runtime/production/capability') {
-            writeJson(response, 200, await productionCapability(state));
-            return;
-        }
-        if (request.method === 'POST' && ['/runtime/production/stages', '/runtime/production/stop', '/runtime/production/reconcile'].includes(url.pathname)) {
-            writeJson(response, 200, await executeSandboxProduction(state, await readJson(request)));
-            return;
-        }
-        if (request.method === 'GET' && url.pathname.startsWith('/runtime/production/stages/')) {
-            writeJson(response, 200, await sandboxProductionReceipt(state, decodeURIComponent(url.pathname.slice('/runtime/production/stages/'.length)), {
-                workspaceId: url.searchParams.get('workspaceId') ?? '', directoryName, taskId: url.searchParams.get('taskId') ?? '',
-                attemptId: url.searchParams.get('attemptId') ?? '', owner: url.searchParams.get('owner') ?? '', fence: Number(url.searchParams.get('fence')),
-            }));
-            return;
-        }
         if (request.method === 'GET' && url.pathname === '/runtime/health') {
             writeJson(response, 200, { status: 'ok', handshake: handshake(state) });
             return;
@@ -143,7 +128,7 @@ export async function handleRuntimeRequest(state, request, response) {
             }
             try {
                 const restored = await state.journal.exclusive(`directory:${scope.data.workspaceId}:${directoryName}`, async () => {
-                    if (await productionDirectoryBusy(state, scope.data.workspaceId, directoryName))
+                    if (await batchDirectoryHeld(state, scope.data.workspaceId, directoryName))
                         throw new SessionRestoreError('batch_workspace_readonly');
                     return state.journal.exclusive(`session:${scope.data.sessionId}`, () => state.journal.exclusive(`workspace:${revisionScope(state, scope.data.workspaceId, directoryName) ?? 'single'}`, () => restoreNativeSession(state, scope.data, parsed.data)));
                 });
@@ -277,7 +262,7 @@ export async function handleRuntimeRequest(state, request, response) {
                     importReceipts: await listWorkspaceLibraryImportReceipts(root, sessionId) });
             }
             else {
-                if (await productionDirectoryBusy(state, workspaceId, directoryName)) {
+                if (await batchDirectoryHeld(state, workspaceId, directoryName)) {
                     writeJson(response, 409, { error: 'batch_workspace_readonly' });
                     return;
                 }
@@ -303,7 +288,7 @@ export async function handleRuntimeRequest(state, request, response) {
             if (writeDestroyed(state, response))
                 return;
             const workspaceId = url.searchParams.get('workspaceId') ?? '';
-            if (await productionDirectoryBusy(state, workspaceId, directoryName)) {
+            if (await batchDirectoryHeld(state, workspaceId, directoryName)) {
                 writeJson(response, 409, { error: 'batch_workspace_readonly' });
                 return;
             }
@@ -337,7 +322,7 @@ export async function handleRuntimeRequest(state, request, response) {
             if (writeDestroyed(state, response))
                 return;
             const workspaceId = url.searchParams.get('workspaceId') ?? '';
-            if (await productionDirectoryBusy(state, workspaceId, directoryName)) {
+            if (await batchDirectoryHeld(state, workspaceId, directoryName)) {
                 writeJson(response, 409, { error: 'batch_workspace_readonly' });
                 return;
             }
@@ -354,7 +339,7 @@ export async function handleRuntimeRequest(state, request, response) {
             if (writeDestroyed(state, response))
                 return;
             const workspaceId = url.searchParams.get('workspaceId') ?? '';
-            if (await productionDirectoryBusy(state, workspaceId, directoryName)) {
+            if (await batchDirectoryHeld(state, workspaceId, directoryName)) {
                 writeJson(response, 409, { error: 'batch_workspace_readonly' });
                 return;
             }
@@ -767,7 +752,7 @@ async function acceptOperation(state, request, response) {
         await sessionWorkspaceRoot(state, parsed.data.workspaceId, parsed.data.directoryName);
     const mutation = isWorkspaceMutation(parsed.data.kind);
     const occupiesDirectory = mutation || parsed.data.kind === 'session.compact';
-    if (occupiesDirectory && await productionDirectoryBusy(state, parsed.data.workspaceId, parsed.data.directoryName)) {
+    if (occupiesDirectory && await batchDirectoryHeld(state, parsed.data.workspaceId, parsed.data.directoryName)) {
         writeJson(response, 409, { error: 'batch_workspace_readonly' });
         return;
     }
@@ -909,7 +894,7 @@ async function acceptOperation(state, request, response) {
         writeJson(response, executed.status === 'failed' ? 409 : 202, executed);
     });
     const acceptBound = async () => {
-        if (occupiesDirectory && await productionDirectoryBusy(state, parsed.data.workspaceId, parsed.data.directoryName)) {
+        if (occupiesDirectory && await batchDirectoryHeld(state, parsed.data.workspaceId, parsed.data.directoryName)) {
             writeJson(response, 409, { error: 'batch_workspace_readonly' });
             return;
         }
@@ -929,7 +914,7 @@ async function acceptOperation(state, request, response) {
         else
             await accept();
     };
-    // Production admission and maintenance use this same lock before checking durable occupancy.
+    // Directory maintenance uses this same lock before checking durable occupancy.
     if (occupiesDirectory && state.config.workspaceMode === 'multi')
         await state.journal.exclusive(`directory:${parsed.data.workspaceId}:${parsed.data.directoryName ?? 'basic'}`, acceptBound);
     else

package/dist/workspace-runtime/server/terminal-host.js

@@ -1,4 +1,4 @@
-import { productionDirectoryBusy } from '../production/controller.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { createRequire } from 'node:module';
 import { randomUUID } from 'node:crypto';
 import { lstat } from 'node:fs/promises';
@@ -67,7 +67,7 @@ export class TerminalHost {
             rejectUpgrade(socket, 404, { error: 'terminal_not_found' });
             return;
         }
-        if (await productionDirectoryBusy(this.state, terminal.workspaceId, terminal.directoryName)) {
+        if (await batchDirectoryHeld(this.state, terminal.workspaceId, terminal.directoryName)) {
             rejectUpgrade(socket, 409, { error: 'batch_workspace_readonly' });
             return;
         }

package/dist/workspace-runtime/workspaces/cli-credentials.js

@@ -24,7 +24,7 @@ export async function ensureCliCredentials(state) {
         entry = { closed: false, expiresAt: 0, epoch: -1 };
         entries.set(state, entry);
     }
-    if (entry.closed)
+    if (entry.closed || state.journal.destroyed())
         throw new Error('cli_credentials_unavailable');
     if (entry.epoch === state.runtimeEpoch && entry.expiresAt > Date.now() + 60_000)
         return;
@@ -33,6 +33,9 @@ export async function ensureCliCredentials(state) {
             entry.pending = undefined;
         });
     await entry.pending;
+    if (entry.closed || state.journal.destroyed() || entry.epoch !== state.runtimeEpoch
+        || entry.expiresAt <= Date.now() + 60_000)
+        throw new Error('cli_credentials_unavailable');
 }
 async function renew(state, entry) {
     const config = state.config;
@@ -92,7 +95,8 @@ async function renew(state, entry) {
         if (!entry.closed && !state.journal.destroyed()) {
             if (entry.timer)
                 clearTimeout(entry.timer);
-            const wait = entry.expiresAt > Date.now() + 60_000 ? entry.expiresAt - Date.now() - 59_000 : 30_000;
+            const wait = entry.epoch === state.runtimeEpoch && entry.expiresAt > Date.now() + 60_000
+                ? entry.expiresAt - Date.now() - 59_000 : 30_000;
             entry.timer = setTimeout(() => void ensureCliCredentials(state).catch(() => undefined), wait);
             entry.timer.unref();
         }

package/dist/workspace-runtime/workspaces/directories.js

@@ -12,16 +12,13 @@ import { revisionScope } from './registry.js';
 import { ensureWorkspaceSkills } from './skills.js';
 import { checkoutBatchCommit, freezeBatchCommit } from './batch-commit.js';
 import { ensureWorkspaceArtifactInstructions } from './instructions.js';
-import { checkoutProductionSourceArchive } from '../production/source-archive.js';
 import { shareWorkspaceRepository } from './git.js';
 const execute = promisify(execFile);
 /** Trusted Runtime registration restores immutable input; it never follows basic's current branch head. */
-export async function registerWorkspaceDirectory(state, input, leaseFence, sourceDirectoryName, sourceArchive) {
+export async function registerWorkspaceDirectory(state, input, leaseFence, sourceDirectoryName) {
     const directory = workspaceDirectoryRegistrationSchema.parse(input);
     if (directory.directoryName === 'basic')
         throw new WorkspaceContextError('workspace_directory_binding_conflict');
-    if (sourceArchive && (sourceArchive.snapshot.sourceWorkspaceId !== directory.workspaceId || sourceArchive.snapshot.commitHash !== directory.sourceCommit))
-        throw new WorkspaceContextError('workspace_directory_binding_conflict');
     return state.journal.exclusive(`directory:${directory.workspaceId}:${directory.directoryName}`, async () => {
         if (state.journal.destroyed())
             throw new WorkspaceContextError('runtime_destroyed');
@@ -51,22 +48,15 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
                 throw new WorkspaceContextError('workspace_directory_source_commit_required');
             const staging = join(parent, `.directory-${randomUUID()}`);
             try {
-                if (sourceArchive) {
-                    if (!sourceArchive.body)
-                        throw new WorkspaceContextError('production_source_archive_required');
-                    await checkoutProductionSourceArchive({ snapshot: sourceArchive.snapshot, body: sourceArchive.body, destination: staging });
-                }
-                else {
-                    const source = await workspaceRoot(state, directory.workspaceId, sourceDirectoryName ?? 'basic');
-                    await git(source, 'cat-file', '-e', `${directory.sourceCommit}^{commit}`);
-                    if (sourceDirectoryName !== undefined) {
-                        const frozen = await freezeBatchCommit({ source: { workspaceId: directory.workspaceId, root: source },
-                            commitHash: directory.sourceCommit, snapshotId: `directory-${directory.remixId}` });
-                        await checkoutBatchCommit({ source: { workspaceId: directory.workspaceId, root: source }, frozen, destination: staging });
-                    }
-                    else
-                        await execute('git', ['-c', 'core.hooksPath=/dev/null', 'clone', '--local', '--no-hardlinks', '--no-checkout', '--', source, staging], { timeout: 90_000, maxBuffer: 1024 * 1024 });
+                const source = await workspaceRoot(state, directory.workspaceId, sourceDirectoryName ?? 'basic');
+                await git(source, 'cat-file', '-e', `${directory.sourceCommit}^{commit}`);
+                if (sourceDirectoryName !== undefined) {
+                    const frozen = await freezeBatchCommit({ source: { workspaceId: directory.workspaceId, root: source },
+                        commitHash: directory.sourceCommit, snapshotId: `directory-${directory.remixId}` });
+                    await checkoutBatchCommit({ source: { workspaceId: directory.workspaceId, root: source }, frozen, destination: staging });
                 }
+                else
+                    await execute('git', ['-c', 'core.hooksPath=/dev/null', 'clone', '--local', '--no-hardlinks', '--no-checkout', '--', source, staging], { timeout: 90_000, maxBuffer: 1024 * 1024 });
                 await git(staging, 'checkout', '-b', directory.branchName, directory.sourceCommit);
                 await git(staging, 'remote', 'set-url', 'origin', binding.repositoryUrl);
                 await git(staging, 'config', 'user.name', 'PlayCraft');
@@ -90,7 +80,7 @@ export async function registerWorkspaceDirectory(state, input, leaseFence, sourc
             const latest = state.journal.getWorkspace(directory.workspaceId) ?? binding;
             await state.journal.putWorkspace({ ...latest, directories: [...(latest.directories ?? []).filter(item => item.directoryName !== directory.directoryName), { ...directory, status: 'ready' }] });
         });
-        if (state.gitCredentials && !sourceArchive)
+        if (state.gitCredentials)
             await state.gitCredentials.configure(state.journal.getWorkspace(directory.workspaceId) ?? binding, await state.gitCredentials.prepareDirectory(directory.workspaceId, directory.directoryName), directory.directoryName);
         return directory;
     });

package/dist/workspace-runtime/workspaces/directory-maintenance.js

@@ -4,14 +4,14 @@ import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { promisify } from 'node:util';
 import { workspaceDirectoryNameSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { productionDirectoryBusy } from '../production/controller.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { workspaceRoot, workspaceSessions } from './registry.js';
 const execute = promisify(execFile);
 const git = async (state, root, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root, ...args], {
     timeout: 30_000, maxBuffer: 1024 * 1024, env: { PATH: process.env.PATH, HOME: state.config.stateDir, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
 })).stdout.trim();
-export async function workspaceDirectoryOccupied(state, workspaceId, directoryName, excludeAttemptId, ignoreSourceCaptures = false) {
-    if (await productionDirectoryBusy(state, workspaceId, directoryName, excludeAttemptId, ignoreSourceCaptures))
+export async function workspaceDirectoryOccupied(state, workspaceId, directoryName) {
+    if (await batchDirectoryHeld(state, workspaceId, directoryName))
         return true;
     if (state.journal.listOperations().some(({ operation }) => operation.workspaceId === workspaceId
         && (operation.directoryName ?? 'basic') === directoryName && ['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.44-beta",
+  "version": "0.1.46-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -51,8 +51,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.44-beta",
-    "@playcraft/common": "^0.1.44-beta",
+    "@playcraft/build": "^0.1.46-beta",
+    "@playcraft/common": "^0.1.46-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

package/project-template-v2/.playcraft/skills.lock.json

@@ -66,8 +66,8 @@
     },
     {
       "skillRef": "platform/playcraft-project-management",
-      "version": "1.0.0",
-      "artifactHash": "e7e4bffe80e0737362a5cac4234056a7d7fb048f0c8b5e41041e61ee914495e3",
+      "version": "1.1.0",
+      "artifactHash": "8653eefd40bc3b5a84728522f778515332c2334e64d90407ce2f8846a1f72e98",
       "surface": "portal-agent",
       "mountPath": ".playcraft/skills/platform__playcraft-project-management"
     },

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

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import { workspacePreparationSchema } from '@playcraft/common/cloud-workspace/runtime';
-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(),
-    repairPreparation: z.custom(value => workspacePreparationSchema.safeParse(value).success).optional(),
-}).strict();