@playcraft/cli 0.1.45-beta → 0.1.47-beta

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;
@@ -108,6 +93,7 @@ export async function handleRuntimeRequest(state, request, response) {
                 permissionsVersion: 1,
                 composerContextVersion: 1,
                 remixReferencesVersion: 1,
+                batchSourceFreezeRevision: 2,
                 ...(state.native?.workspaceUi ? { workspaceUiVersion: 1 } : {}),
                 ...(state.native?.startReview && state.native?.steer ? { turnControlVersion: 1 } : {}),
                 ...(state.native?.startCompact ? { compactionVersion: 1 } : {}),
@@ -143,7 +129,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 +263,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 +289,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 +323,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 +340,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 +753,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 +895,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 +915,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/verify-artifact.js

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+import { readFile, mkdtemp, rm } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { batchSourceRemoteRef, parseSandboxRuntimeConfig } from '@playcraft/common/cloud-workspace/runtime';
+import { createLoopbackNativeAdapter } from './codex/loopback.js';
+import { startWorkspaceRuntime } from './serve.js';
+async function dependencyVersion(name, entry) {
+    let directory = dirname(createRequire(import.meta.url).resolve(entry));
+    for (;;) {
+        const metadata = await readFile(join(directory, 'package.json'), 'utf8').then(JSON.parse).catch(() => undefined);
+        if (metadata?.name === name)
+            return metadata.version;
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error(`package_metadata_missing:${name}`);
+        directory = parent;
+    }
+}
+/** Starts only an isolated temporary runtime; never reads or changes an existing workspace. */
+export async function verifyRuntimeArtifact(expectedVersion) {
+    assert.match(expectedVersion, /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/);
+    const metadata = JSON.parse(await readFile(new URL('../../package.json', import.meta.url), 'utf8'));
+    assert.equal(metadata.version, expectedVersion, 'command package version differs from the release target');
+    assert.equal(await dependencyVersion('@playcraft/common', '@playcraft/common/cloud-workspace/runtime'), expectedVersion);
+    assert.equal(await dependencyVersion('@playcraft/build', '@playcraft/build'), expectedVersion);
+    const batchId = randomUUID();
+    assert.equal(batchSourceRemoteRef(batchId), `refs/tags/playcraft/batch/${batchId}/source`, 'installed shared library lacks standard tag references for source snapshots');
+    const directory = await mkdtemp(join(tmpdir(), 'playcraft-artifact-verify-'));
+    let runtime;
+    try {
+        const config = parseSandboxRuntimeConfig({
+            protocolMajor: 1, protocolMinor: 0, environment: 'artifact-verification',
+            runtimeId: randomUUID(), userId: 'artifact-verification', generation: 1, runtimeEpoch: 0,
+            workspaceMode: 'multi', workspaceRoot: join(directory, 'workspaces'), stateDir: join(directory, 'state'),
+            publicBaseUrl: 'http://127.0.0.1:9', controlToken: randomUUID(), cliVersion: expectedVersion,
+            listen: { host: '127.0.0.1', port: 0 },
+        });
+        runtime = await startWorkspaceRuntime(config, { nativeAdapter: createLoopbackNativeAdapter() });
+        const response = await fetch(`${runtime.url}/runtime/identity`, {
+            headers: { authorization: `Bearer ${config.controlToken}` }, signal: AbortSignal.timeout(10_000),
+        });
+        assert.equal(response.status, 200, 'built runtime identity is unavailable');
+        const identity = await response.json();
+        assert.equal(identity.runtimeId, config.runtimeId);
+        assert.equal(identity.batchSourceFreezeRevision, 2, 'built runtime lacks the required batch source freeze implementation');
+    }
+    finally {
+        await runtime?.close();
+        await rm(directory, { recursive: true, force: true });
+    }
+}
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    await verifyRuntimeArtifact(process.argv[2] ?? '');
+    console.log('Runtime artifact verified: batchSourceFreezeRevision=2');
+}

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.45-beta",
+  "version": "0.1.47-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.45-beta",
-    "@playcraft/common": "^0.1.45-beta",
+    "@playcraft/build": "0.1.47-beta",
+    "@playcraft/common": "0.1.47-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

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();