@playcraft/cli 0.1.83 → 0.1.85-beta

package/dist/workspace-runtime/codex/capture-isolation.js

@@ -0,0 +1,10 @@
+/** Matches the root-owned sandbox launcher: control 1500, development children 1501. */
+export function isCaptureIsolationAvailable(input = {
+    platform: process.platform,
+    uid: process.getuid?.(),
+    launcher: process.env.PLAYCRAFT_LAUNCHER_SOCKET,
+}) {
+    return (input.platform === 'linux' &&
+        input.uid === 1500 &&
+        input.launcher === '/run/playcraft/runtime/launcher.sock');
+}

package/dist/workspace-runtime/codex/model-broker.js

@@ -1,23 +1,41 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { Readable, Transform } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { basename, dirname } from 'node:path';
 import { z } from 'zod';
 import { workspaceContextFromRoot } from '../workspaces/registry.js';
-import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint, workspaceExecutionTraceOriginSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint, workspaceExecutionTraceOriginSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { WorkspaceGenerationProvenanceBroker } from './generation-provenance-broker.js';
 import { WorkspaceRemixReferencesBroker } from './remix-references-broker.js';
 import { WorkspaceExecutionContextBroker } from './execution-context-broker.js';
 import { WorkspaceSkillDiscoveryBroker } from './skill-discovery-broker.js';
+import { WorkspaceModelCapture, captureSubmittedResponse, } from './model-capture.js';
 const credentialSchema = z.object({
-    token: z.string().min(1), expiresAt: z.string().datetime(),
-    configId: z.string().uuid(), model: z.string().min(1).max(128),
+    token: z.string().min(1),
+    expiresAt: z.string().datetime(),
+    configId: z.string().uuid(),
+    model: z.string().min(1).max(128),
     supportsReasoning: z.boolean().optional(),
     claims: z.object({
-        environment: z.string(), userId: z.string(), workspaceId: z.string(), runtimeId: z.string(),
-        generation: z.number().int(), runtimeEpoch: z.number().int(),
-        traceOrigin: z.custom(value => workspaceExecutionTraceOriginSchema.safeParse(value).success).optional(),
+        environment: z.string(),
+        userId: z.string(),
+        workspaceId: z.string(),
+        runtimeId: z.string(),
+        generation: z.number().int(),
+        runtimeEpoch: z.number().int(),
+        traceOrigin: z
+            .custom((value) => workspaceExecutionTraceOriginSchema.safeParse(value).success)
+            .optional(),
+        capturePolicy: z
+            .object({
+            enabled: z.literal(true),
+            policyVersion: z.literal('workspace-model-capture-v1'),
+            maxRequestBytes: z.number().int().positive(),
+            maxResponseBytes: z.number().int().positive(),
+            expiresAt: z.string().datetime(),
+        })
+            .optional(),
     }),
 });
 const MAX_MODEL_REQUEST_BYTES = 128 * 1024 * 1024;
@@ -35,12 +53,14 @@ export class WorkspaceModelBroker {
     references;
     executionContext;
     skills;
+    capture;
     constructor(state) {
         this.state = state;
         this.generation = new WorkspaceGenerationProvenanceBroker(state);
         this.references = new WorkspaceRemixReferencesBroker(state);
         this.executionContext = new WorkspaceExecutionContextBroker(state);
         this.skills = new WorkspaceSkillDiscoveryBroker(state);
+        this.capture = new WorkspaceModelCapture(state);
     }
     async start() {
         if (this.server)
@@ -57,6 +77,7 @@ export class WorkspaceModelBroker {
         if (!address || typeof address === 'string')
             throw new Error('model_broker_unavailable');
         this.baseUrl = `http://127.0.0.1:${address.port}`;
+        await this.capture.start();
     }
     async threadConfig(cwd, modelConfigId, sessionId, reasoningEffort) {
         const { activate, ...settings } = await this.prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort);
@@ -69,24 +90,44 @@ export class WorkspaceModelBroker {
         const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
         if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
             throw new Error('model_config_denied');
-        const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
+        const routeKey = sessionId
+            ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`
+            : workspaceId;
         let route = this.routes.get(routeKey);
-        const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
+        const selected = modelConfigId ??
+            (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
         const cacheKey = `${workspaceId}:${selected ?? 'default'}:${reasoningEffort ?? 'default'}:${sessionId ?? ''}:${clientRequestId ?? ''}`;
-        let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected
-            && item.sessionId === sessionId && item.clientRequestId === clientRequestId
-            && item.reasoningEffort === reasoningEffort);
+        let entry = this.entries.get(cacheKey) ??
+            [...this.entries.values()].find((item) => item.workspaceId === workspaceId &&
+                item.epoch === this.state.runtimeEpoch &&
+                item.modelConfigId === selected &&
+                item.sessionId === sessionId &&
+                item.clientRequestId === clientRequestId &&
+                item.reasoningEffort === reasoningEffort);
         if (!entry || entry.epoch !== this.state.runtimeEpoch) {
-            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected, reasoningEffort, sessionId, clientRequestId };
+            entry = {
+                workspaceId,
+                epoch: this.state.runtimeEpoch,
+                cacheKey,
+                modelConfigId: selected,
+                reasoningEffort,
+                sessionId,
+                clientRequestId,
+            };
             this.entries.set(cacheKey, entry);
         }
         // Resolve current model metadata and permission at every native turn boundary.
         const credential = await this.credential(entry, true);
         const boundaryId = sessionId && clientRequestId ? await this.generation.prepare() : undefined;
         if (!route || route.epoch !== this.state.runtimeEpoch) {
-            route = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url'),
-                generationCapability: randomBytes(32).toString('base64url'), referencesCapability: randomBytes(32).toString('base64url'),
-                skillsCapability: randomBytes(32).toString('base64url') };
+            route = {
+                workspaceId,
+                epoch: this.state.runtimeEpoch,
+                capability: randomBytes(32).toString('base64url'),
+                generationCapability: randomBytes(32).toString('base64url'),
+                referencesCapability: randomBytes(32).toString('base64url'),
+                skillsCapability: randomBytes(32).toString('base64url'),
+            };
             this.routes.set(routeKey, route);
         }
         // Each session pins its prepared model; shared credential renewal cannot change an active turn.
@@ -95,41 +136,67 @@ export class WorkspaceModelBroker {
                 if (!this.valid(entry) || this.routes.get(routeKey) !== route)
                     throw new Error('model_access_denied');
                 route.lastAdmissionReason = undefined;
-                route.selected = { entry, model: credential.model,
-                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId, cwd, boundaryId, readOnly,
-                            ...(originCwd ? { originCwd } : {}) } } : {}) };
+                route.selected = {
+                    entry,
+                    model: credential.model,
+                    ...(sessionId && clientRequestId
+                        ? {
+                            feedback: {
+                                sessionId,
+                                clientRequestId,
+                                cwd,
+                                boundaryId,
+                                readOnly,
+                                ...(originCwd ? { originCwd } : {}),
+                            },
+                        }
+                        : {}),
+                };
             },
             model: credential.model,
             modelConfigId: credential.configId,
             modelProvider: 'playcraft_workspace',
             config: {
-                ...(sessionId ? { 'shell_environment_policy.set': {
-                        PLAYCRAFT_AGENT_GENERATION_ENDPOINT: `${this.baseUrl}/${routeKey}/generation-provenance`,
-                        PLAYCRAFT_AGENT_GENERATION_CAPABILITY: route.generationCapability,
-                        PLAYCRAFT_REMIX_REFERENCES_ENDPOINT: `${this.baseUrl}/${routeKey}/remix-references`,
-                        PLAYCRAFT_REMIX_REFERENCES_CAPABILITY: route.referencesCapability,
-                        PLAYCRAFT_SKILLS_ENDPOINT: `${this.baseUrl}/${routeKey}/skill-discovery`,
-                        PLAYCRAFT_SKILLS_CAPABILITY: route.skillsCapability,
-                    } } : {}),
+                ...(sessionId
+                    ? {
+                        'shell_environment_policy.set': {
+                            PLAYCRAFT_AGENT_GENERATION_ENDPOINT: `${this.baseUrl}/${routeKey}/generation-provenance`,
+                            PLAYCRAFT_AGENT_GENERATION_CAPABILITY: route.generationCapability,
+                            PLAYCRAFT_REMIX_REFERENCES_ENDPOINT: `${this.baseUrl}/${routeKey}/remix-references`,
+                            PLAYCRAFT_REMIX_REFERENCES_CAPABILITY: route.referencesCapability,
+                            PLAYCRAFT_SKILLS_ENDPOINT: `${this.baseUrl}/${routeKey}/skill-discovery`,
+                            PLAYCRAFT_SKILLS_CAPABILITY: route.skillsCapability,
+                        },
+                    }
+                    : {}),
                 'model_providers.playcraft_workspace': {
-                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
-                    wire_api: 'responses', requires_openai_auth: false,
+                    name: 'PlayCraft Workspace',
+                    base_url: `${this.baseUrl}/${routeKey}`,
+                    wire_api: 'responses',
+                    requires_openai_auth: false,
                     http_headers: { Authorization: `Bearer ${route.capability}` },
                 },
             },
         };
     }
     valid(entry) {
-        return Boolean(this.server && !this.state.journal.destroyed()
-            && this.state.runtimeEpoch === entry.epoch && this.state.journal.getWorkspace(entry.workspaceId)
-            && this.entries.get(entry.cacheKey) === entry);
+        return Boolean(this.server &&
+            !this.state.journal.destroyed() &&
+            this.state.runtimeEpoch === entry.epoch &&
+            this.state.journal.getWorkspace(entry.workspaceId) &&
+            this.entries.get(entry.cacheKey) === entry);
     }
     /** Called immediately before the native turn/start write, within this broker's process clock. */
     markCodexDispatched(cwd, sessionId, clientRequestId) {
-        const workspaceId = /^(basic|remix-)/.test(basename(cwd)) ? basename(dirname(cwd)) : basename(cwd);
+        const workspaceId = /^(basic|remix-)/.test(basename(cwd))
+            ? basename(dirname(cwd))
+            : basename(cwd);
         const route = this.routes.get(`${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`);
         const entry = route?.selected?.entry;
-        if (!entry || !this.valid(entry) || entry.sessionId !== sessionId || entry.clientRequestId !== clientRequestId)
+        if (!entry ||
+            !this.valid(entry) ||
+            entry.sessionId !== sessionId ||
+            entry.clientRequestId !== clientRequestId)
             return;
         entry.codexDispatchedAt = new Date().toISOString();
         entry.codexDispatchMark = performance.now();
@@ -137,7 +204,9 @@ export class WorkspaceModelBroker {
     async credential(entry, refresh = false) {
         if (!this.valid(entry))
             throw new Error('model_access_denied');
-        if (!refresh && entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
+        if (!refresh &&
+            entry.credential &&
+            Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
             return entry.credential;
         let pending = this.pending.get(entry);
         if (!pending) {
@@ -150,26 +219,48 @@ export class WorkspaceModelBroker {
         const config = this.state.config;
         const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.modelCredentials);
         const response = await fetch(endpoint, {
-            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({ runtimeId: config.runtimeId, generation: config.generation,
-                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+            method: 'POST',
+            redirect: 'error',
+            signal: AbortSignal.timeout(10_000),
+            headers: {
+                authorization: `Bearer ${config.controlToken}`,
+                'content-type': 'application/json',
+                'playcraft-env': config.environment,
+                ...(this.capture.supported ? { 'x-playcraft-model-capture-protocol': '1' } : {}),
+            },
+            body: JSON.stringify({
+                runtimeId: config.runtimeId,
+                generation: config.generation,
+                runtimeEpoch: entry.epoch,
+                workspaceId: entry.workspaceId,
                 ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
                 ...(entry.clientRequestId ? { clientRequestId: entry.clientRequestId } : {}),
                 ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}),
-                ...(entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {}) }),
+                ...(entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {}),
+            }),
         });
         if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(['model_config_required', 'model_config_denied', 'reasoning_effort_denied', 'reasoning_effort_unsupported'].includes(error.reason ?? '') ? error.reason : 'model_credential_unavailable');
+            const error = (await response.json().catch(() => ({})));
+            throw new Error([
+                'model_config_required',
+                'model_config_denied',
+                'reasoning_effort_denied',
+                'reasoning_effort_unsupported',
+            ].includes(error.reason ?? '')
+                ? error.reason
+                : 'model_credential_unavailable');
         }
         const credential = credentialSchema.parse(await response.json());
         const claims = credential.claims;
-        if (!this.valid(entry) || claims.workspaceId !== entry.workspaceId || claims.runtimeId !== config.runtimeId
-            || claims.userId !== config.userId || claims.environment !== config.environment
-            || claims.generation !== config.generation || claims.runtimeEpoch !== entry.epoch
-            || (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId)
-            || Date.parse(credential.expiresAt) <= Date.now() + 1000)
+        if (!this.valid(entry) ||
+            claims.workspaceId !== entry.workspaceId ||
+            claims.runtimeId !== config.runtimeId ||
+            claims.userId !== config.userId ||
+            claims.environment !== config.environment ||
+            claims.generation !== config.generation ||
+            claims.runtimeEpoch !== entry.epoch ||
+            (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId) ||
+            Date.parse(credential.expiresAt) <= Date.now() + 1000)
             throw new Error('model_credential_scope_mismatch');
         entry.modelConfigId = credential.configId;
         entry.credential = credential;
@@ -182,6 +273,9 @@ export class WorkspaceModelBroker {
         const abort = new AbortController();
         this.requests.add(abort);
         let activeRoute;
+        let capturedRequest;
+        let capturedResponse;
+        let requestEnded = false;
         const cancel = () => abort.abort();
         response.once('close', cancel);
         try {
@@ -194,10 +288,21 @@ export class WorkspaceModelBroker {
             const contextRequest = match?.[2] === 'execution-context';
             const referencesRequest = match?.[2] === 'remix-references';
             const skillsRequest = match?.[2]?.startsWith('skill-discovery/');
-            const expected = Buffer.from(route ? `Bearer ${generationRequest || contextRequest ? route.generationCapability
-                : referencesRequest ? route.referencesCapability : skillsRequest ? route.skillsCapability : route.capability}` : '');
-            if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
-                || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
+            const expected = Buffer.from(route
+                ? `Bearer ${generationRequest || contextRequest
+                    ? route.generationCapability
+                    : referencesRequest
+                        ? route.referencesCapability
+                        : skillsRequest
+                            ? route.skillsCapability
+                            : route.capability}`
+                : '');
+            if (request.method !== 'POST' ||
+                !entry ||
+                !expected.length ||
+                presented.length !== expected.length ||
+                !timingSafeEqual(presented, expected) ||
+                !this.valid(entry)) {
                 response.writeHead(403);
                 response.end();
                 return;
@@ -240,12 +345,23 @@ export class WorkspaceModelBroker {
                 return;
             }
             const rejectOversizedBody = () => {
-                response.writeHead(413, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-                response.end(JSON.stringify({ error: { message: 'model_request_too_large',
-                        type: 'invalid_request_error', code: 'model_request_too_large', maxBytes: MAX_MODEL_REQUEST_BYTES } }));
+                response.writeHead(413, {
+                    'content-type': 'application/json',
+                    'cache-control': 'no-store',
+                });
+                response.end(JSON.stringify({
+                    error: {
+                        message: 'model_request_too_large',
+                        type: 'invalid_request_error',
+                        code: 'model_request_too_large',
+                        maxBytes: MAX_MODEL_REQUEST_BYTES,
+                    },
+                }));
             };
             const declaredLength = request.headers['content-length'];
-            if (declaredLength !== undefined && /^\d+$/.test(declaredLength) && Number(declaredLength) > MAX_MODEL_REQUEST_BYTES) {
+            if (declaredLength !== undefined &&
+                /^\d+$/.test(declaredLength) &&
+                Number(declaredLength) > MAX_MODEL_REQUEST_BYTES) {
                 rejectOversizedBody();
                 return;
             }
@@ -256,10 +372,21 @@ export class WorkspaceModelBroker {
             const credentialMark = performance.now();
             const credential = await this.credential(entry);
             const credentialWaitMs = elapsed(credentialMark);
+            const modelCallId = randomUUID();
+            const candidateCaptureOrigin = credential.claims.traceOrigin;
+            const captured = candidateCaptureOrigin?.sessionId === entry.sessionId &&
+                candidateCaptureOrigin?.clientRequestId === entry.clientRequestId
+                ? this.capture.begin(modelCallId, credential)
+                : undefined;
+            capturedRequest = captured?.artifact('codex_request', request.headers['content-type'] ?? 'application/json');
+            capturedResponse = captured?.artifact('codex_response');
+            if (capturedResponse)
+                captureSubmittedResponse(response, capturedResponse);
             const requestReadMark = performance.now();
             const chunks = [];
             let size = 0;
             for await (const chunk of request) {
+                capturedRequest?.append(chunk);
                 size += chunk.length;
                 if (size > MAX_MODEL_REQUEST_BYTES) {
                     rejectOversizedBody();
@@ -268,6 +395,8 @@ export class WorkspaceModelBroker {
                 chunks.push(Buffer.from(chunk));
             }
             const requestReadMs = elapsed(requestReadMark);
+            capturedRequest?.finish({ sourceEnd: 'eof', protocolTerminal: 'not_applicable' });
+            requestEnded = true;
             if (!this.valid(entry))
                 throw new Error('model_access_denied');
             const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
@@ -288,9 +417,12 @@ export class WorkspaceModelBroker {
                 const reasoning = body.reasoning;
                 const modelName = selected.model.split('/').pop() ?? selected.model;
                 const effort = entry.reasoningEffort === 'max' && /^o\d|gpt-[5-9]/i.test(modelName)
-                    ? 'xhigh' : entry.reasoningEffort;
+                    ? 'xhigh'
+                    : entry.reasoningEffort;
                 body.reasoning = {
-                    ...(reasoning && typeof reasoning === 'object' && !Array.isArray(reasoning) ? reasoning : {}),
+                    ...(reasoning && typeof reasoning === 'object' && !Array.isArray(reasoning)
+                        ? reasoning
+                        : {}),
                     effort,
                 };
             }
@@ -299,26 +431,58 @@ export class WorkspaceModelBroker {
             const dispatchedMark = performance.now();
             const beforeDispatchMs = elapsed(receivedMark);
             const candidateOrigin = credential.claims.traceOrigin;
-            const origin = candidateOrigin?.sessionId === entry.sessionId && candidateOrigin?.clientRequestId === entry.clientRequestId
-                ? candidateOrigin : undefined;
-            const broker = { receivedAt, dispatchedAt,
-                credentialWaitMs, requestReadMs, beforeDispatchMs };
+            const origin = candidateOrigin?.sessionId === entry.sessionId &&
+                candidateOrigin?.clientRequestId === entry.clientRequestId
+                ? candidateOrigin
+                : undefined;
+            const broker = {
+                receivedAt,
+                dispatchedAt,
+                credentialWaitMs,
+                requestReadMs,
+                beforeDispatchMs,
+            };
             let attemptId;
             let outcome = 'error';
             try {
                 const upstream = await fetch(platformEndpoint(this.state.config.publicBaseUrl, modelResponsesPath(credential.configId)), {
-                    method: 'POST', redirect: 'error', signal: abort.signal,
-                    headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json',
-                        ...(origin ? { 'x-playcraft-model-journey': JSON.stringify({ version: 1,
-                                runtimeOperationId: origin.runtimeOperationId, sessionId: origin.sessionId, clientRequestId: origin.clientRequestId,
-                                ...(entry.codexDispatchedAt ? { codexDispatchedAt: entry.codexDispatchedAt } : {}),
-                                brokerReceivedAt: receivedAt, brokerDispatchedAt: dispatchedAt, credentialWaitMs, requestReadMs, beforeDispatchMs,
-                                ...(entry.codexDispatchMark === undefined ? {} : { codexDispatchToBrokerMs: Math.max(0, Math.round(receivedMark - entry.codexDispatchMark)) }),
-                            }) } : {}),
-                        ...(selected?.feedback ? {
-                            'x-playcraft-cloud-session-id': selected.feedback.sessionId,
-                            'x-playcraft-client-request-id': selected.feedback.clientRequestId,
-                        } : {}) },
+                    method: 'POST',
+                    redirect: 'error',
+                    signal: abort.signal,
+                    headers: {
+                        authorization: `Bearer ${credential.token}`,
+                        'content-type': 'application/json',
+                        'x-playcraft-model-call-id': modelCallId,
+                        ...(origin
+                            ? {
+                                'x-playcraft-model-journey': JSON.stringify({
+                                    version: 1,
+                                    runtimeOperationId: origin.runtimeOperationId,
+                                    sessionId: origin.sessionId,
+                                    clientRequestId: origin.clientRequestId,
+                                    ...(entry.codexDispatchedAt
+                                        ? { codexDispatchedAt: entry.codexDispatchedAt }
+                                        : {}),
+                                    brokerReceivedAt: receivedAt,
+                                    brokerDispatchedAt: dispatchedAt,
+                                    credentialWaitMs,
+                                    requestReadMs,
+                                    beforeDispatchMs,
+                                    ...(entry.codexDispatchMark === undefined
+                                        ? {}
+                                        : {
+                                            codexDispatchToBrokerMs: Math.max(0, Math.round(receivedMark - entry.codexDispatchMark)),
+                                        }),
+                                }),
+                            }
+                            : {}),
+                        ...(selected?.feedback
+                            ? {
+                                'x-playcraft-cloud-session-id': selected.feedback.sessionId,
+                                'x-playcraft-client-request-id': selected.feedback.clientRequestId,
+                            }
+                            : {}),
+                    },
                     body: JSON.stringify(body),
                 });
                 broker.responseHeadersAt = new Date().toISOString();
@@ -343,6 +507,7 @@ export class WorkspaceModelBroker {
                 if (upstream.body)
                     await pipeline(Readable.fromWeb(upstream.body), new Transform({
                         transform(chunk, _encoding, callback) {
+                            capturedResponse?.upstreamObserved(chunk.length);
                             if (chunk.length && broker.firstBodyByteAt === undefined) {
                                 broker.firstBodyByteAt = new Date().toISOString();
                                 broker.proxyFirstBodyByteMs = elapsed(dispatchedMark);
@@ -364,21 +529,37 @@ export class WorkspaceModelBroker {
                 broker.proxyResponseDurationMs = elapsed(dispatchedMark);
                 if (origin && attemptId) {
                     // Telemetry is sent after transfer and cannot delay or change the Codex model response.
-                    void this.reportObservation(credential.token, { version: 1, attemptId,
-                        runtimeOperationId: origin.runtimeOperationId, sessionId: origin.sessionId,
-                        clientRequestId: origin.clientRequestId, broker, outcome });
+                    void this.reportObservation(credential.token, {
+                        version: 1,
+                        attemptId,
+                        runtimeOperationId: origin.runtimeOperationId,
+                        sessionId: origin.sessionId,
+                        clientRequestId: origin.clientRequestId,
+                        broker,
+                        outcome,
+                    });
                 }
             }
         }
         catch {
             if (!response.headersSent) {
-                response.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
-                response.end(JSON.stringify({ error: { message: 'model_credential_unavailable', type: 'server_error' } }));
+                response.writeHead(503, {
+                    'content-type': 'application/json',
+                    'cache-control': 'no-store',
+                });
+                response.end(JSON.stringify({
+                    error: { message: 'model_credential_unavailable', type: 'server_error' },
+                }));
             }
             else
                 response.destroy();
         }
         finally {
+            if (!requestEnded)
+                capturedRequest?.finish({
+                    sourceEnd: abort.signal.aborted ? 'aborted' : 'io_error',
+                    protocolTerminal: 'unknown',
+                });
             response.off('close', cancel);
             this.requests.delete(abort);
             if (activeRoute) {
@@ -392,12 +573,17 @@ export class WorkspaceModelBroker {
     async reportObservation(token, input) {
         try {
             const response = await fetch(platformEndpoint(this.state.config.publicBaseUrl, '/api/llm-proxy/runtime-observations'), {
-                method: 'POST', redirect: 'error', signal: AbortSignal.timeout(3_000),
-                headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' }, body: JSON.stringify(input),
+                method: 'POST',
+                redirect: 'error',
+                signal: AbortSignal.timeout(3_000),
+                headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+                body: JSON.stringify(input),
             });
             await response.body?.cancel();
         }
-        catch { /* Missing observations remain unknown; never replay a model request for telemetry. */ }
+        catch {
+            /* Missing observations remain unknown; never replay a model request for telemetry. */
+        }
     }
     cancelSession(cwd, sessionId) {
         const routeKey = `${/^(basic|remix-)/.test(basename(cwd)) ? basename(dirname(cwd)) : basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
@@ -424,7 +610,8 @@ export class WorkspaceModelBroker {
             request.abort();
         if (server) {
             server.closeAllConnections();
-            await new Promise(resolve => server.close(() => resolve()));
+            await new Promise((resolve) => server.close(() => resolve()));
         }
+        await this.capture.close();
     }
 }

package/dist/workspace-runtime/codex/model-capture.js

@@ -0,0 +1,675 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, writeFile, readFile, readdir, rm, rename, lstat, realpath } from 'node:fs/promises';
+import { join, resolve, relative, isAbsolute } from 'node:path';
+import { z } from 'zod';
+import { platformEndpoint, } from '@playcraft/common/cloud-workspace/runtime';
+import { MODEL_CAPTURE_CHUNK_BYTES, } from '@playcraft/common/model-proxy';
+import { isCaptureIsolationAvailable } from './capture-isolation.js';
+const QUEUE_BYTES = 8 * 1024 * 1024;
+const SPOOL_BYTES = 512 * 1024 * 1024;
+const MAX_CAPTURE_CALLS = 128;
+const manifestSchema = z.object({
+    version: z.literal(1),
+    identity: z.object({
+        modelCallId: z.string().uuid(),
+        workspaceId: z.string().uuid(),
+        sessionId: z.string().min(1),
+        clientRequestId: z.string().min(1),
+        directoryName: z.string().min(1).optional(),
+        runtimeId: z.string().min(1),
+        generation: z.number().int().min(0),
+        runtimeEpoch: z.number().int().min(0),
+        configId: z.string().uuid(),
+        captureCallRowId: z.string().uuid().optional(),
+        expiresAt: z.string().datetime(),
+    }),
+    artifacts: z
+        .array(z.object({
+        stage: z.enum(['codex_request', 'codex_response']),
+        contentType: z.string().max(256),
+        representation: z.enum(['raw-http-body', 'decoded_body']),
+        parts: z.number().int().min(0).max(128),
+        rawBytes: z.number().int().min(0).max(SPOOL_BYTES),
+        end: z
+            .object({
+            sourceEnd: z.enum([
+                'eof',
+                'aborted',
+                'cancelled_by_failover',
+                'process_lost',
+                'limit_exceeded',
+                'io_error',
+                'not_started',
+            ]),
+            protocolTerminal: z.enum(['observed', 'absent', 'not_applicable', 'unknown']),
+            downstreamFinished: z.boolean().optional(),
+            dispatchObserved: z.boolean().optional(),
+            responseHeadersObserved: z.boolean().optional(),
+            responseStatus: z.number().int().min(100).max(599).optional(),
+            upstreamObservedBytes: z.number().int().min(0).optional(),
+            downstreamSubmittedBytes: z.number().int().min(0).optional(),
+        })
+            .optional(),
+    }))
+        .max(2),
+});
+function within(parent, child) {
+    const path = relative(parent, child);
+    return !path || (!path.startsWith('..') && !isAbsolute(path));
+}
+let queuedBytes = 0;
+let uploadCount = 0;
+const uploadWaiters = [];
+async function uploadSlot(operation) {
+    if (uploadCount >= 2)
+        await new Promise((resolve) => uploadWaiters.push(resolve));
+    else
+        uploadCount++;
+    try {
+        return await operation();
+    }
+    finally {
+        const next = uploadWaiters.shift();
+        if (next)
+            next();
+        else
+            uploadCount--;
+    }
+}
+/** Captures are control-process state. Only immutable scope and raw parts reach disk. */
+export class WorkspaceModelCapture {
+    state;
+    root;
+    diskBytes = 0;
+    closed = false;
+    ready = false;
+    calls = new Set();
+    constructor(state) {
+        this.state = state;
+        this.root = join(state.config.stateDir, 'model-captures');
+    }
+    async start() {
+        if (!isCaptureIsolationAvailable())
+            return;
+        try {
+            await mkdir(this.root, { recursive: true, mode: 0o700 }); // private
+            const info = await lstat(this.root);
+            const rootPath = await realpath(this.root);
+            const workspacePath = await realpath(this.state.config.workspaceRoot).catch(() => resolve(this.state.config.workspaceRoot));
+            const codexPath = await realpath(process.env.PLAYCRAFT_CODEX_HOME || '/var/lib/playcraft/codex').catch(() => resolve(process.env.PLAYCRAFT_CODEX_HOME || '/var/lib/playcraft/codex'));
+            if (!info.isDirectory() ||
+                info.isSymbolicLink() ||
+                (info.mode & 0o077) !== 0 ||
+                (process.getuid && info.uid !== process.getuid()) ||
+                within(workspacePath, rootPath) ||
+                within(codexPath, rootPath))
+                return;
+            this.ready = true;
+            for (const name of await readdir(this.root)) {
+                if (!z.string().uuid().safeParse(name).success)
+                    continue;
+                const directory = join(this.root, name);
+                try {
+                    const entry = await lstat(directory);
+                    if (!entry.isDirectory() ||
+                        entry.isSymbolicLink() ||
+                        entry.uid !== info.uid ||
+                        entry.mode & 0o077)
+                        throw new Error('capture_private_directory_required');
+                    const manifest = manifestSchema.parse(JSON.parse(await readFile(join(directory, 'manifest.json'), 'utf8')));
+                    if (manifest.version !== 1 ||
+                        manifest.identity.modelCallId !== name ||
+                        manifest.identity.runtimeId !== this.state.config.runtimeId ||
+                        manifest.identity.generation !== this.state.config.generation ||
+                        manifest.identity.runtimeEpoch !== this.state.runtimeEpoch ||
+                        Date.parse(manifest.identity.expiresAt) <= Date.now() ||
+                        !manifest.identity.captureCallRowId ||
+                        this.calls.size >= MAX_CAPTURE_CALLS) {
+                        await rm(directory, { recursive: true, force: true });
+                        continue;
+                    }
+                    let existingBytes = 0;
+                    const stages = new Set();
+                    for (const artifact of manifest.artifacts) {
+                        if (stages.has(artifact.stage))
+                            throw new Error('capture_duplicate_artifact');
+                        stages.add(artifact.stage);
+                        let actualBytes = 0;
+                        for (let partNo = 0; partNo < artifact.parts; partNo++) {
+                            const part = await lstat(join(directory, `${artifact.stage}.${partNo}.part`));
+                            if (!part.isFile() ||
+                                part.isSymbolicLink() ||
+                                part.uid !== info.uid ||
+                                part.mode & 0o077 ||
+                                part.size > MODEL_CAPTURE_CHUNK_BYTES)
+                                throw new Error('capture_private_part_required');
+                            actualBytes += part.size;
+                        }
+                        if (actualBytes !== artifact.rawBytes)
+                            throw new Error('capture_part_manifest_mismatch');
+                        existingBytes += actualBytes;
+                        if (!artifact.end)
+                            artifact.end = {
+                                sourceEnd: 'process_lost',
+                                protocolTerminal: 'unknown',
+                                ...(artifact.stage === 'codex_response' ? { downstreamFinished: false } : {}),
+                            };
+                    }
+                    if (this.diskBytes + existingBytes > SPOOL_BYTES)
+                        throw new Error('capture_spool_limit');
+                    this.diskBytes += existingBytes;
+                    const call = new CaptureCall(this, directory, manifest);
+                    this.calls.add(call);
+                    void call.upload();
+                }
+                catch {
+                    await rm(directory, { recursive: true, force: true }).catch(() => { });
+                }
+            }
+        }
+        catch {
+            /* Capture setup failure cannot prevent the loopback broker from starting. */
+        }
+    }
+    begin(modelCallId, credential) {
+        const policy = credential.claims.capturePolicy;
+        const origin = credential.claims.traceOrigin;
+        if (this.closed ||
+            !this.ready ||
+            this.calls.size >= MAX_CAPTURE_CALLS ||
+            !policy?.enabled ||
+            !origin ||
+            !('directory' in origin) ||
+            Date.parse(policy.expiresAt) <= Date.now())
+            return undefined;
+        const identity = {
+            modelCallId,
+            workspaceId: credential.claims.workspaceId,
+            runtimeId: credential.claims.runtimeId,
+            generation: credential.claims.generation,
+            runtimeEpoch: credential.claims.runtimeEpoch,
+            sessionId: origin.sessionId,
+            directoryName: typeof origin.directory === 'string' ? origin.directory : undefined,
+            clientRequestId: origin.clientRequestId,
+            configId: credential.configId,
+            expiresAt: new Date(Math.min(Date.parse(policy.expiresAt), Date.now() + 3_600_000)).toISOString(),
+        };
+        const call = new CaptureCall(this, join(this.root, modelCallId), { version: 1, identity, artifacts: [] }, credential.token, {
+            request: Math.min(policy.maxRequestBytes, 128 * 1024 * 1024),
+            response: Math.min(policy.maxResponseBytes, 512 * 1024 * 1024),
+        });
+        this.calls.add(call);
+        return call;
+    }
+    reserve(bytes) {
+        if (this.diskBytes + bytes > SPOOL_BYTES)
+            return false;
+        this.diskBytes += bytes;
+        return true;
+    }
+    release(bytes) {
+        this.diskBytes = Math.max(0, this.diskBytes - bytes);
+    }
+    done(call) {
+        this.calls.delete(call);
+    }
+    get runtime() {
+        return this.state;
+    }
+    get supported() {
+        return this.ready && !this.closed;
+    }
+    async close() {
+        this.closed = true;
+        // Only local writes are drained. Network/storage availability never delays shutdown.
+        await Promise.allSettled([...this.calls].map((call) => call.flush()));
+        for (const call of this.calls)
+            call.close();
+    }
+}
+export class CaptureCall {
+    owner;
+    directory;
+    manifest;
+    limits;
+    writes = Promise.resolve();
+    manifests = Promise.resolve();
+    token;
+    tokenExpires = 0;
+    uploading = false;
+    stopped = false;
+    reservedBytes = 0;
+    removing;
+    retry;
+    artifacts = new Map();
+    nextParts = new Map();
+    failedStages = new Set();
+    constructor(owner, directory, manifest, token, limits = { request: 128 * 1024 * 1024, response: 512 * 1024 * 1024 }) {
+        this.owner = owner;
+        this.directory = directory;
+        this.manifest = manifest;
+        this.limits = limits;
+        this.token = token;
+        this.reservedBytes = manifest.artifacts.reduce((sum, artifact) => sum + artifact.rawBytes, 0);
+    }
+    artifact(stage, contentType = 'application/octet-stream', representation = 'raw-http-body') {
+        let artifact = this.artifacts.get(stage);
+        if (!artifact) {
+            const record = { stage, contentType, representation, parts: 0, rawBytes: 0 };
+            this.manifest.artifacts.push(record);
+            artifact = new CaptureArtifact(this, record, stage === 'codex_request' ? this.limits.request : this.limits.response);
+            this.artifacts.set(stage, artifact);
+            this.schedule(async () => {
+                if (this.stopped)
+                    return;
+                await mkdir(this.directory, { recursive: true, mode: 0o700 }); // private
+                await this.persist();
+            });
+        }
+        return artifact;
+    }
+    schedule(operation) {
+        this.writes = this.writes.then(operation).catch(() => {
+            this.stopped = true;
+            // Run after this chain's rejection handler returns, so cleanup cannot await itself.
+            setImmediate(() => {
+                void this.remove();
+            });
+        });
+    }
+    part(record, bytes) {
+        const partNo = this.nextParts.get(record.stage) ?? record.parts;
+        this.nextParts.set(record.stage, partNo + 1);
+        if (!this.owner.reserve(bytes.length)) {
+            throw new Error('capture_spool_limit');
+        }
+        this.reservedBytes += bytes.length;
+        this.schedule(async () => {
+            let written = false;
+            try {
+                if (this.stopped || this.failedStages.has(record.stage)) {
+                    this.release(bytes.length);
+                    return;
+                }
+                await writeFile(this.partPath(record.stage, partNo), bytes, { flag: 'wx', mode: 0o600 }); // private
+                written = true;
+                record.rawBytes += bytes.length;
+                record.parts = partNo + 1;
+                await this.persist();
+            }
+            catch (error) {
+                if (!written)
+                    this.release(bytes.length);
+                this.failedStages.add(record.stage);
+            }
+            finally {
+                queuedBytes -= bytes.length;
+            }
+        });
+    }
+    finish(record, end) {
+        this.schedule(async () => {
+            if (this.stopped)
+                return;
+            record.end = {
+                ...end,
+                sourceEnd: this.failedStages.has(record.stage) ? 'io_error' : end.sourceEnd,
+            };
+            await this.persist();
+        });
+        void this.upload();
+    }
+    flush() {
+        return this.writes;
+    }
+    close() {
+        this.stopped = true;
+        if (this.retry)
+            clearTimeout(this.retry);
+    }
+    get active() {
+        return !this.stopped;
+    }
+    release(bytes) {
+        this.owner.release(bytes);
+        this.reservedBytes = Math.max(0, this.reservedBytes - bytes);
+    }
+    remove() {
+        if (this.removing)
+            return this.removing;
+        this.stopped = true;
+        for (const artifact of this.artifacts.values())
+            artifact.finish({ sourceEnd: 'io_error', protocolTerminal: 'unknown' });
+        if (this.retry)
+            clearTimeout(this.retry);
+        this.removing = (async () => {
+            await this.writes;
+            await this.manifests.catch(() => { });
+            try {
+                await rm(this.directory, { recursive: true, force: true });
+                this.release(this.reservedBytes);
+            }
+            catch {
+                /* Keep quota reserved while files cannot be removed. */
+            }
+            finally {
+                this.owner.done(this);
+            }
+        })();
+        return this.removing;
+    }
+    partPath(stage, part) {
+        return join(this.directory, `${stage}.${part}.part`);
+    }
+    persist() {
+        // Registration and body writes share one manifest writer, including snapshot creation.
+        const next = this.manifests
+            .catch(() => { })
+            .then(async () => {
+            const temporary = join(this.directory, `${randomUUID()}.tmp`);
+            await writeFile(temporary, JSON.stringify(this.manifest), { mode: 0o600 }); // private
+            await rename(temporary, join(this.directory, 'manifest.json'));
+        });
+        this.manifests = next;
+        return next;
+    }
+    async authorize() {
+        if (this.token && (!this.tokenExpires || this.tokenExpires > Date.now() + 10_000))
+            return this.token;
+        const config = this.owner.runtime.config;
+        const response = await fetch(platformEndpoint(config.publicBaseUrl, '/runtime/internal/model-capture-upload-grants'), {
+            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({
+                runtimeId: this.manifest.identity.runtimeId,
+                generation: this.manifest.identity.generation,
+                runtimeEpoch: this.manifest.identity.runtimeEpoch,
+                workspaceId: this.manifest.identity.workspaceId,
+                sessionId: this.manifest.identity.sessionId,
+                directoryName: this.manifest.identity.directoryName,
+                clientRequestId: this.manifest.identity.clientRequestId,
+                modelCallId: this.manifest.identity.modelCallId,
+                captureCallRowId: this.manifest.identity.captureCallRowId,
+            }),
+        });
+        if (!response.ok) {
+            await response.body?.cancel();
+            if ([401, 403, 404, 410].includes(response.status))
+                await this.remove();
+            throw new Error('capture_authority_unavailable');
+        }
+        const grant = z
+            .object({ token: z.string().min(1), expiresAt: z.string().datetime() })
+            .parse(await response.json());
+        this.token = grant.token;
+        this.tokenExpires = Date.parse(grant.expiresAt);
+        return grant.token;
+    }
+    async send(path, init) {
+        const token = await this.authorize();
+        const base = `/api/llm-proxy/workspace-captures/${this.manifest.identity.modelCallId}`;
+        const response = await fetch(platformEndpoint(this.owner.runtime.config.publicBaseUrl, `${base}${path}`), {
+            ...init,
+            redirect: 'error',
+            signal: AbortSignal.timeout(15_000),
+            headers: { ...init.headers, authorization: `Bearer ${token}` },
+        });
+        if (!response.ok) {
+            const terminal = response.status === 410 ||
+                ((response.status === 401 || response.status === 403) && this.tokenExpires > 0);
+            if (response.status === 401 || response.status === 403) {
+                this.token = undefined;
+                this.tokenExpires = 0;
+            }
+            await response.body?.cancel();
+            if (terminal)
+                await this.remove();
+            throw new Error('capture_upload_unavailable');
+        }
+        return response;
+    }
+    verifyArchive(record, sha256, remote) {
+        if (remote.stage !== record.stage ||
+            remote.archiveState !== 'archived' ||
+            remote.rawBytes !== record.rawBytes ||
+            remote.partCount !== record.parts ||
+            remote.sha256 !== sha256 ||
+            Object.entries(record.end ?? {}).some(([key, value]) => remote[key] !== value)) {
+            throw new Error('capture_archive_confirmation_mismatch');
+        }
+    }
+    async upload() {
+        if (this.uploading || this.stopped)
+            return;
+        this.uploading = true;
+        try {
+            await this.writes;
+            if (this.stopped)
+                return;
+            if (Date.parse(this.manifest.identity.expiresAt) <= Date.now()) {
+                await this.remove();
+                return;
+            }
+            await uploadSlot(async () => {
+                if (!this.manifest.identity.captureCallRowId) {
+                    const response = await this.send('/register', {
+                        method: 'POST',
+                        headers: { 'content-type': 'application/json' },
+                        body: JSON.stringify({ configId: this.manifest.identity.configId }),
+                    });
+                    const registration = (await response.json());
+                    if (registration.capability !== 'available' || !registration.call) {
+                        await this.remove();
+                        return;
+                    }
+                    this.manifest.identity.captureCallRowId = registration.call.callRowId;
+                    await this.persist();
+                }
+                const statusResponse = await this.send('/upload-status', { method: 'GET' });
+                const status = (await statusResponse.json());
+                if (status.call?.callRowId !== this.manifest.identity.captureCallRowId ||
+                    status.call.modelCallId !== this.manifest.identity.modelCallId ||
+                    !Array.isArray(status.artifacts)) {
+                    throw new Error('capture_status_identity_mismatch');
+                }
+                for (const record of this.manifest.artifacts) {
+                    if (!record.end)
+                        continue;
+                    const remote = status.artifacts.find((item) => item.stage === record.stage);
+                    const confirmed = new Map((remote?.confirmedParts ?? []).map((part) => [part.partNo, part]));
+                    const hash = createHash('sha256');
+                    for (let partNo = 0; partNo < record.parts; partNo++) {
+                        const bytes = await readFile(this.partPath(record.stage, partNo));
+                        hash.update(bytes);
+                        const sha256 = createHash('sha256').update(bytes).digest('hex');
+                        const part = confirmed.get(partNo);
+                        if (part) {
+                            if (part.sha256 !== sha256 || part.rawBytes !== bytes.length)
+                                throw new Error('capture_part_confirmation_mismatch');
+                            continue;
+                        }
+                        const response = await this.send(`/artifacts/${record.stage}/chunks/${partNo}`, {
+                            method: 'PUT',
+                            headers: {
+                                'content-type': 'application/octet-stream',
+                                'x-capture-sha256': sha256,
+                                'x-capture-content-type': record.contentType,
+                                'x-capture-representation': record.representation,
+                            },
+                            body: bytes,
+                        });
+                        await response.body?.cancel();
+                    }
+                    const sha256 = hash.digest('hex');
+                    if (remote?.archiveState === 'archived') {
+                        this.verifyArchive(record, sha256, remote);
+                        continue;
+                    }
+                    const response = await this.send(`/artifacts/${record.stage}/finalize`, {
+                        method: 'POST',
+                        headers: { 'content-type': 'application/json' },
+                        body: JSON.stringify({
+                            ...record.end,
+                            partCount: record.parts,
+                            rawBytes: record.rawBytes,
+                            sha256,
+                        }),
+                    });
+                    this.verifyArchive(record, sha256, (await response.json()));
+                }
+            });
+            if ((this.manifest.artifacts.length === 2 || this.artifacts.size === 0) &&
+                this.manifest.artifacts.every((item) => item.end)) {
+                await this.remove();
+                return;
+            }
+        }
+        catch {
+            /* Retry only archival transport, never model execution. */
+        }
+        finally {
+            this.uploading = false;
+            if (!this.stopped) {
+                this.retry = setTimeout(() => {
+                    void this.upload();
+                }, 5_000);
+                this.retry.unref();
+            }
+        }
+    }
+}
+export class CaptureArtifact {
+    call;
+    record;
+    limit;
+    pending = [];
+    pendingBytes = 0;
+    receivedBytes = 0;
+    ended = false;
+    failure;
+    observedBytes = 0;
+    submittedBytes = 0;
+    constructor(call, record, limit) {
+        this.call = call;
+        this.record = record;
+        this.limit = limit;
+    }
+    contentType(value) {
+        this.record.contentType = value.slice(0, 256);
+    }
+    upstreamObserved(bytes) {
+        this.observedBytes += bytes;
+    }
+    append(bytes) {
+        if (this.ended || !bytes.byteLength)
+            return;
+        this.submittedBytes += bytes.byteLength;
+        if (this.failure || !this.call.active)
+            return;
+        if (this.receivedBytes + bytes.byteLength > this.limit ||
+            queuedBytes + bytes.byteLength > QUEUE_BYTES) {
+            this.failure = 'limit_exceeded';
+            return;
+        }
+        this.receivedBytes += bytes.byteLength;
+        queuedBytes += bytes.byteLength;
+        let offset = 0;
+        while (offset < bytes.byteLength) {
+            const length = Math.min(MODEL_CAPTURE_CHUNK_BYTES - this.pendingBytes, bytes.byteLength - offset);
+            this.pending.push(Buffer.from(bytes.subarray(offset, offset + length)));
+            this.pendingBytes += length;
+            offset += length;
+            if (this.pendingBytes === MODEL_CAPTURE_CHUNK_BYTES)
+                this.flushPart();
+        }
+    }
+    finish(end) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        if (!this.call.active) {
+            queuedBytes -= this.pendingBytes;
+            this.pending = [];
+            this.pendingBytes = 0;
+            return;
+        }
+        this.flushPart();
+        this.call.finish(this.record, {
+            ...end,
+            sourceEnd: this.failure ?? end.sourceEnd,
+            ...(this.record.stage === 'codex_response'
+                ? {
+                    upstreamObservedBytes: this.observedBytes,
+                    downstreamSubmittedBytes: this.submittedBytes,
+                }
+                : {}),
+        });
+    }
+    flushPart() {
+        if (!this.pendingBytes)
+            return;
+        const bytes = Buffer.concat(this.pending, this.pendingBytes);
+        this.pending = [];
+        this.pendingBytes = 0;
+        try {
+            this.call.part(this.record, bytes);
+        }
+        catch {
+            queuedBytes -= bytes.length;
+            this.failure = 'limit_exceeded';
+        }
+    }
+}
+/** Observes Node's accepted bytes without changing the return value or drain handling. */
+export function captureSubmittedResponse(response, artifact) {
+    const append = (chunk, encoding) => {
+        try {
+            if (typeof chunk === 'string')
+                artifact.append(Buffer.from(chunk, typeof encoding === 'string' ? encoding : undefined));
+            else if (chunk instanceof Uint8Array)
+                artifact.append(chunk);
+        }
+        catch {
+            /* Archival must never turn a successful write into an inference failure. */
+        }
+    };
+    const write = response.write;
+    response.write = function (...args) {
+        const writable = !this.destroyed && !this.writableEnded && !this.socket?.destroyed;
+        const accepted = Reflect.apply(write, this, args);
+        if (writable && !this.destroyed && !this.socket?.destroyed)
+            append(args[0], args[1]);
+        return accepted;
+    };
+    const end = response.end;
+    response.end = function (chunk, encoding, callback) {
+        const writable = !this.destroyed && !this.writableEnded && !this.socket?.destroyed;
+        const accepted = Reflect.apply(end, this, [chunk, encoding, callback]);
+        if (writable && !this.destroyed && !this.socket?.destroyed)
+            append(chunk, encoding);
+        return accepted;
+    };
+    response.once('finish', () => queueMicrotask(() => {
+        artifact.contentType(String(response.getHeader('content-type') ?? 'application/octet-stream'));
+        artifact.finish({
+            sourceEnd: 'eof',
+            protocolTerminal: /event-stream|ndjson/i.test(String(response.getHeader('content-type') ?? ''))
+                ? 'unknown'
+                : 'not_applicable',
+            downstreamFinished: true,
+            responseStatus: response.statusCode,
+        });
+    }));
+    response.once('close', () => queueMicrotask(() => artifact.finish({
+        sourceEnd: response.writableFinished ? 'eof' : 'aborted',
+        protocolTerminal: 'unknown',
+        downstreamFinished: response.writableFinished,
+        responseStatus: response.statusCode,
+    })));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.83",
+  "version": "0.1.85-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -22,6 +22,7 @@
     "README.md"
   ],
   "scripts": {
+    "lint": "pnpm -w run lint:eslint packages/cli",
     "dev": "tsc -w",
     "build": "node scripts/generate-asset-skills.mjs && node scripts/generate-video-skills.mjs && node scripts/generate-parameter-skill.mjs && node scripts/generate-level-editor-skill.mjs && node scripts/generate-preview-runtime.mjs && tsc",
     "start": "node dist/index.js",
@@ -57,8 +58,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "0.1.83",
-    "@playcraft/common": "0.1.83",
+    "@playcraft/build": "0.1.85-beta",
+    "@playcraft/common": "0.1.85-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",

package/templates/preview-runtime/v1/manifest.json

@@ -8,7 +8,7 @@
     "release-guard.mjs": "728ac088f8d885a50a1c9bcdddad724fa80afd06e66a6dd3658756034e563055",
     "runtime.d.mts": "a90c69a8b72105e8dc8fe0b3bcd272f038ed255f7daf5ec6c1aefc293a1e84b2",
     "runtime.d.ts": "a90c69a8b72105e8dc8fe0b3bcd272f038ed255f7daf5ec6c1aefc293a1e84b2",
-    "runtime.mjs": "50dc53ff94effedf10903df708c1ecdb51bd8145a5a6ec1eac9449cad7424a24",
+    "runtime.mjs": "fefc50ed3246b6d33934179c04952c48f424fcce4d8d45b35bbcd083b644e41e",
     "types/adapters.d.ts": "f5e70c4bb9043de1c590eada14266f613286360c809faf26680b0bbbd1cc7b2c",
     "types/host.d.ts": "9ea867d5485a66aba7da86ea7e5583bca6b9a7a89618afd0eb70ace58e06faf9",
     "types/index.d.ts": "210d24a767f260bc8944d917b50dae1357cba31b8b5d499bea7bcc99b1051e6c",

package/templates/preview-runtime/v1/runtime.mjs

@@ -257,7 +257,7 @@ var package_default = {
     test: "vitest run",
     "test:watch": "vitest",
     playground: 'pnpm --filter "@playcraft/iframe-bridge-playground-*" --parallel dev',
-    lint: "echo 'No eslint config yet'",
+    lint: "pnpm -w run lint:eslint packages/iframe-bridge",
     release: "node ../../scripts/release-npm.mjs --packages=iframe-bridge --skip-install --skip-tests --skip-git-push"
   },
   devDependencies: {