@playcraft/cli 0.1.57-beta → 0.1.59-beta

package/dist/workspace-runtime/persistence/journal.js

@@ -11,6 +11,7 @@ export class RuntimeJournal {
     legacyPath;
     client;
     listeners = new Set();
+    changeListeners = new Set();
     maintenance;
     engineInfo;
     epochs = [];
@@ -40,11 +41,13 @@ export class RuntimeJournal {
         }
     }
     async load() {
+        // private
         await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
         const legacy = await readLegacy(this.legacyPath, this.filePath);
         const started = await SqliteWorkerClient.open(this.filePath, legacy?.value ?? null);
         this.client = started.client;
         this.apply(started.opened);
+        // private
         if (legacy?.readable)
             await writeFile(this.legacyPath, LEGACY_JOURNAL_SENTINEL, { mode: 0o600 });
         this.maintenance = setInterval(() => {
@@ -76,6 +79,33 @@ export class RuntimeJournal {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
     }
+    onChange(listener) {
+        this.changeListeners.add(listener);
+        return () => this.changeListeners.delete(listener);
+    }
+    directoryBarriers() { return Object.values(this.snapshot.directoryBarriers); }
+    async putDirectoryBarrier(barrier) {
+        await this.run('upsertRecord', { bucket: 'directory_barriers', key: barrier.owner,
+            body: { ...barrier, queuedAt: this.snapshot.directoryBarriers[barrier.owner]?.queuedAt ?? barrier.queuedAt ?? new Date().toISOString() } });
+    }
+    async deleteDirectoryBarrier(owner) {
+        await this.run('deleteRecord', { bucket: 'directory_barriers', key: owner });
+    }
+    deferredDirectoryOperations() { return Object.values(this.snapshot.deferredDirectoryOperations); }
+    async deferDirectoryOperation(input) {
+        await this.run('upsertRecord', { bucket: 'directory_deferred_operations', key: input.operationId,
+            body: { ...input, queuedAt: this.snapshot.deferredDirectoryOperations[input.operationId]?.queuedAt ?? input.queuedAt ?? new Date().toISOString() } });
+    }
+    /** The accepted command and its replayable input commit together before any writer can start. */
+    async putPendingOperation(scopeKey, operation, payload, recovery) {
+        const parsed = operationRecordSchema.parse(operation);
+        await this.run('putPendingOperation', { scopeKey, operation: parsed,
+            pending: { operationId: parsed.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}), queuedAt: parsed.createdAt } });
+        return this.snapshot.operations[scopeKey];
+    }
+    async deleteDeferredDirectoryOperation(operationId) {
+        await this.run('deleteRecord', { bucket: 'directory_deferred_operations', key: operationId });
+    }
     getWorkspace(workspaceId) {
         return this.snapshot.workspaces[workspaceId];
     }
@@ -288,6 +318,8 @@ export class RuntimeJournal {
             throw new Error('sqlite_not_open');
         const result = await this.client.request(type, payload);
         this.apply(result);
+        for (const listener of this.changeListeners)
+            listener();
         for (const event of result.committedEvents ?? []) {
             for (const listener of this.listeners)
                 listener(event);
@@ -356,6 +388,8 @@ function emptySnapshot() {
         fileRevisions: {},
         approvals: {},
         managedWrites: {},
+        directoryBarriers: {},
+        deferredDirectoryOperations: {},
         workspaceDependencies: {},
         executionGroup: { stopConfirmed: false, replaced: false },
         lastSourceSequence: 0,

package/dist/workspace-runtime/persistence/sqlite-worker.js

@@ -64,6 +64,15 @@ function dispatch(type, payload) {
             case 'putOperation':
                 putOperation(database, String(body.scopeKey), body.operation);
                 return;
+            case 'putPendingOperation': {
+                const operation = operationRecordSchema.parse(body.operation);
+                const pending = asRecord(body.pending);
+                if (operation.status !== 'queued' || pending.operationId !== operation.operationId || pending.scopeKey !== body.scopeKey)
+                    throw new Error('invalid_pending_operation');
+                putOperation(database, String(body.scopeKey), operation);
+                upsertRecord(database, 'directory_deferred_operations', operation.operationId, pending);
+                return;
+            }
             case 'setAcceptedFence':
                 setMeta(database, 'accepted_lease_fence', String(Math.max(metaNumber(database, 'accepted_lease_fence'), Number(body.value) || 0)));
                 return;
@@ -158,6 +167,8 @@ function openDatabase(payload) {
       ON native_inbox(thread_id, ingress_sequence) WHERE converted = 0;
     CREATE INDEX IF NOT EXISTS records_native_session_thread
       ON records(json_extract(body_json, '$.threadId')) WHERE bucket = 'sessions';
+    CREATE INDEX IF NOT EXISTS operation_intents_sandbox_operation
+      ON operation_intents(sandbox_operation_id);
     CREATE INDEX IF NOT EXISTS native_inbox_pending_parent
       ON native_inbox(COALESCE(json_extract(payload_json, '$.thread.parentThreadId'),
         json_extract(payload_json, '$.thread.source.subAgent.thread_spawn.parent_thread_id')))
@@ -353,7 +364,7 @@ function allocateEvent(database, body) {
        WHERE runtime_id = ? AND generation = ? AND runtime_epoch = ?
        RETURNING next_sequence`)
         .get(runtimeId, generation, runtimeEpoch);
-    const payload = body.payload ?? {};
+    const payload = operationEventPayload(database, body);
     const event = pendingSourceEventSchema.parse({
         source: { runtimeId, generation, runtimeEpoch, sourceSequence: allocated.next_sequence },
         payloadHash: hashOperationPayload(payload),
@@ -832,6 +843,8 @@ function dump(database, includeEvents = true) {
         fileRevisions: bucketObject(database, 'file_revisions'),
         approvals: bucketObject(database, 'approvals'),
         managedWrites: bucketObject(database, 'managed_writes'),
+        directoryBarriers: bucketObject(database, 'directory_barriers'),
+        deferredDirectoryOperations: bucketObject(database, 'directory_deferred_operations'),
         workspaceDependencies: bucketObject(database, 'workspace_dependencies'),
         executionGroup: executionGroup(database),
         stoppedRuntimeEpochs: stoppedExecutionEpochs(database, metaString(database, 'runtime_id'), metaNumber(database, 'generation')),
@@ -878,7 +891,16 @@ function operationsObject(database) {
     return operations;
 }
 function putOperation(database, scopeKey, value) {
-    const operation = operationRecordSchema.parse(value);
+    let operation = operationRecordSchema.parse(value);
+    if (operation.status !== 'queued')
+        database.prepare("DELETE FROM records WHERE bucket = 'directory_deferred_operations' AND record_key = ?").run(operation.operationId);
+    const existing = database.prepare('SELECT gateway_operation_id FROM operation_intents WHERE scope_key = ?')
+        .get(scopeKey);
+    if (existing?.gateway_operation_id) {
+        if (operation.gatewayOperationId && operation.gatewayOperationId !== existing.gateway_operation_id)
+            throw new Error('gateway_operation_mismatch');
+        operation = { ...operation, gatewayOperationId: existing.gateway_operation_id };
+    }
     if (metaString(database, 'runtime_id') && operation.generation === metaNumber(database, 'generation') && operation.runtimeEpoch === metaNumber(database, 'runtime_epoch')) {
         const key = JSON.stringify([scopeKey, operation.operationId]);
         database.prepare("INSERT INTO records (bucket, record_key, body_json) VALUES ('operation_execution_scopes', ?, ?) ON CONFLICT DO NOTHING")
@@ -898,7 +920,7 @@ function putOperation(database, scopeKey, value) {
         thread_id = excluded.thread_id,
         turn_id = excluded.turn_id,
         reconcile_status = excluded.reconcile_status`)
-        .run(scopeKey, JSON.stringify(operation), null, operation.sandboxOperationId ?? operation.operationId, operation.payloadHash, operation.nativeRequestId ?? null, operation.nativeThreadId ?? null, operation.nativeTurnId ?? null, operation.status);
+        .run(scopeKey, JSON.stringify(operation), operation.gatewayOperationId ?? null, operation.sandboxOperationId ?? operation.operationId, operation.payloadHash, operation.nativeRequestId ?? null, operation.nativeThreadId ?? null, operation.nativeTurnId ?? null, operation.status);
 }
 function insertEventRow(database, event, links) {
     database
@@ -1017,17 +1039,57 @@ function operationByTurn(database, turnId, threadId) {
 }
 function linkedPayload(params, session, subAgent) {
     const payload = { ...asRecord(params) };
-    delete payload.workspaceId;
-    delete payload.sessionId;
-    delete payload.subAgent;
+    // Native notifications cannot assert the platform identity or override durable ownership.
+    for (const key of ['operationId', 'gatewayOperationId', 'platformOperationId', 'sandboxOperationId',
+        'workspaceId', 'sessionId', 'directoryName', 'runtimeId', 'generation', 'runtimeEpoch', 'userId', 'environment', 'execution', 'subAgent',
+        'directoryAccessMode', 'dispatchAttempted'])
+        delete payload[key];
     if (typeof session?.workspaceId === 'string')
         payload.workspaceId = session.workspaceId;
     if (typeof session?.sessionId === 'string')
         payload.sessionId = session.sessionId;
+    if (session)
+        payload.directoryName = optionalString(session.directoryName) ?? 'basic';
     if (subAgent)
         payload.subAgent = subAgent;
     return payload;
 }
+/** Identity enters the immutable event body before hashing, including synthetic stop events. */
+function operationEventPayload(database, body) {
+    const operationId = optionalString(body.operationId);
+    if (!operationId)
+        return body.payload ?? {};
+    const row = database.prepare('SELECT operation_json FROM operation_intents WHERE sandbox_operation_id = ? LIMIT 1')
+        .get(operationId);
+    if (!row)
+        return body.payload ?? {};
+    const operation = operationRecordSchema.parse(JSON.parse(row.operation_json));
+    if ((operation.generation !== undefined && operation.generation !== Number(body.generation)) ||
+        (operation.runtimeEpoch !== undefined && operation.runtimeEpoch !== Number(body.runtimeEpoch)))
+        return body.payload ?? {};
+    const payload = { ...asRecord(body.payload) };
+    delete payload.gatewayOperationId;
+    delete payload.platformOperationId;
+    payload.operationId = operation.gatewayOperationId ?? operation.operationId;
+    payload.sandboxOperationId = operation.operationId;
+    if (operation.gatewayOperationId)
+        payload.gatewayOperationId = operation.gatewayOperationId;
+    if (operation.workspaceId)
+        payload.workspaceId = operation.workspaceId;
+    if (operation.sessionId)
+        payload.sessionId = operation.sessionId;
+    payload.directoryName = operation.directoryName ?? 'basic';
+    const subAgent = asRecord(payload.subAgent);
+    const threadId = optionalString(body.threadId) ?? nativeIds(payload).threadId ??
+        (Object.keys(subAgent).length ? undefined : operation.nativeThreadId);
+    const turnId = optionalString(body.turnId) ?? nativeIds(payload).turnId ??
+        (Object.keys(subAgent).length ? undefined : operation.nativeTurnId);
+    if (threadId)
+        payload.threadId = threadId;
+    if (turnId)
+        payload.turnId = turnId;
+    return payload;
+}
 function nativeIds(params) {
     const record = asRecord(params);
     const turn = asRecord(record.turn);

package/dist/workspace-runtime/previews/output.js

@@ -8,6 +8,7 @@ export async function saveWorkspacePlayableOutput(root, bytes) {
     let directory = workspace;
     for (const segment of dirname(WORKSPACE_PLAYABLE_OUTPUT_PATH).split('/')) {
         directory = join(directory, segment);
+        // shared
         const created = await mkdir(directory, { mode: 0o2775 }).then(() => true, error => {
             if (error.code !== 'EEXIST')
                 throw error;
@@ -22,6 +23,7 @@ export async function saveWorkspacePlayableOutput(root, bytes) {
     const target = join(workspace, WORKSPACE_PLAYABLE_OUTPUT_PATH);
     const temporary = join(directory, `.playable-${randomUUID()}.tmp`);
     try {
+        // shared
         await writeFile(temporary, bytes, { flag: 'wx', mode: 0o664 });
         await chmod(temporary, 0o664);
         const stat = await lstat(target).catch(error => { if (error.code === 'ENOENT')

package/dist/workspace-runtime/previews/publish.js

@@ -17,6 +17,7 @@ import { openScratchToDevelopment } from '../workspaces/directory-access.js';
 import { injectPreviewDiagnostics } from './diagnostics.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
 import { prepareRuntimePreview, RuntimePreviewBuildError } from './runtime-preview.js';
+import { driftScope, permissionDriftFromOutput, repairWorkspaceShares, } from '../workspaces/workspace-shares.js';
 const BUILD_TIMEOUT_MS = 10 * 60_000;
 /** Build output and the builder's own scratch folder live in the checkout, hidden from Git. */
 const OUTPUT_FOLDER = '.playcraft-preview-out';
@@ -60,12 +61,12 @@ export function trackPreviewPublish(state, task) {
 export async function settlePreviewPublishes(state) {
     await Promise.all([...(running.get(state) ?? [])]);
 }
-/** A publish cut off by a restart has no build left running; it is closed rather than left accepted. */
+/** Restart alone does not prove the old builder stopped; retain its exclusive directory claim. */
 export async function recoverInterruptedPreviews(journal) {
     for (const { scopeKey, operation } of journal.listOperations()) {
         if (operation.kind !== 'preview.publish' || operation.status !== 'accepted')
             continue;
-        await journal.putOperation(scopeKey, transitionOperation(operation, 'interrupted', { error: 'preview_interrupted' }));
+        await journal.putOperation(scopeKey, transitionOperation(operation, 'uncertain', { error: 'preview_interrupted' }));
     }
 }
 export async function runPreviewPublish(state, operation, root) {
@@ -215,7 +216,7 @@ async function ensureDependencies(state, workspaceId, root, output) {
 async function buildPreview(state, root, outputDir, operationId, output, onLog, runtimeCommand) {
     // Tests replace the build; the real one needs a project and the published CLI.
     const planned = process.env.PLAYCRAFT_PREVIEW_BUILD_COMMAND || BUILD_COMMAND;
-    const outcome = await runDeveloperCommand(state, {
+    const run = () => runDeveloperCommand(state, {
         processId: `preview-${operationId}`,
         cwd: root,
         command: runtimeCommand ?? `${planned} --output ${shellQuote(outputDir)} .`,
@@ -226,8 +227,22 @@ async function buildPreview(state, root, outputDir, operationId, output, onLog,
             onLog?.(text);
         },
     });
-    if (outcome.code !== 0)
-        throw new PreviewFailure('preview_build_failed');
+    let outcome = await run();
+    if (outcome.code === undefined)
+        throw new PreviewFailure('preview_process_unknown');
+    if (outcome.code !== 0) {
+        // The build runs as the development identity; a directory only that identity can repair makes
+        // it fail on its own cwd. Repair the shared subtree as its owner and retry exactly once.
+        const drift = permissionDriftFromOutput(output.log);
+        if (drift) {
+            await repairWorkspaceShares(state, root, await driftScope(root, drift.path)).catch(() => undefined);
+            outcome = await run();
+            if (outcome.code === undefined)
+                throw new PreviewFailure('preview_process_unknown');
+        }
+        if (outcome.code !== 0)
+            throw new PreviewFailure(drift ? 'workspace_permission_drift' : 'preview_build_failed');
+    }
 }
 /** Reads the one HTML file without following links, so the uploaded bytes are what was checked. */
 async function readSingleHtml(outputDir) {

package/dist/workspace-runtime/previews/runtime-preview.js

@@ -166,6 +166,8 @@ export async function prepareRuntimePreview(state, operation, root) {
             dataRevision: before.dataRevision ?? 0,
             schemaRevision: before.schemaRevision ?? 0,
             dataHash: before.dataHash,
+            ...(before.runtimeI18n ? { runtimeI18nRevision: before.runtimeI18n.themeRevision,
+                ...(before.runtimeI18n.themeHash ? { runtimeI18nHash: before.runtimeI18n.themeHash } : {}) } : {}),
         },
     };
     const context = { buildId, ...profileBase };
@@ -187,6 +189,8 @@ export async function prepareRuntimePreview(state, operation, root) {
                 after.schemaHash !== before.schemaHash ||
                 after.dataRevision !== before.dataRevision ||
                 after.schemaRevision !== before.schemaRevision ||
+                after.runtimeI18n?.themeHash !== before.runtimeI18n?.themeHash ||
+                after.runtimeI18n?.themeRevision !== before.runtimeI18n?.themeRevision ||
                 digest(await insideFile(root, manifestPath)) !== digest(manifest))
                 throw new RuntimePreviewBuildError('runtime_preview_source_changed');
             for (const [path, hash] of gameHashes) {

package/dist/workspace-runtime/processes/managed-writes.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
+import { holdDirectoryAccess, managedDirectoryScope } from '../server/directory-access.js';
 export const MANAGED_WRITE_SOURCES = ['manual', 'agent', 'background'];
 const BACKGROUND_WRITER = `
 const fs = require('node:fs');
@@ -23,16 +24,48 @@ export function probeProcess(pid) {
         return undefined;
     }
 }
-export function spawnBackgroundWriter(absolutePath) {
+export function spawnBackgroundWriter(absolutePath, stopped) {
     const child = spawn(process.execPath, ['-e', BACKGROUND_WRITER, absolutePath], {
         detached: true,
         stdio: 'ignore',
     });
     child.unref();
+    child.once('error', () => undefined);
+    child.once('exit', () => stopped?.());
     if (!child.pid)
         throw new Error('background_write_failed');
     return child.pid;
 }
+/** A writer keeps its directory claim after the request that created it has finished. */
+export async function startManagedBackgroundWriter(state, record, absolutePath) {
+    if (state.journal.listManagedWrites().some(item => item.writeId === record.writeId && !item.stoppedAt))
+        throw new Error('write_already_active');
+    const release = await holdDirectoryAccess(state, managedDirectoryScope(state, record.workspaceId), `managed:${record.writeId}`, 'shared');
+    let pid;
+    let persisted = Promise.resolve();
+    const finish = async () => {
+        await persisted;
+        const current = state.journal.listManagedWrites().find(item => item.writeId === record.writeId);
+        if (current && current.startedAt === record.startedAt && !current.stoppedAt) {
+            await state.journal.putManagedWrite({ ...current, stoppedAt: new Date().toISOString() });
+        }
+        release();
+    };
+    try {
+        await state.journal.putManagedWrite(record);
+        pid = spawnBackgroundWriter(absolutePath, () => { void finish().catch(() => undefined); });
+        persisted = state.journal.putManagedWrite({ ...record, pid });
+        await persisted;
+        return pid;
+    }
+    catch (error) {
+        if (pid === undefined || await stopBackgroundWriter(pid)) {
+            persisted = Promise.resolve();
+            await finish();
+        }
+        throw error;
+    }
+}
 export async function stopBackgroundWriter(pid) {
     signal(pid, 'SIGTERM');
     if (await waitUntilStopped(pid, 2_000))
@@ -58,12 +91,21 @@ function signal(pid, name) {
 async function waitUntilStopped(pid, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const alive = probeProcess(pid);
+        const alive = probeProcessGroup(pid);
         if (alive === false)
             return true;
-        if (alive === undefined)
-            return false;
         await delay(50);
     }
-    return probeProcess(pid) === false;
+    return probeProcessGroup(pid) === false;
+}
+function probeProcessGroup(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH')
+            return undefined;
+        return probeProcess(pid);
+    }
 }

package/dist/workspace-runtime/serve.js

@@ -8,10 +8,11 @@ import { createCodexAppServerAdapter } from './codex/app-server.js';
 import { trustedMemberPolicy } from './batch/policy.js';
 import { batchDirectoryHeld } from './batch/occupancy.js';
 import { createLoopbackNativeAdapter } from './codex/loopback.js';
-import { attachNativeCollector, recoverInterruptedParameterVerifications, stopParameterVerifications } from './server/dispatch.js';
+import { attachNativeCollector, executeOperation, recoverInterruptedParameterVerifications, stopParameterVerifications } from './server/dispatch.js';
+import { restoreDeferredDirectoryOperations } from './server/directory-access.js';
 import { handleRuntimeRequest } from './server/http.js';
 import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
-import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
+import { disposeTerminalHost, retireStoppedTerminals, terminalHost } from './server/terminal-host.js';
 import { handleExecutionGroupCrash } from './server/execution-group.js';
 import { RuntimeProcessLock } from './server/lock.js';
 import { probeGitBinary } from './workspaces/git.js';
@@ -57,7 +58,9 @@ export async function startWorkspaceRuntime(config, options = {}) {
         await recoverInterruptedPreviews(journal);
         await recoverInterruptedParameterVerifications(journal);
         await recoverInterruptedDeliveries(config.stateDir);
-        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
+        await retireStoppedTerminals(journal, config.runtimeEpoch, previousEpoch);
+        // shared: in multi-workspace mode this is /workspaces, the container both identities traverse.
+        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o2770 });
         const state = runtimeState = {
             config: { ...config, protocolMinor: negotiated.protocolMinor },
             configPath: options.configPath,
@@ -99,6 +102,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         for (const { scopeKey, operation } of journal.listOperations()) {
             if (operation.kind !== 'asset.library.import' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                continue;
             const published = recoveredImports.get(operation.operationId);
             const result = operation.result && 'paths' in operation.result ? { ...operation.result,
                 paths: [...new Set([...operation.result.paths, ...(published?.paths ?? [])])],
@@ -150,6 +155,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         for (const { scopeKey, operation } of journal.listOperations()) {
             if (operation.kind !== 'asset.bundle.save' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                continue;
             const recovered = recoveredBundles.get(operation.operationId), receipt = recovered?.receipt;
             let next = operation;
             if (receipt) {
@@ -181,6 +188,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
             if (!['directory.rename', 'directory.delete'].includes(operation.kind)
                 || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                continue;
             const kind = operation.kind;
             let next = operation;
             try {
@@ -272,6 +281,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             state.nativeError = code === 'codex_model_catalog_unavailable' ? code : 'codex_start_failed';
             console.error(`[workspace-runtime] ${state.nativeError}`);
         }
+        await restoreDeferredDirectoryOperations(state, (scopeKey, operation, payload, recovery) => executeOperation(state, scopeKey, operation, payload, recovery));
         const server = createServer((request, response) => {
             void handleRuntimeRequest(state, request, response);
         });

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

@@ -1,4 +1,4 @@
-import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
+import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, } from '@playcraft/common/cloud-workspace/runtime';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { buildOperationRecord } from './operation-record.js';
 /**
@@ -29,6 +29,18 @@ export async function acceptOperationCore(state, parsed, options) {
                 operationId: decision.operation.operationId,
             }));
         }
+        if (decision.action === 'reuse' && parsed.gatewayOperationId) {
+            if (decision.operation.gatewayOperationId && decision.operation.gatewayOperationId !== parsed.gatewayOperationId) {
+                return rejected(409, runtimeError('idempotency_conflict', 'gateway_operation_mismatch', {
+                    operationId: decision.operation.operationId,
+                }));
+            }
+            if (!decision.operation.gatewayOperationId) {
+                decision.operation = await state.journal.putOperation(scopeKey, {
+                    ...decision.operation, gatewayOperationId: parsed.gatewayOperationId,
+                });
+            }
+        }
         const retryWithRecovery = decision.action === 'reuse' && parsed.kind === 'session.turn'
             && Boolean(parsed.sessionRecovery) && decision.operation.status === 'failed'
             && isLostThreadError(decision.operation.error);
@@ -38,6 +50,12 @@ export async function acceptOperationCore(state, parsed, options) {
                     operationId: decision.operation.operationId,
                 }));
             }
+            if (decision.operation.status === 'queued' && takesWorkspaceDirectory(decision.operation.kind) &&
+                !isTurnControl(decision.operation.kind) && !state.journal.deferredDirectoryOperations().some(item => item.operationId === decision.operation.operationId)) {
+                const queued = await state.journal.putPendingOperation(scopeKey, decision.operation, options.executionPayload, parsed.sessionRecovery);
+                const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
+                return { rejected: false, operation: executed, executed, reused: true };
+            }
             return { rejected: false, operation: decision.operation, executed: decision.operation, reused: true };
         }
         const validation = await options.validate?.(scopeKey);
@@ -51,7 +69,9 @@ export async function acceptOperationCore(state, parsed, options) {
         }
         state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, options.leaseFence);
         await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
-        const queued = await state.journal.putOperation(scopeKey, operation);
+        const queued = takesWorkspaceDirectory(operation.kind) && !isTurnControl(operation.kind) && operation.kind !== 'runtime.destroy'
+            ? await state.journal.putPendingOperation(scopeKey, operation, options.executionPayload, parsed.sessionRecovery)
+            : await state.journal.putOperation(scopeKey, operation);
         const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
         return { rejected: false, operation: queued, executed, reused: false };
     });