@playcraft/cli 0.1.56-beta → 0.1.58-beta

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

@@ -3,25 +3,17 @@ 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}$/;
-const LOCKS = [
-    'pnpm-lock.yaml',
-    'package-lock.json',
-    'npm-shrinkwrap.json',
-    'yarn.lock',
-    'bun.lock',
-    'bun.lockb',
-];
-export function frozenInstallCommand() {
-    return (process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ??
-        'pnpm install --frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --ignore-scripts');
-}
 function hashCommand(value) {
     return createHash('sha256').update(JSON.stringify(value)).digest('hex');
 }
@@ -117,43 +109,6 @@ async function resumeBranch(repositoryUrl, branchName, commit, destination, sour
     }
     await gitWrite(destination, ['checkout', '-B', branchName, commit]);
 }
-export async function assertMemberDependencies(root) {
-    let manifest;
-    try {
-        manifest = await readFile(join(root, 'package.json'), 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            return 'skip';
-        throw error;
-    }
-    let names = [];
-    try {
-        const pkg = JSON.parse(manifest);
-        names = [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})];
-    }
-    catch {
-        throw new Error('dependency_lock_mismatch');
-    }
-    const present = [];
-    for (const lock of LOCKS)
-        if (await lstat(join(root, lock)).catch(() => undefined))
-            present.push(lock);
-    if (present.length > 1)
-        throw new Error('dependency_locks_conflict');
-    if (present.length === 0)
-        return 'skip';
-    if (present[0] !== 'pnpm-lock.yaml')
-        throw new Error('dependency_lock_mismatch');
-    const lock = await readFile(join(root, 'pnpm-lock.yaml'), 'utf8');
-    if (names.some((name) => !lock.includes(`${name}:`) &&
-        !lock.includes(`/${name}@`) &&
-        !lock.includes(`'${name}'`) &&
-        !lock.includes(`"${name}"`))) {
-        throw new Error('dependency_lock_mismatch');
-    }
-    return 'install';
-}
 export async function prepareBatchMember(state, body, options) {
     if (!body ||
         typeof body !== 'object' ||
@@ -191,106 +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 assertMemberDependencies(root);
-            if (plan === 'install') {
-                const installed = await runProcessGroup(root, frozenInstallCommand(), '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),
@@ -298,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: 'Start one formal channel delivery build. Returns build identifiers immediately; poll playcraft_get_delivery for status and validation results. This writes a delivery record under dist/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. 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: {
@@ -24,7 +24,7 @@ export const WORKSPACE_DELIVERY_TOOLS = [
     {
         type: 'function',
         name: 'playcraft_get_delivery',
-        description: 'Read the latest delivery build, or one build by id, including status, validation summary, error and a truncated build log.',
+        description: 'Read one export by build id, or the latest export of a channel (or of any channel) on this branch: status, current stage while running, channel check findings, and for a failed export the failed stage, command, exit code and the end of its stderr/stdout.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -109,8 +109,9 @@ export class WorkspaceDeliveryTools {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
         }
+        // Sandbox builds are UUIDs; platform exports use the build queue's ids.
         if (input.buildId !== undefined && (typeof input.buildId !== 'string'
-            || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(input.buildId))) {
+            || !/^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/.test(input.buildId))) {
             await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
             return;
         }
@@ -138,7 +139,8 @@ export class WorkspaceDeliveryTools {
     }
 }
 function errorReason(cause) {
-    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
-        return cause.code;
+    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string') {
+        return cause.message.startsWith(cause.code) ? cause.message.slice(0, 500) : cause.code;
+    }
     return 'delivery_tool_failed';
 }

package/dist/workspace-runtime/codex/generation-provenance-broker.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { agentGenerationProvenanceRequestSchema, PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
+import { prepareLauncherOrigin, verifyLauncherOrigin } from './launcher-client.js';
+const requestSchema = agentGenerationProvenanceRequestSchema.pick({ toolPath: true, toolRequestId: true, payloadHash: true });
+/** Only an unambiguous, newly launched shell in a controlled turn receives attribution. */
+export class WorkspaceGenerationProvenanceBroker {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    async prepare() {
+        const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+        const root = this.state.native?.executionProcess?.();
+        return socketPath && root ? prepareLauncherOrigin({ socketPath, rootPid: root.pid, runtimeEpoch: this.state.runtimeEpoch }) : undefined;
+    }
+    operation(context) {
+        const active = this.state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind)
+            && ['dispatched', 'accepted', 'uncertain'].includes(operation.status)
+            && operation.generation === this.state.config.generation && operation.runtimeEpoch === this.state.runtimeEpoch);
+        if (active.length !== 1)
+            return undefined;
+        const operation = active[0];
+        const session = this.state.journal.getSession(context.sessionId);
+        if (operation.kind !== 'session.turn' || operation.sessionId !== context.sessionId || operation.clientRequestId !== context.clientRequestId
+            || !operation.nativeThreadId || !operation.nativeTurnId || !operation.workspaceId || !operation.directoryName
+            || !session || session.threadId !== operation.nativeThreadId || session.activeTurnId !== operation.nativeTurnId
+            || session.cwd !== context.cwd || !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
+            return undefined;
+        return operation;
+    }
+    async forward(request, response, context, valid) {
+        const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+        const deny = () => { response.writeHead(403, { 'cache-control': 'no-store' }); response.end(); };
+        try {
+            const operation = this.operation(context);
+            if (!valid() || !socketPath || !context.boundaryId || !operation || request.socket.remoteAddress !== '127.0.0.1'
+                || !request.socket.localPort || !request.socket.remotePort)
+                return deny();
+            let text = '';
+            for await (const chunk of request) {
+                text += chunk.toString();
+                if (text.length > 2048)
+                    return deny();
+            }
+            const parsed = requestSchema.safeParse(JSON.parse(text));
+            if (!parsed.success || !await verifyLauncherOrigin({ socketPath, boundaryId: context.boundaryId,
+                runtimeEpoch: this.state.runtimeEpoch, serverPort: request.socket.localPort, clientPort: request.socket.remotePort, cwd: context.cwd }))
+                return deny();
+            // The socket lookup may take time. Never attest a turn which ended or changed meanwhile.
+            if (!valid() || this.operation(context)?.operationId !== operation.operationId)
+                return deny();
+            const config = this.state.config;
+            const input = agentGenerationProvenanceRequestSchema.parse({ ...parsed.data,
+                runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: this.state.runtimeEpoch,
+                workspaceId: operation.workspaceId, directoryName: operation.directoryName,
+                sessionId: context.sessionId, sessionClientRequestId: context.clientRequestId,
+                nativeThreadId: operation.nativeThreadId, nativeTurnId: operation.nativeTurnId });
+            const upstream = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.agentGenerationProvenance), {
+                method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+                headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+                body: JSON.stringify(input),
+            });
+            if (!upstream.ok) {
+                await upstream.body?.cancel();
+                return deny();
+            }
+            const value = z.object({ proof: z.string().min(1).max(8192) }).strict().parse(await upstream.json());
+            if (!valid() || this.operation(context)?.operationId !== operation.operationId)
+                return deny();
+            response.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(value));
+        }
+        catch {
+            if (!response.headersSent)
+                deny();
+            else
+                response.destroy();
+        }
+    }
+}

package/dist/workspace-runtime/codex/launcher-client.js

@@ -33,6 +33,24 @@ function request(socketPath, message) {
         });
     });
 }
+/** The private launcher owns the boundary; development shells never receive its identity. */
+export async function prepareLauncherOrigin(input) {
+    try {
+        const reply = await request(input.socketPath, { action: 'origin-boundary', rootPid: input.rootPid, runtimeEpoch: input.runtimeEpoch });
+        return typeof reply.boundaryId === 'string' ? reply.boundaryId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function verifyLauncherOrigin(input) {
+    try {
+        return (await request(input.socketPath, { ...input, action: 'origin-verify', socketPath: undefined })).verified === true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function startLauncherProcess(input) {
     const socket = createConnection(input.socketPath);
     const stdout = new PassThrough();