@playcraft/cli 0.1.57-beta → 0.1.59-beta

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

@@ -2,6 +2,7 @@ import { withObservedFile } from '../workspaces/revisions.js';
 import { revisionScope, sessionWorkspaceRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
 import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../workspaces/turn-changes.js';
 import { shareWorkspaceGit } from '../workspaces/shared-git.js';
+import { holdDirectoryAccess, withOperationDirectoryAccess } from './directory-access.js';
 import { join } from 'node:path';
 import { z } from 'zod';
 import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
@@ -11,6 +12,7 @@ import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
 import { resolveWorkspaceAttachments } from '../workspaces/attachments.js';
 import { importWorkspaceRemixReference, RemixReferenceError } from '../workspaces/remix-references.js';
 import { ComposerContextError, resolveComposerContext } from '../workspaces/composer-context.js';
+import { ensureParameterInitializationSkill } from '../workspaces/parameter-initialization-skill.js';
 import { readWorkspaceSkillSnapshot, readWorkspaceSkills } from '../workspaces/skills.js';
 import { loadWorkspaceSkillArtifact, workspacePlatformSkillAccess } from '../workspaces/skill-artifact-loader.js';
 import { enableLocalProjectSkill, syncLocalProjectSkills } from '../../project-skills/local-store.js';
@@ -28,9 +30,10 @@ import { ThemeAssetIndexError } from '../workspaces/theme-asset-index.js';
 import { patchWorkspaceParameters, readWorkspaceParameters } from '../workspaces/parameters.js';
 import { prepareParameterAgentTask, finishParameterAgentTask, verifyParameterAgentTask, } from '../workspaces/parameter-agent.js';
 import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPreviewPublish, } from '../previews/publish.js';
-import { spawnBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
+import { startManagedBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
 import { batchDirectoryHeld } from '../batch/occupancy.js';
+import { trustedMemberPolicy } from '../batch/policy.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';
@@ -90,6 +93,8 @@ export async function recoverInterruptedParameterVerifications(journal) {
     for (const { scopeKey, operation } of journal.listOperations()) {
         if (operation.kind !== 'parameter.verify' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
             continue;
+        if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+            continue;
         await journal.putOperation(scopeKey, transitionOperation(operation, 'interrupted', { error: 'parameter_verification_interrupted' }));
     }
 }
@@ -105,12 +110,21 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
         if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed()) {
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: state.journal.destroyed() ? 'runtime_destroyed' : 'stale_lease' }));
         }
-        return executeScopedOperation(state, scopeKey, operation, payload, recovery);
+        if (operation.kind === 'session.turn' && !recovery && operation.sessionId &&
+            state.journal.getSession(operation.sessionId)?.recoverability === 'history_only')
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'native_not_recoverable' }));
+        return withOperationDirectoryAccess(state, operation, () => {
+            if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
+                return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: state.journal.destroyed() ? 'runtime_destroyed' : 'stale_lease' }));
+            return executeScopedOperation(state, scopeKey, operation, payload, recovery);
+        }, { operationId: operation.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}) });
     };
     if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel'].includes(operation.kind)) {
         return run();
     }
-    return state.journal.exclusive(`workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, run);
+    return state.journal.exclusive(operation.kind.startsWith('session.') && operation.sessionId
+        ? `session-execution:${operation.sessionId}`
+        : `workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, run);
 }
 async function executeScopedOperation(state, scopeKey, operation, payload, recovery) {
     let current = await persist(state, scopeKey, transitionOperation(operation, 'dispatched'));
@@ -204,7 +218,7 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
         if (operation.kind === 'session.steer')
             return executeSteer(state, scopeKey, current, payload);
         if (operation.kind === 'session.interrupt') {
-            return executeInterrupt(state, scopeKey, current);
+            return executeInterrupt(state, scopeKey, current, payload);
         }
         if (operation.kind === 'session.approval.respond') {
             return executeApproval(state, scopeKey, current, payload);
@@ -381,12 +395,12 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         }
         found = rebound;
     }
-    const binding = found;
     // Also covers a new thread whose first turn failed before starting: the next turn still carries it.
-    const context = recovery && binding?.recoveryContextPending ? recovery.context : '';
-    if (!binding) {
+    const context = recovery && found?.recoveryContextPending ? recovery.context : '';
+    if (!found) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
+    let binding = found;
     if ((binding.directoryName ?? 'basic') !== (operation.directoryName ?? 'basic')) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'context_directory_mismatch' }));
     }
@@ -398,17 +412,30 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     }
     const root = await sessionWorkspaceRoot(state, operation.workspaceId, operation.directoryName);
     let composer;
+    let initializationSkill;
     try {
+        let turnContext = selection.data.context;
+        if (parameterTask.data?.action === 'initialize') {
+            const selectedSkill = await ensureParameterInitializationSkill(root);
+            initializationSkill = { ...selectedSkill,
+                path: join(root, '.playcraft/skills', selectedSkill.lockHash, selectedSkill.entryKey, 'SKILL.md') };
+            turnContext = { ...turnContext, files: turnContext?.files ?? [], skills: [
+                    ...(turnContext?.skills ?? []).filter(skill => skill.entryKey !== selectedSkill.entryKey), selectedSkill,
+                ] };
+        }
         composer = await resolveComposerContext({
             root,
-            directoryName: binding.directoryName ?? 'basic', context: selection.data.context,
+            directoryName: binding.directoryName ?? 'basic', context: turnContext,
             skillCache: join(state.config.stateDir, 'skill-artifacts'),
             loadSkillArtifact: entry => loadWorkspaceSkillArtifact(state, operation.workspaceId ?? 'workspace', entry),
         });
     }
     catch (error) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', {
-            error: error instanceof ComposerContextError ? error.message : 'invalid_composer_context',
+            error: error instanceof ComposerContextError ? error.message : parameterTask.data?.action === 'initialize'
+                ? error instanceof Error && /^(?:workspace_skills_|skills_revision_conflict$)/.test(error.message)
+                    ? error.message : parameterAgentError(error)
+                : 'invalid_composer_context',
         }));
     }
     let attachments;
@@ -429,7 +456,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}\n\n`
         : '';
     const engineeringBatchContext = state.config.workspaceMode === 'multi' && operation.workspaceId
-        && operation.directoryName !== 'root' && !productionSessionAttemptId(sessionId)
+        && operation.directoryName !== 'root' && !productionSessionAttemptId(sessionId) && !trustedMemberPolicy(state, sessionId)
         ? `PlayCraft batch request context (trusted runtime identity): ${JSON.stringify({ workspaceId: operation.workspaceId,
             clientRequestId: operation.clientRequestId, sourceDirectoryName: binding.directoryName ?? 'basic',
             ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}`
@@ -446,7 +473,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     let parameterInstructions = '';
     if (parameterTask.data) {
         try {
-            parameterInstructions = (await prepareParameterAgentTask(state, operation, parameterTask.data, root)).instructions;
+            parameterInstructions = (await prepareParameterAgentTask(state, operation, parameterTask.data, root, { initializationSkill })).instructions;
         }
         catch (error) {
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: parameterAgentError(error) }));
@@ -458,7 +485,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     });
     let result;
     try {
-        result = await native(state).startTurn({
+        const startTurn = () => native(state).startTurn({
             sessionId,
             threadId: binding.threadId,
             text: composer.append(batchContext + context + String(body.text ?? '') + attachmentText, [engineeringBatchContext, parameterInstructions].filter(Boolean).join('\n\n')),
@@ -490,6 +517,18 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
                 await state.journal.putSession({ ...binding, modelConfigId, reasoningEffort: selectedEffort, permissionMode: selectedMode, turnStatus: 'starting' });
             },
         });
+        result = await startTurn();
+        // The native runtime cannot persist an empty thread before its first turn. Adding the
+        // selected skill can therefore require replacing that empty thread, before any model work.
+        if (initializationSkill && result.outcome === 'failed' && result.error === 'workspace_skills_changed'
+            && !(state.journal.getOperation(scopeKey) ?? operation).nativeRequestId) {
+            const started = await native(state).startThread({ sessionId, cwd: root,
+                modelConfigId: selected.data ?? binding.modelConfigId, reasoningEffort: requestedEffort, permissionMode: requestedMode });
+            binding = { ...binding, threadId: started.threadId, modelConfigId: started.modelConfigId ?? binding.modelConfigId,
+                reasoningEffort: started.reasoningEffort ?? requestedEffort, permissionMode: started.permissionMode ?? requestedMode };
+            await state.journal.putSession(binding);
+            result = await startTurn();
+        }
     }
     catch (error) {
         if (!parameterTask.data)
@@ -811,13 +850,18 @@ async function executeSteer(state, scopeKey, operation, payload) {
             } }]);
     return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
 }
-async function executeInterrupt(state, scopeKey, operation) {
+async function executeInterrupt(state, scopeKey, operation, payload) {
     const sessionId = required(operation.sessionId, 'sessionId');
     const binding = state.journal.getSession(sessionId);
     if (!binding) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
-    const result = await native(state).interrupt({ sessionId, threadId: binding.threadId });
+    const expectedTurnId = asRecord(payload).expectedTurnId;
+    if (expectedTurnId !== undefined && (typeof expectedTurnId !== 'string' || !expectedTurnId
+        || binding.activeTurnId !== expectedTurnId))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_changed' }));
+    const result = await native(state).interrupt({ sessionId, threadId: binding.threadId,
+        ...(typeof expectedTurnId === 'string' ? { expectedTurnId } : {}) });
     if (result.outcome === 'failed') {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: result.error ?? 'turn_not_running' }));
     }
@@ -1113,7 +1157,7 @@ async function executeFileWrite(state, scopeKey, operation, payload) {
             : 'invalid_workspace_path';
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error }));
     }
-    const workspaceId = operation.workspaceId ?? 'workspace';
+    const workspaceId = revisionScope(state, operation.workspaceId, operation.directoryName) ?? operation.workspaceId ?? 'workspace';
     const writer = parsed.data.writer ?? 'manual';
     if (parsed.data.release) {
         const lease = state.journal.getManagedWrite(parsed.data.writeId);
@@ -1147,17 +1191,14 @@ async function executeFileWrite(state, scopeKey, operation, payload) {
                 contentHash: written.contentHash,
             }, revisionScope(state, operation.workspaceId, operation.directoryName));
             if (parsed.data.hold && parsed.data.writeId) {
-                let pid;
+                const record = { writeId: parsed.data.writeId, workspaceId, source: writer, startedAt: new Date().toISOString() };
                 if (writer === 'background') {
-                    pid = spawnBackgroundWriter(await resolveWorkspaceFile(root, parsed.data.path));
+                    await startManagedBackgroundWriter(state, record, await resolveWorkspaceFile(root, parsed.data.path));
+                }
+                else {
+                    await holdDirectoryAccess(state, operation, `managed:${parsed.data.writeId}`, 'shared');
+                    await state.journal.putManagedWrite(record);
                 }
-                await state.journal.putManagedWrite({
-                    writeId: parsed.data.writeId,
-                    workspaceId,
-                    source: writer,
-                    startedAt: new Date().toISOString(),
-                    pid,
-                });
             }
             const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { expectedRevision: revision }));
             if (artifactFormat(parsed.data.path) && operation.workspaceId) {
@@ -1238,11 +1279,12 @@ async function executeWorkspaceSave(state, scopeKey, operation, payload) {
     }
     const binding = operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId) : undefined;
     try {
-        const saved = await saveWorkspaceGit(await gitWorkspaceRoot(state, operation), {
+        // Saves share the directory, and a deferred one runs outside the workspace queue; commit one at a time.
+        const saved = await state.journal.exclusive(`workspace-save:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, async () => saveWorkspaceGit(await gitWorkspaceRoot(state, operation), {
             message: parsed.data.trigger === 'auto' ? 'Autosave workspace' : 'Save workspace',
             push: savePushesBranch(binding?.targetKind, operation.directoryName),
             boundBranch: boundBranch(state, operation),
-        });
+        }));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {
@@ -1349,7 +1391,9 @@ async function executeParameterPatch(state, scopeKey, operation, payload) {
     if (document.status === 'missing' || document.status === 'schema_only' || !document.dataPath) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_data_missing' }));
     }
-    const dataPath = document.dataPath;
+    const dataPath = 'documentId' in parsed.data ? document.runtimeI18n?.themePath : document.dataPath;
+    if (!dataPath)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_i18n_global_invalid' }));
     return withObservedFile(state, operation.workspaceId, dataPath, async ({ revision: currentRevision, file }) => {
         if (parsed.data.expectedRevision !== currentRevision) {
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'revision_conflict' }));
@@ -1386,6 +1430,7 @@ async function executeParameterPatch(state, scopeKey, operation, payload) {
                         revision,
                         contentHash: written.contentHash,
                         size: written.size,
+                        ...('documentId' in parsed.data ? { documentId: parsed.data.documentId } : {}),
                         ...('changes' in parsed.data
                             ? { fieldPaths: parsed.data.changes.map((change) => change.fieldPath) }
                             : { fieldPath: parsed.data.fieldPath }),
@@ -1416,7 +1461,7 @@ async function executePreviewPublish(state, scopeKey, operation) {
     trackPreviewPublish(state, runPreviewPublish(state, accepted, root).then(async () => {
         await persist(state, scopeKey, transitionOperation(accepted, 'completed'));
     }, async (error) => {
-        await persist(state, scopeKey, transitionOperation(accepted, 'failed', { error: previewFailureCode(error) }));
+        await persist(state, scopeKey, transitionOperation(accepted, previewFailureCode(error) === 'preview_process_unknown' ? 'uncertain' : 'failed', { error: previewFailureCode(error) }));
     }).catch(() => undefined));
     return accepted;
 }
@@ -1438,7 +1483,7 @@ async function executeDeliveryBuild(state, scopeKey, operation, payload) {
     }).then(async (result) => {
         const error = result.record.error
             ?? (result.record.status === 'succeeded' ? undefined : 'delivery_build_failed');
-        await persist(state, scopeKey, transitionOperation(accepted, result.record.status === 'succeeded' ? 'completed' : 'failed', error ? { error } : {}));
+        await persist(state, scopeKey, transitionOperation(accepted, result.record.status === 'succeeded' ? 'completed' : error === 'delivery_process_unknown' ? 'uncertain' : 'failed', error ? { error } : {}));
     }, async (error) => {
         await persist(state, scopeKey, transitionOperation(accepted, 'failed', {
             error: error instanceof DeliveryBuildError ? error.code : 'delivery_build_failed',

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

@@ -12,6 +12,7 @@ export async function applyRuntimeEndpointPatch(state, patch) {
         throw new Error('endpoint_config_path_missing');
     }
     const temporary = `${state.configPath}.${process.pid}.tmp`;
+    // private
     await writeFile(temporary, `${JSON.stringify(next)}\n`, { mode: 0o600 });
     await chmod(temporary, 0o600);
     await rename(temporary, state.configPath);

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

@@ -3,7 +3,7 @@ import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.j
 import { registerWorkspace, revisionScope, sessionWorkspaceRoot, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
 import { constants } from 'node:fs';
 import { access as accessDirectory, stat } from 'node:fs/promises';
-import { workspaceRegistrationRequestSchema, workspaceFileSearchQuerySchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, sourceAckSchema, operationAcceptRequestSchema, operationLogSchema, operationKindSchema, operationScopeKey, productionSessionAttemptId, takesWorkspaceDirectory, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, workspaceUiResultSchema, workspaceRemixReferenceImportRequestSchema, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES, WORKSPACE_ASSET_LIBRARY_IMPORT_BODY_MAX_BYTES, workspaceSessionRestoreRequestSchema, workspaceSessionRestoreResponseSchema, deliveryValidatePayloadSchema, deliveryBuildListQuerySchema, deliveryBuildListSchema, deliveryBuildDetailSchema, deliveryBuildLogSchema, workspaceDirectoryNameSchema, attachmentIdsSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceRegistrationRequestSchema, workspaceFileSearchQuerySchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, gitFileRefSchema, sourceAckSchema, operationAcceptRequestSchema, operationLogSchema, operationKindSchema, operationScopeKey, productionSessionAttemptId, takesWorkspaceDirectory, nativeHistoryReadSchema, runtimeError, runtimeConnectivityDocumentSchema, unavailableRuntimeCapabilities, workspaceUiResultSchema, workspaceRemixReferenceImportRequestSchema, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES, WORKSPACE_ASSET_LIBRARY_IMPORT_BODY_MAX_BYTES, workspaceSessionRestoreRequestSchema, workspaceSessionRestoreResponseSchema, deliveryValidatePayloadSchema, deliveryBuildListQuerySchema, deliveryBuildListSchema, deliveryBuildDetailSchema, deliveryBuildLogSchema, workspaceDirectoryNameSchema, workspaceDirectoryRegistrationSchema, attachmentIdsSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { controlTokenMatches, extractControlToken } from './auth.js';
 import { applyRuntimeEndpointPatch } from './endpoints.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
@@ -12,6 +12,7 @@ import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWork
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
 import { listParameterAgentTasks } from '../workspaces/parameter-agent.js';
 import { readDependencies } from '../workspaces/dependencies.js';
+import { permissionDriftFromError } from '../workspaces/workspace-shares.js';
 import { desktopHost, desktopRoute } from './desktop-host.js';
 import { ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { readAttachmentUpload, uploadWorkspaceAttachment, uploadWorkspaceVideoAttachment } from '../workspaces/attachments.js';
@@ -40,11 +41,37 @@ import { workspaceArtifactContentQuerySchema } from '@playcraft/common/cloud-wor
 import { searchWorkspaceFiles } from '../workspaces/files-search.js';
 import { serveWorkspaceArchive } from '../workspaces/archive.js';
 import { handleWorkspaceTransfer } from './workspace-transfer.js';
+import { handleWorkspaceStorage } from './workspace-storage.js';
 import { serveSessionImage } from '../workspaces/session-image.js';
 import { restoreNativeSession, SessionRestoreError } from './session-restore.js';
 import { handleAssetTransferRequest } from './asset-transfers.js';
 import { readWorktreeSource, registerChatWorktree } from '../workspaces/worktrees.js';
+import { withDirectoryWrite } from './directory-access.js';
 export async function handleRuntimeRequest(state, request, response) {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    const workspaceId = url.searchParams.get('workspaceId');
+    // Body-scoped operations, members and terminal control take their own lifetime-aware leases.
+    const ownLease = url.pathname.startsWith('/runtime/operations') || url.pathname.startsWith('/runtime/terminals/') ||
+        url.pathname.startsWith('/runtime/batch-') || /^\/runtime\/sessions\/[^/]+\/ui-results$/.test(url.pathname) ||
+        /^\/runtime\/sessions\/[^/]+\/prediction$/.test(url.pathname);
+    if (authorizeRuntime(state, request) === 'control' && workspaceId &&
+        (!['GET', 'HEAD', 'OPTIONS'].includes(request.method ?? 'GET') || url.pathname === '/runtime/git-bundle') && !ownLease) {
+        try {
+            return await withDirectoryWrite(state, { workspaceId, directoryName: url.searchParams.get('directoryName') ?? 'basic', wait: false,
+                sessionId: url.searchParams.get('sessionId') ?? undefined,
+                ...(url.pathname === '/runtime/git-bundle' ? { mode: 'exclusive' } : {}) }, () => dispatchRuntimeRequest(state, request, response));
+        }
+        catch (error) {
+            if (!response.headersSent)
+                writeJson(response, error instanceof Error && error.message === 'directory_busy' ? 409 : 500, { error: error instanceof Error && error.message === 'directory_busy' ? 'directory_busy' : 'runtime_request_failed' });
+            else
+                response.destroy(error instanceof Error ? error : undefined);
+            return;
+        }
+    }
+    return dispatchRuntimeRequest(state, request, response);
+}
+async function dispatchRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const directoryName = url.searchParams.get('directoryName') ?? 'basic';
     const access = authorizeRuntime(state, request);
@@ -57,6 +84,8 @@ export async function handleRuntimeRequest(state, request, response) {
         return;
     }
     try {
+        if (await handleWorkspaceStorage(state, request, response, url))
+            return;
         const transfer = await handleAssetTransferRequest(state, request, url);
         if (transfer) {
             writeJson(response, transfer.status, transfer.body);
@@ -103,12 +132,17 @@ export async function handleRuntimeRequest(state, request, response) {
                 instanceToken: state.instanceToken,
                 permissionsVersion: 1,
                 composerContextVersion: 1,
+                scheduledTaskIdentityVersion: 1,
+                scheduledTaskCancellationVersion: 1,
                 parameterAgentVersion: 1,
+                directoryConcurrencyVersion: 1,
+                parameterInitializationVersion: 1,
                 remixReferencesVersion: 1,
                 batchSourceFreezeRevision: 2,
                 ...(state.native?.workspaceUi ? { workspaceUiVersion: 1 } : {}),
                 ...(state.native?.startReview && state.native?.steer ? { turnControlVersion: 1 } : {}),
                 ...(state.native?.startCompact ? { compactionVersion: 1 } : {}),
+                ...(state.native?.startPrediction ? { predictionVersion: 1 } : {}),
                 sourceReadToken: state.journal.sourceReadToken(),
                 workspaceMode: state.config.workspaceMode,
                 executionGroup: {
@@ -181,6 +215,27 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, result.outcome === 'accepted' ? 200 : 409, result);
             return;
         }
+        const predictionRoute = /^\/runtime\/sessions\/([^/]+)\/prediction$/.exec(url.pathname);
+        if (request.method === 'POST' && predictionRoute) {
+            if (writeDestroyed(state, response))
+                return;
+            const sessionId = decodeURIComponent(predictionRoute[1]);
+            const session = state.journal.getSession(sessionId);
+            if (!session || productionSessionAttemptId(sessionId) || session.workspaceId !== url.searchParams.get('workspaceId')
+                || (session.directoryName ?? 'basic') !== directoryName) {
+                writeJson(response, 404, { error: 'session_not_found' });
+                return;
+            }
+            if (!state.native?.startPrediction) {
+                writeJson(response, 409, { error: 'prediction_unavailable' });
+                return;
+            }
+            // Best-effort and read-only: no instruction/journal reservation, and the ephemeral
+            // fork never becomes a user-visible thread.
+            const result = await state.native.startPrediction({ sessionId, threadId: session.threadId });
+            writeJson(response, result.outcome === 'ok' ? 200 : 409, result);
+            return;
+        }
         if (request.method === 'POST' && url.pathname === '/runtime/workspaces/register') {
             if (writeDestroyed(state, response))
                 return;
@@ -189,7 +244,7 @@ export async function handleRuntimeRequest(state, request, response) {
                 writeJson(response, 409, { error: 'invalid_workspace_registration' });
                 return;
             }
-            const binding = await registerWorkspace(state, parsed.data.binding, parsed.data.leaseFence, parsed.data.preparation, parsed.data.cliCredentials === false, parsed.data.sourceSnapshot);
+            const binding = await withDirectoryWrite(state, { workspaceId: parsed.data.binding.workspaceId, directoryName: 'basic', wait: false }, () => registerWorkspace(state, parsed.data.binding, parsed.data.leaseFence, parsed.data.preparation, parsed.data.cliCredentials === false, parsed.data.sourceSnapshot));
             if (parsed.data.cliCredentials)
                 await ensureCliCredentials(state);
             writeJson(response, 200, { workspaceId: binding.workspaceId, status: 'registered' });
@@ -210,10 +265,13 @@ export async function handleRuntimeRequest(state, request, response) {
                     writeJson(response, 400, { error: 'invalid_workspace_registration' });
                     return;
                 }
-                writeJson(response, 200, await registerChatWorktree(state, body.directory, Number(body.leaseFence), source.data, body.sourceBranchName, attachments.data));
+                const directory = workspaceDirectoryRegistrationSchema.parse(body.directory);
+                writeJson(response, 200, await withDirectoryWrite(state, { ...directory, mode: 'exclusive', wait: false }, () => withDirectoryWrite(state, { workspaceId: directory.workspaceId, directoryName: source.data, mode: 'exclusive', wait: false }, () => registerChatWorktree(state, directory, Number(body.leaseFence), source.data, body.sourceBranchName, attachments.data))));
+            }
+            else {
+                const directory = workspaceDirectoryRegistrationSchema.parse(body.directory);
+                writeJson(response, 200, await withDirectoryWrite(state, { ...directory, mode: 'exclusive', wait: false }, () => registerWorkspaceDirectory(state, directory, Number(body.leaseFence))));
             }
-            else
-                writeJson(response, 200, await registerWorkspaceDirectory(state, body.directory, Number(body.leaseFence)));
             return;
         }
         if (request.method === 'POST' && url.pathname === '/runtime/workspaces/directories/worktree-source') {
@@ -226,7 +284,7 @@ export async function handleRuntimeRequest(state, request, response) {
                 writeJson(response, 409, { error: 'invalid_workspace_registration' });
                 return;
             }
-            writeJson(response, 200, await readWorktreeSource(state, body.workspaceId, source.data, Number(body.leaseFence), body.sourceBranchName));
+            writeJson(response, 200, await withDirectoryWrite(state, { workspaceId: body.workspaceId, directoryName: source.data, mode: 'exclusive', wait: false }, () => readWorktreeSource(state, body.workspaceId, source.data, Number(body.leaseFence), body.sourceBranchName)));
             return;
         }
         const maintenance = /^\/runtime\/workspaces\/([a-f0-9-]{36})\/directories\/(cleanup|sync|stats)$/.exec(url.pathname);
@@ -763,6 +821,10 @@ export async function handleRuntimeRequest(state, request, response) {
         writeJson(response, 404, { error: 'not_found' });
     }
     catch (error) {
+        if (error instanceof Error && error.message === 'directory_busy') {
+            writeJson(response, 409, { error: 'directory_busy' });
+            return;
+        }
         if (request.method === 'GET' && ['/runtime/connectivity', '/runtime/files'].includes(url.pathname)) {
             const cause = error instanceof Error && error.cause ? error.cause : error;
             if (['EACCES', 'EPERM'].includes(String(cause?.code))) {
@@ -778,6 +840,12 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, 413, { error: 'request_body_too_large' });
             return;
         }
+        // A shared path without development-group access is a repair, not an internal failure.
+        const drift = permissionDriftFromError(error);
+        if (drift) {
+            writeJson(response, 409, { error: 'workspace_permission_drift', ...drift });
+            return;
+        }
         if (error instanceof WorkspaceContextError) {
             writeJson(response, 409, { error: error.message });
             return;
@@ -858,7 +926,7 @@ async function acceptOperation(state, request, response) {
         return;
     }
     // leaseFence 由 Runtime Server 派发，本控制面单独校验；其余代次/身份/根目录字段仍只来自引导配置。
-    const untrusted = findUntrustedRuntimeFields(body).filter((field) => field !== 'leaseFence');
+    const untrusted = findUntrustedRuntimeFields(body).filter((field) => field !== 'leaseFence' && field !== 'gatewayOperationId');
     if (untrusted.length > 0) {
         writeError(response, runtimeError('untrusted_runtime_field', untrusted.join(',')));
         return;
@@ -896,7 +964,7 @@ async function acceptOperation(state, request, response) {
         return;
     }
     if (state.config.workspaceMode === 'multi' && parsed.data.kind === 'runtime.ensure' && parsed.data.workspaceId)
-        await restoreWorkspaceDirectory(state, parsed.data.workspaceId, parsed.data.directoryName);
+        await withDirectoryWrite(state, { workspaceId: parsed.data.workspaceId, directoryName: parsed.data.directoryName, mode: 'exclusive', wait: false }, () => restoreWorkspaceDirectory(state, parsed.data.workspaceId, parsed.data.directoryName));
     if (state.config.workspaceMode === 'multi')
         await sessionWorkspaceRoot(state, parsed.data.workspaceId, parsed.data.directoryName);
     // Shared classification: a new conversation writes no files, so a batch hold must not refuse it.
@@ -995,7 +1063,9 @@ async function acceptOperation(state, request, response) {
     };
     // 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);
+        await state.journal.exclusive(parsed.data.kind.startsWith('session.') && parsed.data.sessionId
+            ? `session-admission:${parsed.data.sessionId}`
+            : `directory:${parsed.data.workspaceId}:${parsed.data.directoryName ?? 'basic'}`, acceptBound);
     else
         await acceptBound();
 }
@@ -1152,7 +1222,7 @@ async function readObservedParameters(state, workspaceId, directoryName = 'basic
     const scope = revisionScope(state, workspaceId, directoryName);
     return state.journal.exclusive(`workspace:${scope ?? 'single'}`, async () => {
         const first = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
-        for (const path of [first.schemaPath, first.dataPath]) {
+        for (const path of [first.schemaPath, first.dataPath, first.runtimeI18n?.globalPath, first.runtimeI18n?.themePath]) {
             if (path)
                 await withObservedFile(state, workspaceId, path, async () => undefined, directoryName);
         }

package/dist/workspace-runtime/server/operation-record.js

@@ -7,6 +7,8 @@ export function buildOperationRecord(state, parsed, payloadHash, leaseFence, exe
         : {};
     return {
         operationId: randomUUID(),
+        ...(parsed.gatewayOperationId ? { gatewayOperationId: parsed.gatewayOperationId } : {}),
+        ...(parsed.kind === 'session.turn' && payload.parameterTask !== undefined ? { directoryAccessMode: 'exclusive' } : {}),
         environment: state.config.environment,
         userId: state.config.userId,
         clientRequestId: parsed.clientRequestId,