@playcraft/cli 0.1.49-beta → 0.1.50-beta

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

@@ -4,7 +4,7 @@ import { abandonTurnChanges, beginTurnChanges, finishTurnChanges } from '../work
 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, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, } from '@playcraft/common/cloud-workspace/runtime';
+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';
 import { closeCliCredentials, ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
@@ -24,6 +24,7 @@ import { InvalidWorkspacePathError, resolveWorkspaceFile, writeWorkspaceFile, }
 import { GitWorkspaceError, commitWorkspaceGit, discardWorkspaceGit, pushWorkspaceGit, pullWorkspaceGit, abortWorkspaceMerge, saveWorkspaceGit, stageWorkspaceGit, unstageWorkspaceGit, } from '../workspaces/git.js';
 import { ParameterEditError } from '../workspaces/json5-edit.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 { wakeSourceEventUploader } from './source-uploader.js';
@@ -31,6 +32,10 @@ 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';
+import { DirectoryMutationError, mutateWorkspaceDirectory } from '../workspaces/directory-mutations.js';
+import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
+import { publishAssetTransfer } from '../workspaces/asset-transfer-publish.js';
+import { AssetTransferError } from '../workspaces/asset-transfer-storage.js';
 import { runDeliveryBuild, cancelDeliveryBuild, trackDeliveryBuild, DeliveryBuildError } from '../workspaces/delivery-build.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
@@ -47,7 +52,10 @@ const LOCAL_KINDS = new Set([
     'file.write',
     'file.binary.write',
     'asset.library.import',
+    'asset.bundle.save',
     'directory.create',
+    'directory.rename',
+    'directory.delete',
     'git.commit',
     'git.push',
     'git.pull',
@@ -59,11 +67,30 @@ const LOCAL_KINDS = new Set([
     'workspace.references.import',
     'terminal.create',
     'parameter.patch',
+    'parameter.verify',
     'preview.publish',
     'delivery.build',
     'delivery.cancel',
     'skills.update',
 ]);
+const parameterVerifications = new WeakMap();
+const parameterVerificationClosing = new WeakSet();
+export async function stopParameterVerifications(state) {
+    parameterVerificationClosing.add(state);
+    const tasks = parameterVerifications.get(state);
+    if (!tasks)
+        return;
+    for (const controller of tasks.keys())
+        controller.abort();
+    await Promise.allSettled(tasks.values());
+}
+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;
+        await journal.putOperation(scopeKey, transitionOperation(operation, 'interrupted', { error: 'parameter_verification_interrupted' }));
+    }
+}
 export function canExecuteKind(state, kind) {
     if (LOCAL_KINDS.has(kind))
         return true;
@@ -107,9 +134,15 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'asset.library.import') {
         return executeAssetLibraryImport(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'asset.bundle.save') {
+        return executeAssetBundleSave(state, scopeKey, current, payload);
+    }
     if (operation.kind === 'directory.create') {
         return executeDirectoryCreate(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'directory.rename' || operation.kind === 'directory.delete') {
+        return executeDirectoryMutation(state, scopeKey, current, payload);
+    }
     if (operation.kind === 'workspace.references.import') {
         return executeRemixReferenceImport(state, scopeKey, current, payload);
     }
@@ -140,6 +173,9 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'parameter.patch') {
         return executeParameterPatch(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'parameter.verify') {
+        return executeParameterVerify(state, scopeKey, current, payload);
+    }
     if (operation.kind === 'preview.publish') {
         return executePreviewPublish(state, scopeKey, current);
     }
@@ -321,6 +357,19 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
     if (!mode.success)
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_permission_mode' }));
     const requestedMode = mode.data ?? found?.permissionMode ?? recovery?.permissionMode ?? 'auto';
+    const parameterTask = parameterAgentTaskRequestSchema.optional().safeParse(body.parameterTask);
+    if (!parameterTask.success || (parameterTask.data && parameterTask.data.taskId !== operation.clientRequestId))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_parameter_task' }));
+    if (parameterTask.data) {
+        if (operation.directoryName === 'root')
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_directory' }));
+        if ((selection.data.workMode ?? 'execute') !== 'execute' || requestedMode === 'read-only')
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_task_readonly' }));
+        if (workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
+        if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'batch_workspace_readonly' }));
+    }
     const modelChanged = selected.data !== undefined && selected.data !== (found?.modelConfigId ?? recovery?.modelConfigId);
     const requestedEffort = effort.data ?? (modelChanged ? undefined : recovery?.reasoningEffort ?? found?.reasoningEffort);
     if (recovery && found?.recoverability !== 'native') {
@@ -392,49 +441,72 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'cli_credentials_unavailable' }));
         }
     }
+    let parameterInstructions = '';
+    if (parameterTask.data) {
+        try {
+            parameterInstructions = (await prepareParameterAgentTask(state, operation, parameterTask.data, root)).instructions;
+        }
+        catch (error) {
+            return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: parameterAgentError(error) }));
+        }
+    }
     // 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',
     });
-    const result = await native(state).startTurn({
-        sessionId,
-        threadId: binding.threadId,
-        text: composer.append(batchContext + context + String(body.text ?? '') + attachmentText, engineeringBatchContext),
-        images: attachments.filter((file) => ['image/png', 'image/jpeg', 'image/gif', 'image/webp'].includes(file.mimeType)).map((file) => file.path),
-        clientRequestId: operation.clientRequestId,
-        modelConfigId: selected.data ?? binding.modelConfigId,
-        reasoningEffort: requestedEffort,
-        permissionMode: requestedMode,
-        workMode: selection.data.workMode ?? 'execute',
-        skillsLockHash: composer.skillsLockHash,
-        uiSnapshot: uiSnapshot.data,
-        simulateLostReceipt: body.simulateLostReceipt === true,
-        persistReservation: async ({ nativeRequestId, modelConfigId, reasoningEffort, permissionMode }) => {
-            const selectedEffort = reasoningEffort ?? requestedEffort;
-            const selectedMode = permissionMode ?? requestedMode;
-            await persist(state, scopeKey, {
-                ...operation,
-                nativeRequestId,
-                nativeThreadId: binding.threadId,
-                modelConfigId,
-                reasoningEffort: selectedEffort,
-                permissionMode: selectedMode,
-                workMode: selection.data.workMode ?? 'execute',
-                context: composer.context,
-                userText: selection.data.workMode !== undefined || composer.context !== undefined
-                    ? String(body.userText ?? body.text ?? '') : undefined,
-                updatedAt: new Date().toISOString(),
-            });
-            await state.journal.putSession({ ...binding, modelConfigId, reasoningEffort: selectedEffort, permissionMode: selectedMode, turnStatus: 'starting' });
-        },
-    });
+    let result;
+    try {
+        result = await native(state).startTurn({
+            sessionId,
+            threadId: binding.threadId,
+            text: composer.append(batchContext + context + String(body.text ?? '') + attachmentText, [engineeringBatchContext, parameterInstructions].filter(Boolean).join('\n\n')),
+            images: attachments.filter((file) => ['image/png', 'image/jpeg', 'image/gif', 'image/webp'].includes(file.mimeType)).map((file) => file.path),
+            clientRequestId: operation.clientRequestId,
+            modelConfigId: selected.data ?? binding.modelConfigId,
+            reasoningEffort: requestedEffort,
+            permissionMode: requestedMode,
+            workMode: selection.data.workMode ?? 'execute',
+            skillsLockHash: composer.skillsLockHash,
+            uiSnapshot: uiSnapshot.data,
+            simulateLostReceipt: body.simulateLostReceipt === true,
+            persistReservation: async ({ nativeRequestId, modelConfigId, reasoningEffort, permissionMode }) => {
+                const selectedEffort = reasoningEffort ?? requestedEffort;
+                const selectedMode = permissionMode ?? requestedMode;
+                await persist(state, scopeKey, {
+                    ...operation,
+                    nativeRequestId,
+                    nativeThreadId: binding.threadId,
+                    modelConfigId,
+                    reasoningEffort: selectedEffort,
+                    permissionMode: selectedMode,
+                    workMode: selection.data.workMode ?? 'execute',
+                    context: composer.context,
+                    userText: selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data
+                        ? String(body.userText ?? body.text ?? '') : undefined,
+                    updatedAt: new Date().toISOString(),
+                });
+                await state.journal.putSession({ ...binding, modelConfigId, reasoningEffort: selectedEffort, permissionMode: selectedMode, turnStatus: 'starting' });
+            },
+        });
+    }
+    catch (error) {
+        if (!parameterTask.data)
+            throw error;
+        abandonTurnChanges(state, sessionId);
+        if (error instanceof NativePreparationError) {
+            await state.journal.putSession({ ...(state.journal.getSession(sessionId) ?? binding), turnStatus: undefined, turnBlock: undefined });
+            return persist(state, scopeKey, transitionOperation(state.journal.getOperation(scopeKey) ?? operation, 'failed', { error: error.message }));
+        }
+        await state.journal.putSession({ ...(state.journal.getSession(sessionId) ?? binding), turnStatus: 'starting', turnBlock: 'uncertain' });
+        return persist(state, scopeKey, transitionOperation(state.journal.getOperation(scopeKey) ?? operation, 'uncertain', { error: 'native_receipt_lost' }));
+    }
     const reserved = state.journal.getOperation(scopeKey) ?? operation;
     if (result.outcome === 'uncertain' || result.outcome === 'failed' || !result.turnId) {
         abandonTurnChanges(state, sessionId);
         const failed = result.outcome === 'failed';
         // Codex no longer knows the thread although the binding said it could continue. Marking the
         // binding lost lets the same turn, sent again with the conversation, rebind the session.
-        const threadLost = failed && result.error === 'unknown_thread';
+        const threadLost = result.outcome === 'failed' && result.error === 'unknown_thread';
         await state.journal.putSession({
             ...(state.journal.getSession(sessionId) ?? binding),
             turnStatus: failed ? undefined : 'starting',
@@ -480,7 +552,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         threadId: binding.threadId,
         turnId: result.turnId,
     });
-    if (selection.data.workMode !== undefined || composer.context !== undefined) {
+    if (selection.data.workMode !== undefined || composer.context !== undefined || parameterTask.data) {
         await recordNativeEvents(state, accepted, [{
                 type: 'composer.context', occurredAt: new Date().toISOString(), payload: {
                     threadId: binding.threadId, turnId: result.turnId, clientRequestId: operation.clientRequestId,
@@ -497,7 +569,56 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
         const session = state.journal.getSession(sessionId) ?? binding;
         await state.journal.putSession({ ...session, turnStatus: 'waiting_for_user', activeTurnId: result.turnId });
     }
-    return state.journal.getOperation(scopeKey) ?? latest;
+    const final = state.journal.getOperation(scopeKey) ?? latest;
+    await syncParameterAgentOperation(state, final);
+    return final;
+}
+async function executeParameterVerify(state, scopeKey, operation, payload) {
+    const parsed = parameterAgentVerifyPayloadSchema.safeParse(payload);
+    if (!parsed.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_parameter_task' }));
+    if (operation.directoryName === 'root' || (operation.sessionId && productionSessionAttemptId(operation.sessionId)))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_directory' }));
+    if (workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_already_active' }));
+    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 accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
+    const controller = new AbortController();
+    const assertActive = () => {
+        if (controller.signal.aborted || parameterVerificationClosing.has(state))
+            throw new Error('parameter_verification_interrupted');
+        if (state.journal.destroyed())
+            throw new Error('runtime_destroyed');
+        if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence)
+            throw new Error('stale_lease');
+    };
+    const key = `workspace:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`;
+    const task = state.journal.exclusive(key, async () => {
+        try {
+            assertActive();
+            if (workspaceSessions(state, operation.workspaceId, operation.directoryName).some(sessionTurnBusy))
+                throw new Error('turn_already_active');
+            if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
+                throw new Error('batch_workspace_readonly');
+            const result = await verifyParameterAgentTask(state, operation, parsed.data, root, { assertActive, signal: controller.signal });
+            assertActive();
+            await persist(state, scopeKey, transitionOperation(accepted, 'completed', { result }));
+        }
+        catch (error) {
+            await persist(state, scopeKey, transitionOperation(accepted, 'failed', { error: parameterAgentError(error) }));
+        }
+    });
+    const tasks = parameterVerifications.get(state) ?? new Map();
+    parameterVerifications.set(state, tasks);
+    const tracked = task.catch(() => undefined).finally(() => tasks.delete(controller));
+    tasks.set(controller, tracked);
+    return accepted;
+}
+function parameterAgentError(error) {
+    return error instanceof Error && /^(?:parameter_|invalid_parameter_|runtime_destroyed$|stale_lease$|turn_already_active$|batch_workspace_readonly$)/.test(error.message)
+        ? error.message : 'parameter_task_failed';
 }
 /**
  * Gives a session whose native thread was lost a thread in this process. It keeps its own thread
@@ -742,6 +863,7 @@ async function executeApproval(state, scopeKey, operation, payload) {
 }
 async function executeDestroy(state, scopeKey, operation) {
     await state.journal.markDestroyed();
+    await stopParameterVerifications(state);
     await closeCliCredentials(state);
     await state.gitCredentials?.destroy();
     disposeTerminalHost(state);
@@ -792,6 +914,50 @@ async function executeDirectoryCreate(state, scopeKey, operation, payload) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: code }));
     }
 }
+async function executeDirectoryMutation(state, scopeKey, operation, payload) {
+    const kind = operation.kind === 'directory.rename' ? 'directory.rename' : 'directory.delete';
+    const parsed = kind === 'directory.rename' ? directoryRenamePayloadSchema.safeParse(payload) : directoryDeletePayloadSchema.safeParse(payload);
+    if (!parsed.success)
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace_path' }));
+    let current = operation;
+    try {
+        const assertCurrent = async () => {
+            if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
+                throw new DirectoryMutationError('stale_lease');
+            if (operation.sessionId && productionSessionAttemptId(operation.sessionId))
+                throw new DirectoryMutationError('production_session_readonly');
+            if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
+                throw new DirectoryMutationError('batch_workspace_readonly');
+        };
+        await assertCurrent();
+        const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
+        const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
+        const options = { operationId: operation.operationId, operationPayloadHash: operation.payloadHash, scope: scopeKey, assertCurrent,
+            observeRevision: async () => (await observeWorkspaceDirectories(root, state.journal, scope)).directoryRevisions?.[parsed.data.path],
+            onDetached: async () => { if (current.status === 'dispatched')
+                current = await persist(state, scopeKey, transitionOperation(current, 'accepted')); } };
+        const receipt = await mutateWorkspaceDirectory(root, kind, parsed.data, options);
+        if (!receipt)
+            throw new DirectoryMutationError('directory_recovery_required');
+        await observeWorkspaceDirectories(root, state.journal, scope);
+        const paths = [receipt.path, ...(receipt.newPath ? [receipt.newPath] : [])];
+        const result = { paths, skippedPaths: [], failures: [], directoryMutation: directoryMutationReceiptSchema.parse(receipt) };
+        if (current.status === 'dispatched')
+            current = await persist(state, scopeKey, transitionOperation(current, 'accepted', { result }));
+        await recordNativeEvents(state, current, [{ type: 'files.changed', occurredAt: new Date().toISOString(), payload: {
+                    workspaceId: operation.workspaceId, directoryName: operation.directoryName ?? 'basic', paths,
+                    source: kind, operationId: operation.operationId, revision: receipt.revision,
+                } }]);
+        return persist(state, scopeKey, transitionOperation(current, 'completed', { result }));
+    }
+    catch (error) {
+        const code = error instanceof DirectoryMutationError ? error.code
+            : error instanceof InvalidWorkspacePathError || error?.code === 'invalid_workspace_path' ? 'invalid_workspace_path'
+                : ['EACCES', 'EPERM'].includes(String(error?.code)) ? 'workspace_permission_denied'
+                    : 'directory_recovery_required';
+        return persist(state, scopeKey, transitionOperation(current, code === 'directory_recovery_required' ? 'uncertain' : 'failed', { error: code }));
+    }
+}
 async function executeAssetLibraryImport(state, scopeKey, operation, payload) {
     const input = payload;
     try {
@@ -833,6 +999,63 @@ async function executeAssetLibraryImport(state, scopeKey, operation, payload) {
         }));
     }
 }
+async function executeAssetBundleSave(state, scopeKey, operation, payload) {
+    const directoryName = operation.directoryName ?? 'basic';
+    const scope = revisionScope(state, operation.workspaceId, directoryName);
+    const revisions = new Map();
+    const metadata = new Map();
+    try {
+        const assertCurrent = async () => {
+            if (state.journal.destroyed() || (operation.leaseFence ?? 0) < state.acceptedLeaseFence)
+                throw new AssetTransferError(state.journal.destroyed() ? 'runtime_destroyed' : 'stale_lease');
+            if (directoryName === 'root' || operation.sessionId && productionSessionAttemptId(operation.sessionId))
+                throw new AssetTransferError('production_session_readonly');
+            if (await batchDirectoryHeld(state, operation.workspaceId, directoryName))
+                throw new AssetTransferError('batch_workspace_readonly');
+        };
+        await assertCurrent();
+        const root = await workspaceRoot(state, operation.workspaceId, directoryName);
+        const receipt = await publishAssetTransfer(root, { environment: state.config.environment, userId: state.config.userId,
+            workspaceId: operation.workspaceId ?? '', directoryName }, payload, { operationId: operation.operationId, assertCurrent,
+            onManifest: manifest => { for (const file of manifest.files)
+                metadata.set(file.path, file); },
+            assertRevision: async (file, observed) => {
+                const previous = state.journal.fileRevisions(scope)[file.path];
+                const hash = observed?.contentHash ?? '';
+                const revision = previous ? previous.revision + (previous.contentHash === hash ? 0 : 1) : 0;
+                if (previous && previous.contentHash !== hash || !previous && observed)
+                    await state.journal.putFileRevision(file.path, { revision, contentHash: hash }, scope);
+                if (file.expectedRevision !== undefined && file.expectedRevision !== revision)
+                    throw new AssetTransferError('revision_conflict');
+                revisions.set(file.path, revision + 1);
+            } });
+        await assertCurrent();
+        const paths = [...receipt.files.map(file => file.path), ...(receipt.directories ?? [])];
+        const result = { paths, skippedPaths: [], failures: [], bundleReceipt: receipt };
+        const events = [];
+        for (const file of receipt.files) {
+            const previous = state.journal.fileRevisions(scope)[file.path];
+            const revision = revisions.get(file.path) ?? (previous ? previous.revision + (previous.contentHash === file.contentHash ? 0 : 1) : 1);
+            await state.journal.putFileRevision(file.path, { revision, contentHash: file.contentHash }, scope);
+            events.push({ type: 'file.written', payload: { ...file, revision, writer: 'manual', workspaceId: operation.workspaceId,
+                    directoryName, operationId: operation.operationId, transferId: receipt.transferId,
+                    ...(metadata.get(file.path)?.processing ? { processing: metadata.get(file.path).processing } : {}) }, occurredAt: new Date().toISOString() });
+        }
+        events.push({ type: 'files.changed', payload: { workspaceId: operation.workspaceId, directoryName,
+                operationId: operation.operationId, paths, source: 'asset.bundle.save' }, occurredAt: new Date().toISOString() });
+        const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { result }));
+        await recordNativeEvents(state, accepted, events);
+        if (operation.workspaceId && directoryName === 'basic')
+            await refreshWorkspaceArtifacts(state, operation.workspaceId, { paths, source: { kind: 'discovered', tool: 'asset.bundle.save', operationId: operation.operationId } }).catch(() => undefined);
+        return persist(state, scopeKey, transitionOperation(accepted, 'completed', { result }));
+    }
+    catch (error) {
+        const code = error instanceof AssetTransferError ? error.code
+            : error.name === 'ZodError' ? 'invalid_asset_transfer'
+                : ['EACCES', 'EPERM'].includes(String(error.code)) ? 'workspace_permission_denied' : 'asset_bundle_save_failed';
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: code }));
+    }
+}
 async function executeFileBinaryWrite(state, scopeKey, operation, payload) {
     const parsed = fileBinaryWritePayloadSchema.safeParse(payload);
     if (!parsed.success)
@@ -1118,19 +1341,19 @@ async function executeParameterPatch(state, scopeKey, operation, payload) {
     const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
     const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
     const document = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
-    if (document.status === 'missing' || document.status === 'schema_only' || !document.dataPath) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_data_missing' }));
-    }
     if (document.status === 'invalid') {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'parameter_document_invalid' }));
     }
+    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;
-    return withObservedFile(state, operation.workspaceId, dataPath, async ({ revision: currentRevision }) => {
+    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' }));
         }
         try {
-            const written = await patchWorkspaceParameters(root, state.journal.fileRevisions(scope), parsed.data);
+            const written = await patchWorkspaceParameters(root, state.journal.fileRevisions(scope), parsed.data, { dataPath, contentHash: file?.contentHash ?? '' });
             const revision = currentRevision + 1;
             await state.journal.putFileRevision(dataPath, { revision, contentHash: written.contentHash }, scope);
             const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted', { expectedRevision: revision }));
@@ -1142,7 +1365,9 @@ async function executeParameterPatch(state, scopeKey, operation, payload) {
                         revision,
                         contentHash: written.contentHash,
                         size: written.size,
-                        fieldPath: parsed.data.fieldPath,
+                        ...('changes' in parsed.data
+                            ? { fieldPaths: parsed.data.changes.map((change) => change.fieldPath) }
+                            : { fieldPath: parsed.data.fieldPath }),
                     },
                     occurredAt: new Date().toISOString(),
                 },
@@ -1325,6 +1550,11 @@ export async function ingestCollected(state, event, publish = true) {
         itemId: ids.itemId,
         occurredAt: event.occurredAt,
     });
+    if (ids.turnId && ids.threadId) {
+        const operation = state.journal.listOperations().map(item => item.operation).find(item => item.kind === 'session.turn' && item.nativeThreadId === ids.threadId && item.nativeTurnId === ids.turnId);
+        if (operation)
+            await syncParameterAgentOperation(state, operation);
+    }
     if (publish && recorded.length > 0)
         await publishSourceEvents(state, recorded);
     return recorded;
@@ -1374,7 +1604,16 @@ function nativeIds(params) {
     };
 }
 async function persist(state, scopeKey, operation) {
-    return state.journal.putOperation(scopeKey, operation);
+    const saved = await state.journal.putOperation(scopeKey, operation);
+    await syncParameterAgentOperation(state, saved);
+    return saved;
+}
+async function syncParameterAgentOperation(state, operation) {
+    if (operation.kind !== 'session.turn')
+        return;
+    if (operation.status === 'completed' || operation.status === 'failed' || operation.status === 'interrupted' || operation.status === 'uncertain') {
+        await finishParameterAgentTask(state, operation, operation.status, operation.error);
+    }
 }
 function native(state) {
     if (!state.native)

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

@@ -1,4 +1,5 @@
 import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
+import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
 import { registerWorkspace, revisionScope, sessionWorkspaceRoot, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
 import { constants } from 'node:fs';
 import { access as accessDirectory, stat } from 'node:fs/promises';
@@ -6,9 +7,10 @@ import { workspaceRegistrationRequestSchema, workspaceFileSearchQuerySchema, HTT
 import { controlTokenMatches, extractControlToken } from './auth.js';
 import { applyRuntimeEndpointPatch } from './endpoints.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
-import { InvalidWorkspacePathError, listWorkspaceFiles, } from '../workspaces/files.js';
+import { InvalidWorkspacePathError, } from '../workspaces/files.js';
 import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitFile, readWorkspaceGitGraph, readWorkspaceGitStatus, } from '../workspaces/git.js';
 import { readWorkspaceParameters } from '../workspaces/parameters.js';
+import { listParameterAgentTasks } from '../workspaces/parameter-agent.js';
 import { readDependencies } from '../workspaces/dependencies.js';
 import { desktopHost, desktopRoute } from './desktop-host.js';
 import { ensureCliCredentials } from '../workspaces/cli-credentials.js';
@@ -40,6 +42,7 @@ import { serveWorkspaceArchive } from '../workspaces/archive.js';
 import { handleWorkspaceTransfer } from './workspace-transfer.js';
 import { serveSessionImage } from '../workspaces/session-image.js';
 import { restoreNativeSession, SessionRestoreError } from './session-restore.js';
+import { handleAssetTransferRequest } from './asset-transfers.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const directoryName = url.searchParams.get('directoryName') ?? 'basic';
@@ -53,6 +56,11 @@ export async function handleRuntimeRequest(state, request, response) {
         return;
     }
     try {
+        const transfer = await handleAssetTransferRequest(state, request, url);
+        if (transfer) {
+            writeJson(response, transfer.status, transfer.body);
+            return;
+        }
         const batch = await dispatchBatchRoute(state, request, url);
         if (batch) {
             writeJson(response, batch.status, batch.body);
@@ -94,6 +102,7 @@ export async function handleRuntimeRequest(state, request, response) {
                 instanceToken: state.instanceToken,
                 permissionsVersion: 1,
                 composerContextVersion: 1,
+                parameterAgentVersion: 1,
                 remixReferencesVersion: 1,
                 batchSourceFreezeRevision: 2,
                 ...(state.native?.workspaceUi ? { workspaceUiVersion: 1 } : {}),
@@ -505,7 +514,8 @@ export async function handleRuntimeRequest(state, request, response) {
                 return;
             const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
             const root = await workspaceRoot(state, workspaceId, directoryName);
-            const listed = await listWorkspaceFiles(root, state.journal.fileRevisions(revisionScope(state, workspaceId, directoryName)));
+            const scope = revisionScope(state, workspaceId, directoryName);
+            const listed = await state.journal.exclusive(`workspace:${scope ?? 'single'}`, () => observeWorkspaceDirectories(root, state.journal, scope));
             console.log(`[workspace-files] GET /runtime/files workspaceId=${workspaceId ?? '-'} root=${root} files=${listed.files.length}`);
             writeJson(response, 200, listed);
             return;
@@ -639,6 +649,18 @@ export async function handleRuntimeRequest(state, request, response) {
             writeJson(response, 200, await readObservedParameters(state, url.searchParams.get('workspaceId') ?? undefined, directoryName));
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/parameter-tasks') {
+            if (writeDestroyed(state, response))
+                return;
+            if (directoryName === 'root') {
+                writeJson(response, 400, { error: 'invalid_workspace_directory' });
+                return;
+            }
+            const workspaceId = url.searchParams.get('workspaceId') ?? undefined;
+            const root = await workspaceRoot(state, workspaceId, directoryName);
+            writeJson(response, 200, { tasks: await listParameterAgentTasks(state, workspaceId, directoryName, root) });
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/terminals') {
             if (writeDestroyed(state, response))
                 return;
@@ -1105,12 +1127,14 @@ async function handleSessionHistory(state, response, workspaceId, sessionId) {
 async function readObservedParameters(state, workspaceId, directoryName = 'basic') {
     const root = await workspaceRoot(state, workspaceId, directoryName);
     const scope = revisionScope(state, workspaceId, directoryName);
-    const first = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
-    for (const path of [first.schemaPath, first.dataPath]) {
-        if (path)
-            await withObservedFile(state, workspaceId, path, async () => undefined, directoryName);
-    }
-    return readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    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]) {
+            if (path)
+                await withObservedFile(state, workspaceId, path, async () => undefined, directoryName);
+        }
+        return readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    });
 }
 function writeError(response, error) {
     writeJson(response, HTTP_STATUS_BY_ERROR[error.code], error);