@playcraft/cli 0.1.57-beta → 0.1.58-beta

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

@@ -3,12 +3,15 @@ import { lstat, mkdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { sandboxBatchMemberPrepareSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { claimBatchDirectory, withDirectoryOwner } from '../server/directory-access.js';
+import { writeWorkspaceCliContext } from '../workspaces/cli-context.js';
 import { registerWorkspaceDirectory } from '../workspaces/directories.js';
 import { workspaceContainerRoot } from '../workspaces/registry.js';
 import { dependencyInstallCommand, planInstall } from '../workspaces/dependencies.js';
 import { copyCredentialHelpers, gitRead, gitWrite } from './git.js';
 import { restoreArchive } from './source-capture.js';
 import { groupExited, runProcessGroup } from './processes.js';
+import { stopMemberWriters } from './writer-proof.js';
 import { filesystemObjectStore, memberStatus, readMember, readSnapshot, readStopMarker, serializeRun, sourceCacheDir, writeMember, } from './records.js';
 const BRANCH = /^remix\/draft-[a-f0-9]{16}$/;
 function hashCommand(value) {
@@ -143,111 +146,123 @@ export async function prepareBatchMember(state, body, options) {
         if (existing?.processes.some((process) => process.role === 'install' && !process.stopped && !groupExited(process.pid)))
             return memberStatus(existing);
         const snapshot = command.snapshot;
-        if ((await readSnapshot(state, snapshot.batchId))?.digest === snapshot.digest) {
-            /* The local snapshot record is an accelerator; the command snapshot remains authoritative. */
-        }
-        let record = await writeMember(state, {
-            runId: command.runId,
-            ownerFence: command.ownerFence,
-            occupancyId: command.occupancyId,
-            workspaceId: command.workspaceId,
-            directoryName: command.directoryName,
-            phase: 'prepare',
-            state: 'running',
-            writersStopped: false,
-            holding: true,
-            stopRequested: false,
-            processes: existing?.processes ?? [],
-            commandHash: { ...existing?.commandHash, prepare: hash },
-            snapshotDigest: snapshot.digest,
-            branchName: command.branchName,
-            sourceCommit: snapshot.commitHash,
-            beforeTree: existing?.beforeTree,
-            updatedAt: new Date().toISOString(),
-        });
-        let staging;
-        try {
-            const parent = await workspaceContainerRoot(state, command.workspaceId);
-            const root = join(parent, command.directoryName);
-            staging = join(parent, `.batch-member-${randomUUID()}`);
-            const binding = state.journal.getWorkspace(command.workspaceId);
-            if (!binding)
-                throw new Error('workspace_not_registered');
-            const repositoryUrl = binding.repositoryUrl ?? undefined;
-            const sourceRoot = join(parent, snapshot.sourceDirectoryName);
-            if (!(await lstat(root).catch(() => undefined))) {
-                await mkdir(parent, { recursive: true });
-                if (command.resumeFromCommit)
-                    await resumeBranch(repositoryUrl, command.branchName, command.resumeFromCommit, staging, sourceRoot);
-                else
-                    await materialize(state, snapshot, staging, options?.objectStore ?? filesystemObjectStore(state), sourceRoot);
-                const commit = command.resumeFromCommit ?? snapshot.commitHash;
-                await checkoutBranch(staging, command.branchName, commit, repositoryUrl);
-                const { rename } = await import('node:fs/promises');
-                await rename(staging, root);
+        await claimBatchDirectory(state, command);
+        return withDirectoryOwner(state, command, `run:${command.runId}`, async () => {
+            if ((await readSnapshot(state, snapshot.batchId))?.digest === snapshot.digest) {
+                /* The local snapshot record is an accelerator; the command snapshot remains authoritative. */
             }
-            await registerWorkspaceDirectory(state, {
+            let record = await writeMember(state, {
+                runId: command.runId,
+                ownerFence: command.ownerFence,
+                occupancyId: command.occupancyId,
                 workspaceId: command.workspaceId,
                 directoryName: command.directoryName,
-                remixId: command.remixId,
+                phase: 'prepare',
+                state: 'running',
+                writersStopped: false,
+                holding: true,
+                stopRequested: false,
+                processes: existing?.processes ?? [],
+                commandHash: { ...existing?.commandHash, prepare: hash },
+                snapshotDigest: snapshot.digest,
                 branchName: command.branchName,
-                sourceCommit: command.resumeFromCommit ?? snapshot.commitHash,
-            }, state.acceptedLeaseFence);
-            const plan = await planInstall(root);
-            if (plan.kind === 'install') {
-                // Keep control-user installs script-free. pnpm validates the frozen manifest and lock.
-                const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} --ignore-scripts`;
-                const installCommand = process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ?? (plan.hasLockfile
-                    ? frozen
-                    : `${dependencyInstallCommand(state)} --lockfile-only --ignore-scripts && ${frozen}`);
-                const installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
+                sourceCommit: snapshot.commitHash,
+                beforeTree: existing?.beforeTree,
+                updatedAt: new Date().toISOString(),
+            });
+            let staging;
+            try {
+                const parent = await workspaceContainerRoot(state, command.workspaceId);
+                const root = join(parent, command.directoryName);
+                staging = join(parent, `.batch-member-${randomUUID()}`);
+                const binding = state.journal.getWorkspace(command.workspaceId);
+                if (!binding)
+                    throw new Error('workspace_not_registered');
+                const repositoryUrl = binding.repositoryUrl ?? undefined;
+                const sourceRoot = join(parent, snapshot.sourceDirectoryName);
+                if (!(await lstat(root).catch(() => undefined))) {
+                    await mkdir(parent, { recursive: true });
+                    if (command.resumeFromCommit)
+                        await resumeBranch(repositoryUrl, command.branchName, command.resumeFromCommit, staging, sourceRoot);
+                    else
+                        await materialize(state, snapshot, staging, options?.objectStore ?? filesystemObjectStore(state), sourceRoot);
+                    const commit = command.resumeFromCommit ?? snapshot.commitHash;
+                    await checkoutBranch(staging, command.branchName, commit, repositoryUrl);
+                    const { rename } = await import('node:fs/promises');
+                    await rename(staging, root);
+                }
+                await registerWorkspaceDirectory(state, {
+                    workspaceId: command.workspaceId,
+                    directoryName: command.directoryName,
+                    remixId: command.remixId,
+                    branchName: command.branchName,
+                    sourceCommit: command.resumeFromCommit ?? snapshot.commitHash,
+                }, state.acceptedLeaseFence);
+                // Workspace-level registration writes this for `basic` only. A batch member is a workspace
+                // directory in its own right: without the hint `generatedWorkspace()` returns nothing and the
+                // agent's deliverables are never captured as artifacts.
+                await writeWorkspaceCliContext(root, command.workspaceId);
+                const plan = await planInstall(root);
+                if (plan.kind === 'install') {
+                    // Keep control-user installs script-free. pnpm validates the frozen manifest and lock.
+                    const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} --ignore-scripts`;
+                    const installCommand = process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ?? (plan.hasLockfile
+                        ? frozen
+                        : `${dependencyInstallCommand(state)} --lockfile-only --ignore-scripts && ${frozen}`);
+                    const installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
+                        record = await writeMember(state, {
+                            ...record,
+                            processes: [...record.processes, process],
+                        });
+                    });
                     record = await writeMember(state, {
                         ...record,
-                        processes: [...record.processes, process],
+                        processes: record.processes.map((process) => process.pid === installed.process.pid
+                            ? { ...installed.process, role: 'install' }
+                            : process),
                     });
+                    if (await readStopMarker(state, command.runId))
+                        return memberStatus(await sealStopped(state, command, record));
+                    if (installed.code !== 0)
+                        throw new Error('batch_install_failed');
+                }
+                const writersStopped = await stopMemberWriters(state, record);
+                if (!writersStopped)
+                    return memberStatus(await writeMember(state, { ...record, state: 'stopping', writersStopped: false, holding: true }));
+                const head = (await gitRead(root, ['rev-parse', 'HEAD'])).trim();
+                record = await writeMember(state, {
+                    ...record,
+                    state: 'completed',
+                    writersStopped: true,
+                    holding: true,
+                    headCommit: head,
+                    error: undefined,
                 });
+                return memberStatus(record);
+            }
+            catch (error) {
+                const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
+                    ? error.message
+                    : 'batch_prepare_failed';
+                const writersStopped = await stopMemberWriters(state, record);
                 record = await writeMember(state, {
                     ...record,
-                    processes: record.processes.map((process) => process.pid === installed.process.pid
-                        ? { ...installed.process, role: 'install' }
-                        : process),
+                    state: writersStopped ? 'failed' : 'stopping',
+                    writersStopped,
+                    holding: !writersStopped,
+                    error: code,
                 });
-                if (await readStopMarker(state, command.runId))
-                    return memberStatus(await sealStopped(state, command, record));
-                if (installed.code !== 0)
-                    throw new Error('batch_install_failed');
+                return memberStatus(record);
             }
-            const head = (await gitRead(root, ['rev-parse', 'HEAD'])).trim();
-            record = await writeMember(state, {
-                ...record,
-                state: 'completed',
-                writersStopped: true,
-                holding: true,
-                headCommit: head,
-                error: undefined,
-            });
-            return memberStatus(record);
-        }
-        catch (error) {
-            const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
-                ? error.message
-                : 'batch_prepare_failed';
-            record = await writeMember(state, {
-                ...record,
-                state: 'failed',
-                writersStopped: true,
-                holding: false,
-                error: code,
-            });
-            return memberStatus(record);
-        }
-        finally {
-            if (staging)
-                await rm(staging, { recursive: true, force: true });
-        }
+            finally {
+                if (staging)
+                    await rm(staging, { recursive: true, force: true });
+            }
+        });
     });
 }
 async function sealStopped(state, command, existing) {
+    const writersStopped = await stopMemberWriters(state, existing);
     return writeMember(state, {
         runId: command.runId,
         ownerFence: Math.max(command.ownerFence, existing?.ownerFence ?? 0),
@@ -255,9 +270,9 @@ async function sealStopped(state, command, existing) {
         workspaceId: command.workspaceId,
         directoryName: command.directoryName,
         phase: existing?.phase ?? 'prepare',
-        state: 'stopped',
-        writersStopped: true,
-        holding: false,
+        state: writersStopped ? 'stopped' : 'stopping',
+        writersStopped,
+        holding: !writersStopped,
         stopRequested: true,
         processes: existing?.processes ?? [],
         sessionId: existing?.sessionId,

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

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { batchSourceSnapshotRefSchema, sandboxBatchMemberStatusSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { releaseBatchDirectory } from '../server/directory-access.js';
 const runs = new Map();
 let freezeChain = Promise.resolve();
 export function serializeFreeze(action) {
@@ -33,8 +34,10 @@ export function objectFile(state, key) {
     return join(state.config.stateDir, 'batch-objects', key);
 }
 async function writeAtomic(path, body) {
+    // private
     await mkdir(join(path, '..'), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
+    // private
     await writeFile(temporary, body, { mode: 0o600 });
     await rename(temporary, path);
 }
@@ -62,6 +65,7 @@ export async function readMember(state, runId) {
 export async function writeMember(state, record) {
     const next = { ...record, updatedAt: new Date().toISOString() };
     await writeAtomic(memberFile(state, record.runId), JSON.stringify(next));
+    releaseBatchDirectory(state, next);
     return next;
 }
 export async function listMembers(state) {

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

@@ -36,8 +36,16 @@ export async function dispatchBatchRoute(state, request, url) {
         return undefined;
     try {
         if (path === '/runtime/batch-sources/freeze') {
-            const result = batchSourceFreezeResultSchema.parse(await freezeBatchSource(state, await readBody(request)));
-            return { status: 200, body: result };
+            const controller = new AbortController();
+            const disconnected = () => controller.abort();
+            request.socket.once('close', disconnected);
+            try {
+                const result = batchSourceFreezeResultSchema.parse(await freezeBatchSource(state, await readBody(request), { signal: controller.signal }));
+                return { status: 200, body: result };
+            }
+            finally {
+                request.socket.off('close', disconnected);
+            }
         }
         if (path === '/runtime/batch-members/prepare')
             return { status: 200, body: await prepareBatchMember(state, await readBody(request)) };

package/dist/workspace-runtime/batch/source-candidate.js

@@ -39,8 +39,10 @@ export async function readSourceCandidate(state, batchId) {
 export async function writeSourceCandidate(state, candidate) {
     const path = sourceCandidateFile(state, candidate.snapshot.batchId);
     const directory = join(path, '..');
+    // private
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
+    // private
     const handle = await open(temporary, 'wx', 0o600);
     try {
         await handle.writeFile(JSON.stringify(candidate));

package/dist/workspace-runtime/batch/source-capture.js

@@ -129,6 +129,7 @@ export async function restoreArchive(body, destination, expectedDigest) {
     await mkdir(temporary, { recursive: true });
     try {
         const bundle = join(temporary, 'source.bundle');
+        // private
         await writeFile(bundle, Buffer.from(archive.bundle, 'base64'), { mode: 0o600 });
         await gitWrite(temporary, ['clone', '--no-checkout', '--', bundle, destination]);
         await gitWrite(destination, ['checkout', '--detach', archive.commitHash]);

package/dist/workspace-runtime/batch/source-failure.js

@@ -29,7 +29,9 @@ export async function sourceFreezeError(state, batchId, failure, cause) {
     const directory = join(state.config.stateDir, 'batch-source-diagnostics');
     const detail = cause;
     try {
+        // private
         await mkdir(directory, { recursive: true, mode: 0o700 });
+        // private
         await writeFile(join(directory, `${diagnosticId}.json`), JSON.stringify({
             diagnosticId, batchId, ...failure, recordedAt: new Date().toISOString(), reason: redactedReason(cause),
             exitCode: typeof detail?.code === 'number' ? detail.code : undefined,

package/dist/workspace-runtime/batch/source-publish.js

@@ -25,6 +25,7 @@ async function publishRemote(state, candidate, source) {
     const cache = sourceCacheDir(state, snapshot.batchId);
     if (!remote || !snapshot.remoteRef)
         return reject(state, candidate, 'batch_source_push_failed', 'publish', false, 'not_published');
+    // private
     await mkdir(cache, { recursive: true, mode: 0o700 });
     if (!await lstat(join(cache, '.git')).catch(() => undefined))
         await gitWrite(cache, ['init', '--initial-branch', 'source']);
@@ -85,6 +86,7 @@ async function publishRemote(state, candidate, source) {
         if (!await verifyCache(cache, candidate))
             return reject(state, candidate, 'batch_source_snapshot_mismatch', 'verify', false, 'unknown');
     }
+    // private
     await writeFile(`${cache}.digest`, snapshot.digest, { mode: 0o600 });
 }
 async function publishArtifact(state, candidate, store) {
@@ -113,6 +115,7 @@ async function publishArtifact(state, candidate, store) {
             return reject(state, candidate, 'batch_source_upload_failed', 'publish', true, 'unknown', error);
         }
     }
+    // private
     await writeFile(`${cache}.digest`, snapshot.digest, { mode: 0o600 });
 }
 export async function publishSourceCandidate(state, candidate, source, store) {

package/dist/workspace-runtime/batch/writer-proof.js

@@ -0,0 +1,37 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { groupExited, stopProcessGroup } from './processes.js';
+/** An interrupt acknowledgement is not proof that the native turn and its writers have stopped. */
+export async function stopMemberWriters(state, record) {
+    if (!record)
+        return true;
+    let stopped = true;
+    for (const process of record.processes) {
+        if (process.stopped || groupExited(process.pid))
+            process.stopped = true;
+        else
+            process.stopped = await stopProcessGroup(process);
+        if (!process.stopped)
+            stopped = false;
+    }
+    if (record.sessionId) {
+        const terminal = () => {
+            const session = state.journal.getSession(record.sessionId);
+            return Boolean(session && !session.turnBlock && ['completed', 'failed', 'interrupted'].includes(session.turnStatus ?? ''));
+        };
+        if (!terminal()) {
+            const session = state.journal.getSession(record.sessionId);
+            if (session?.threadId)
+                await state.native?.interrupt?.({ sessionId: record.sessionId, threadId: session.threadId }).catch(() => undefined);
+            const deadline = Date.now() + 2_000;
+            while (!terminal() && Date.now() < deadline)
+                await delay(15);
+            if (!terminal())
+                stopped = false;
+        }
+    }
+    const scope = `${record.workspaceId}:${record.directoryName}`;
+    if (state.journal.listManagedWrites(scope).some(writer => !writer.stoppedAt) ||
+        state.journal.listTerminals(record.workspaceId).some(terminal => terminal.directoryName === record.directoryName && terminal.status !== 'destroyed'))
+        stopped = false;
+    return stopped;
+}

package/dist/workspace-runtime/codex/app-server.js

@@ -372,6 +372,7 @@ export function createCodexAppServerAdapter(options) {
         }
         else {
             // Local execution owns its fresh profile; managed launcher profiles are prepared for the development identity by the image.
+            // private
             await mkdir(homeDir, { recursive: true, mode: 0o700 });
             if (closed)
                 throw new Error('codex_not_started');

package/dist/workspace-runtime/codex/config-toml.js

@@ -77,7 +77,9 @@ export async function writePortableCodexCatalog(input) {
     }
     await mkdir(input.directory, { recursive: true });
     const path = join(input.directory, 'portable-models.json');
+    // private
     await writeFile(path, body, { encoding: 'utf8', mode: 0o644 });
+    // private
     await writeFile(join(input.directory, 'portable-models.version.json'), JSON.stringify({
         version,
         sha256: createHash('sha256').update(body).digest('hex'),
@@ -85,6 +87,7 @@ export async function writePortableCodexCatalog(input) {
     return path;
 }
 export async function writePlaycraftCodexConfig(input) {
+    // private
     await mkdir(input.homeDir, { recursive: true, mode: 0o700 });
     const path = join(input.homeDir, 'config.toml');
     const body = [
@@ -102,6 +105,7 @@ export async function writePlaycraftCodexConfig(input) {
         'requires_openai_auth = false',
         '',
     ].join('\n');
+    // private
     await writeFile(path, body, { encoding: 'utf8', mode: 0o600 });
     return path;
 }

package/dist/workspace-runtime/codex/delivery-tools.js

@@ -5,7 +5,7 @@ export const WORKSPACE_DELIVERY_TOOLS = [
     {
         type: 'function',
         name: 'playcraft_build_delivery',
-        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit; each channel reuses the options of its latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. Returns build ids immediately; poll playcraft_get_delivery for status, checks and failure details.',
+        description: 'Export channel packages through the PlayCraft platform. This first saves the workspace (commit and push), then exports that commit; each channel reuses the options of its latest export on this branch, or the defaults when it has none. A workspace without a project first gets one, with a private repository, as its first save would. If the result is pending at workspace.save, finish the current turn without polling so the save can run, then continue the export in a later turn. Once build ids are returned, poll playcraft_get_delivery for status, checks and failure details.',
         inputSchema: {
             type: 'object',
             properties: {

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')