@playcraft/cli 0.1.58-beta → 0.1.60-beta

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

@@ -33,6 +33,24 @@ function request(socketPath, message) {
         });
     });
 }
+/** A persisted identity lets the controller stop development-user writers after a request ends. */
+export async function stopLauncherProcess(input) {
+    if (!input.instanceId)
+        throw new Error('launcher_start_unconfirmed');
+    const { socketPath, ...identity } = input;
+    // A new launcher's empty registry cannot confirm an old group's exit.
+    for (const signal of ['SIGTERM', 'SIGKILL']) {
+        await request(socketPath, { ...identity, action: 'stop', signal });
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline) {
+            const status = await request(socketPath, { ...identity, action: 'status' });
+            if (status.running === false)
+                return;
+            await delay(50);
+        }
+    }
+    throw new Error('codex_group_stop_unconfirmed');
+}
 /** The private launcher owns the boundary; development shells never receive its identity. */
 export async function prepareLauncherOrigin(input) {
     try {
@@ -98,9 +116,12 @@ export async function startLauncherProcess(input) {
                 try {
                     const frame = JSON.parse(line);
                     if (!started) {
+                        if (frame.ok === false)
+                            throw Object.assign(new Error(frame.error || 'launcher_start_failed'), { launchRejected: true });
                         if (!frame.ok || !frame.pid || !frame.instanceId)
                             throw new Error(frame.error || 'launcher_start_failed');
                         identity = {
+                            socketPath: input.socketPath,
                             processId: input.processId,
                             runtimeEpoch: input.runtimeEpoch,
                             instanceId: frame.instanceId,
@@ -146,6 +167,7 @@ export async function startLauncherProcess(input) {
         });
     });
     return {
+        identity: identity,
         pid,
         stdin,
         stdout,
@@ -163,31 +185,19 @@ export async function startLauncherProcess(input) {
         },
         stop() {
             stopPromise ??= (async () => {
-                // A new launcher's empty registry cannot confirm an old group's exit.
-                for (const signal of ['SIGTERM', 'SIGKILL']) {
-                    await request(input.socketPath, { ...identity, action: 'stop', signal });
-                    const deadline = Date.now() + 3000;
-                    while (Date.now() < deadline) {
-                        const status = await request(input.socketPath, { ...identity, action: 'status' });
-                        if (status.running === false) {
-                            let timeout;
-                            try {
-                                await Promise.race([transportClosed, new Promise((_resolve, reject) => {
-                                        timeout = setTimeout(() => {
-                                            socket.destroy();
-                                            reject(new Error('launcher_output_drain_unconfirmed'));
-                                        }, 3000);
-                                    })]);
-                            }
-                            finally {
-                                clearTimeout(timeout);
-                            }
-                            return;
-                        }
-                        await delay(50);
-                    }
+                await stopLauncherProcess(identity);
+                let timeout;
+                try {
+                    await Promise.race([transportClosed, new Promise((_resolve, reject) => {
+                            timeout = setTimeout(() => {
+                                socket.destroy();
+                                reject(new Error('launcher_output_drain_unconfirmed'));
+                            }, 3000);
+                        })]);
+                }
+                finally {
+                    clearTimeout(timeout);
                 }
-                throw new Error('codex_group_stop_unconfirmed');
             })();
             return stopPromise;
         },

package/dist/workspace-runtime/codex/loopback.js

@@ -87,6 +87,8 @@ export function createLoopbackNativeAdapter() {
             if (!thread || thread.sessionId !== input.sessionId)
                 return { outcome: 'uncertain' };
             const turnId = thread.turnId;
+            if (input.expectedTurnId !== undefined && input.expectedTurnId !== turnId)
+                return { outcome: 'failed', error: 'turn_changed' };
             queueMicrotask(() => {
                 emit(collectedEvent('notification', 'turn/completed', {
                     threadId: input.threadId,

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

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { workspaceContextFromRoot } from '../workspaces/registry.js';
 import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 import { WorkspaceGenerationProvenanceBroker } from './generation-provenance-broker.js';
+import { WorkspaceRemixReferencesBroker } from './remix-references-broker.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),
@@ -27,9 +28,11 @@ export class WorkspaceModelBroker {
     requests = new Set();
     sessionRequests = new Map();
     generation;
+    references;
     constructor(state) {
         this.state = state;
         this.generation = new WorkspaceGenerationProvenanceBroker(state);
+        this.references = new WorkspaceRemixReferencesBroker(state);
     }
     async start() {
         if (this.server)
@@ -52,7 +55,7 @@ export class WorkspaceModelBroker {
         activate();
         return settings;
     }
-    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId) {
+    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId, originCwd) {
         if (!this.server)
             throw new Error('workspace_not_registered');
         const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
@@ -61,11 +64,12 @@ export class WorkspaceModelBroker {
         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 cacheKey = `${workspaceId}:${selected ?? 'default'}:${reasoningEffort ?? 'default'}`;
+        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);
         if (!entry || entry.epoch !== this.state.runtimeEpoch) {
-            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected, reasoningEffort };
+            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.
@@ -73,16 +77,37 @@ export class WorkspaceModelBroker {
         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') };
+                generationCapability: randomBytes(32).toString('base64url'), referencesCapability: randomBytes(32).toString('base64url') };
             this.routes.set(routeKey, route);
         }
         // Each session pins its prepared model; shared credential renewal cannot change an active turn.
         return {
-            activate: () => {
+            activate: (readOnly = false) => {
                 if (!this.valid(entry) || this.routes.get(routeKey) !== route)
                     throw new Error('model_access_denied');
+                const priorFeedback = route.selected?.feedback;
+                let refsBlocked = Boolean(entry.refsBlocked || priorFeedback?.refsBlocked && priorFeedback.clientRequestId === clientRequestId);
+                if (sessionId && clientRequestId) {
+                    const overlaps = (this.state.journal.listOperations?.() ?? []).some(({ 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
+                        && (operation.sessionId !== sessionId || operation.clientRequestId !== clientRequestId));
+                    if (overlaps) {
+                        refsBlocked = true;
+                        // A completed overlapping turn may leave shells alive. Only a later turn gets a new safe boundary.
+                        for (const prepared of this.entries.values()) {
+                            if (prepared.epoch === this.state.runtimeEpoch)
+                                prepared.refsBlocked = true;
+                        }
+                        for (const existing of this.routes.values()) {
+                            if (existing.epoch === this.state.runtimeEpoch && existing.selected?.feedback)
+                                existing.selected.feedback.refsBlocked = true;
+                        }
+                    }
+                }
                 route.selected = { entry, model: credential.model,
-                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId, cwd, boundaryId } } : {}) };
+                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId, cwd, boundaryId, readOnly, refsBlocked,
+                            ...(originCwd ? { originCwd } : {}) } } : {}) };
             },
             model: credential.model,
             modelConfigId: credential.configId,
@@ -91,6 +116,8 @@ export class WorkspaceModelBroker {
                 ...(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,
                     } } : {}),
                 'model_providers.playcraft_workspace': {
                     name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
@@ -125,6 +152,8 @@ export class WorkspaceModelBroker {
             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,
+                ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
+                ...(entry.clientRequestId ? { clientRequestId: entry.clientRequestId } : {}),
                 ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}),
                 ...(entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {}) }),
         });
@@ -151,13 +180,15 @@ export class WorkspaceModelBroker {
         const cancel = () => abort.abort();
         response.once('close', cancel);
         try {
-            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance)$/.exec(request.url ?? '');
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/(responses|generation-provenance|remix-references)$/.exec(request.url ?? '');
             const route = match ? this.routes.get(match[1]) : undefined;
             const selected = route?.selected;
             const entry = selected?.entry;
             const presented = Buffer.from(request.headers.authorization ?? '');
             const generationRequest = match?.[2] === 'generation-provenance';
-            const expected = Buffer.from(route ? `Bearer ${generationRequest ? route.generationCapability : route.capability}` : '');
+            const referencesRequest = match?.[2] === 'remix-references';
+            const expected = Buffer.from(route ? `Bearer ${generationRequest ? route.generationCapability
+                : referencesRequest ? route.referencesCapability : route.capability}` : '');
             if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
                 || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
                 response.writeHead(403);
@@ -173,6 +204,15 @@ export class WorkspaceModelBroker {
                 await this.generation.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected);
                 return;
             }
+            if (referencesRequest) {
+                if (!selected?.feedback) {
+                    response.writeHead(403);
+                    response.end();
+                    return;
+                }
+                await this.references.forward(request, response, selected.feedback, () => this.valid(entry) && route?.selected === selected);
+                return;
+            }
             activeRoute = route;
             const active = this.sessionRequests.get(route) ?? new Set();
             active.add(abort);

package/dist/workspace-runtime/codex/remix-references-broker.js

@@ -0,0 +1,184 @@
+import { realpath } from 'node:fs/promises';
+import { isAbsolute, relative } from 'node:path';
+import { z } from 'zod';
+import { PLATFORM_ROUTES, platformEndpoint, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES, WORKSPACE_REMIX_REFERENCES_MANIFEST, workspaceRemixReferenceCandidateSchema, workspaceRemixReferenceExportSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { withDirectoryWrite } from '../server/directory-access.js';
+import { wakeSourceEventUploader } from '../server/source-uploader.js';
+import { workspaceContextFromRoot } from '../workspaces/registry.js';
+import { importWorkspaceRemixReference, listWorkspaceRemixReferences } from '../workspaces/remix-references.js';
+import { shareWorkspaceGit } from '../workspaces/shared-git.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
+import { verifyLauncherOrigin } from './launcher-client.js';
+import { localRemixReference, RemixReferenceToolError, remixReferenceToolRequestSchema } from '../../references/protocol.js';
+const ACTIVE = new Set(['dispatched', 'accepted', 'uncertain']);
+const candidatesSchema = z.object({ items: z.array(z.unknown()).max(50),
+    total: z.number().int().nonnegative(), page: z.number().int().positive(), pageSize: z.number().int().positive() }).strict();
+const SOURCE_ERRORS = new Set(['remix_reference_unavailable', 'remix_reference_too_large', 'remix_reference_incomplete',
+    'remix_reference_unsupported', 'remix_reference_source_changed', 'workspace_access_denied', 'workspace_permission_denied']);
+/** Executes source-reference operations only for the shell and native turn owning this route. */
+export class WorkspaceRemixReferencesBroker {
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    operation(context, valid, write = false) {
+        const state = this.state;
+        const session = state.journal.getSession(context.sessionId);
+        const operations = state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind)
+            && ACTIVE.has(operation.status) && operation.generation === state.config.generation && operation.runtimeEpoch === state.runtimeEpoch);
+        const operation = operations.length === 1 ? operations[0] : undefined;
+        if (!valid() || context.refsBlocked || state.journal.destroyed() || !operation || operation.kind !== 'session.turn' || operation.sessionId !== context.sessionId
+            || operation.generation !== state.config.generation || operation.runtimeEpoch !== state.runtimeEpoch
+            || operation.clientRequestId !== context.clientRequestId || !operation.workspaceId || !operation.directoryName
+            || operation.directoryName === 'root' || !operation.nativeThreadId || !operation.nativeTurnId
+            || !session || session.threadId !== operation.nativeThreadId || session.activeTurnId !== operation.nativeTurnId
+            || session.cwd !== context.cwd || session.workspaceId !== operation.workspaceId
+            || (session.directoryName ?? 'basic') !== operation.directoryName || session.turnBlock === 'uncertain'
+            || !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
+            throw new RemixReferenceToolError('remix_reference_turn_unavailable');
+        if (write) {
+            if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence)
+                throw new RemixReferenceToolError('remix_reference_turn_unavailable');
+            if (context.readOnly || operation.workMode === 'plan' || operation.permissionMode === 'read-only' || session.permissionMode === 'read-only')
+                throw new RemixReferenceToolError('remix_reference_readonly');
+            if (state.journal.listSessions().some(other => other.sessionId !== context.sessionId
+                && other.workspaceId === operation.workspaceId
+                && ((other.directoryName ?? 'basic') === operation.directoryName || other.directoryName === 'root')
+                && (other.turnBlock === 'uncertain' || ['starting', 'running', 'waiting_for_user'].includes(other.turnStatus ?? ''))))
+                throw new RemixReferenceToolError('turn_already_active');
+        }
+        return operation;
+    }
+    async current(context, valid, write = false) {
+        const operation = this.operation(context, valid, write);
+        const scope = await workspaceContextFromRoot(this.state, context.cwd);
+        if (scope.workspaceId !== operation.workspaceId || scope.directoryName !== operation.directoryName)
+            throw new RemixReferenceToolError('remix_reference_scope_mismatch');
+        if (write && await batchDirectoryHeld(this.state, scope.workspaceId, scope.directoryName))
+            throw new RemixReferenceToolError('batch_workspace_readonly');
+        this.operation(context, valid, write);
+        return { ...scope, operation };
+    }
+    async forward(request, response, context, valid) {
+        const reply = (status, value) => {
+            response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            response.end(JSON.stringify(value));
+        };
+        try {
+            if (request.socket.remoteAddress !== '127.0.0.1')
+                throw new RemixReferenceToolError('remix_reference_turn_unavailable');
+            let text = '';
+            for await (const chunk of request) {
+                text += chunk.toString();
+                if (Buffer.byteLength(text) > 16 * 1024)
+                    throw new RemixReferenceToolError('invalid_remix_reference_tool_request');
+            }
+            const parsed = remixReferenceToolRequestSchema.safeParse(JSON.parse(text));
+            if (!parsed.success)
+                throw new RemixReferenceToolError('invalid_remix_reference_tool_request');
+            const input = parsed.data;
+            const write = input.action === 'import';
+            const scope = await this.current(context, valid, write);
+            const callerCwd = await realpath(input.cwd);
+            const childPath = relative(context.cwd, callerCwd);
+            if (isAbsolute(childPath) || childPath === '..' || childPath.startsWith('../') || input.workspaceId !== undefined && input.workspaceId !== scope.workspaceId
+                || input.directoryName !== undefined && input.directoryName !== scope.directoryName)
+                throw new RemixReferenceToolError('remix_reference_scope_mismatch');
+            const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+            if (!socketPath || !context.boundaryId || !request.socket.localPort || !request.socket.remotePort
+                || !await verifyLauncherOrigin({ socketPath, boundaryId: context.boundaryId, runtimeEpoch: this.state.runtimeEpoch,
+                    serverPort: request.socket.localPort, clientPort: request.socket.remotePort, cwd: context.originCwd ?? callerCwd }))
+                throw new RemixReferenceToolError('remix_reference_turn_unavailable');
+            await this.current(context, valid, write);
+            if (input.action === 'list') {
+                const items = await this.state.journal.exclusive(`workspace:${scope.workspaceId}:${scope.directoryName}`, () => listWorkspaceRemixReferences(context.cwd, scope.directoryName));
+                this.operation(context, valid);
+                return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                    items: items.map(reference => localRemixReference(context.cwd, reference)) });
+            }
+            if (input.action === 'search') {
+                const result = candidatesSchema.parse(await this.upstream(scope, { action: 'search', source: input.source,
+                    ...(input.tagCategory === undefined ? {} : { tagCategory: input.tagCategory, tagValues: input.tagValues }),
+                    ...(input.q === undefined ? {} : { q: input.q }), page: input.page, limit: input.limit }, 2 * 1024 * 1024));
+                await this.current(context, valid);
+                return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName, ...result,
+                    items: result.items.map(item => workspaceRemixReferenceCandidateSchema.parse(item)) });
+            }
+            const result = await withDirectoryWrite(this.state, { workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                sessionId: context.sessionId, wait: false }, async () => {
+                await this.current(context, valid, true);
+                const raw = await this.upstream(scope, { action: 'export', projectUuid: input.projectUuid, branchName: input.branchName }, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES);
+                await this.current(context, valid, true);
+                const snapshot = workspaceRemixReferenceExportSchema.parse(raw);
+                if (snapshot.source.environment !== this.state.config.environment || snapshot.source.projectUuid !== input.projectUuid
+                    || snapshot.source.branchName !== input.branchName)
+                    throw new RemixReferenceToolError('remix_reference_unavailable');
+                return this.state.journal.exclusive(`workspace:${scope.workspaceId}:${scope.directoryName}`, async () => {
+                    await this.current(context, valid, true);
+                    await shareWorkspaceGit(this.state, context.cwd);
+                    await this.current(context, valid, true);
+                    const reference = await importWorkspaceRemixReference(context.cwd, scope.directoryName, snapshot, () => {
+                        this.operation(context, valid, true);
+                    });
+                    this.operation(context, valid, true);
+                    await this.state.journal.allocateSourceEvent({ runtimeId: this.state.config.runtimeId,
+                        generation: this.state.config.generation, runtimeEpoch: this.state.runtimeEpoch,
+                        type: 'workspace.references.imported', occurredAt: new Date().toISOString(),
+                        sessionId: context.sessionId, workspaceId: scope.workspaceId, operationId: scope.operation.operationId,
+                        payload: { sessionId: context.sessionId, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                            referenceId: reference.referenceId, path: reference.path, contentHash: reference.contentHash } });
+                    await this.state.journal.allocateSourceEvent({ runtimeId: this.state.config.runtimeId,
+                        generation: this.state.config.generation, runtimeEpoch: this.state.runtimeEpoch,
+                        type: 'files.changed', occurredAt: new Date().toISOString(), sessionId: context.sessionId,
+                        workspaceId: scope.workspaceId, operationId: scope.operation.operationId,
+                        payload: { workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                            paths: [reference.path, WORKSPACE_REMIX_REFERENCES_MANIFEST], source: 'workspace.references.import',
+                            operationId: scope.operation.operationId } });
+                    wakeSourceEventUploader(this.state);
+                    return reference;
+                });
+            });
+            return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                reference: localRemixReference(context.cwd, result) });
+        }
+        catch (error) {
+            if (response.headersSent) {
+                response.destroy();
+                return;
+            }
+            const code = error instanceof SyntaxError ? 'invalid_remix_reference_tool_request' : error instanceof RemixReferenceToolError ? error.code
+                : error instanceof Error && /^(?:remix_reference_[a-z_]+|directory_busy)$/.test(error.message)
+                    ? error.message : 'remix_reference_tool_failed';
+            reply(code === 'invalid_remix_reference_tool_request' ? 400
+                : ['turn_already_active', 'batch_workspace_readonly', 'directory_busy'].includes(code) ? 409 : 403, { ok: false, error: { code } });
+        }
+    }
+    async upstream(scope, input, limit) {
+        const config = this.state.config;
+        const response = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.remixReferenceTools), {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(120_000),
+            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: this.state.runtimeEpoch,
+                workspaceId: scope.workspaceId, directoryName: scope.directoryName, ...input }),
+        });
+        const chunks = [];
+        let bytes = 0;
+        if (!response.body)
+            throw new RemixReferenceToolError('remix_reference_unavailable');
+        for await (const chunk of response.body) {
+            bytes += chunk.byteLength;
+            if (bytes > (response.ok ? limit : 8192)) {
+                await response.body.cancel().catch(() => undefined);
+                throw new RemixReferenceToolError('remix_reference_too_large');
+            }
+            chunks.push(Buffer.from(chunk));
+        }
+        const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (!response.ok) {
+            const code = [value?.reason, value?.code, value?.message, value?.error?.reason, value?.error?.code]
+                .find(code => typeof code === 'string' && SOURCE_ERRORS.has(code));
+            throw new RemixReferenceToolError(code ?? 'remix_reference_unavailable');
+        }
+        return value;
+    }
+}

package/dist/workspace-runtime/codex/scheduled-task-tools.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { scheduledTaskProposalDraftSchema, scheduledTaskProposalDraftJsonSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_SCHEDULED_TASK_TOOLS = [
+    { type: 'function', name: 'playcraft_get_scheduled_task_context',
+        description: 'Read server time, scheduling defaults, and tasks actually related to this conversation. The returned timeZone describes the server clock, not the user’s local timezone; clarify the intended timezone when it is unknown. When several tasks match, ask the user which task to change. This tool never changes a task.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
+    { type: 'function', name: 'playcraft_propose_scheduled_task',
+        description: 'Prepare a scheduled-task creation or change for the user to review in a persistent confirmation card. Read scheduling context first. This does not create or change a task: only the user can confirm the card. A pending_confirmation result must never be reported as an applied task.',
+        inputSchema: { type: 'object', properties: {
+                draft: scheduledTaskProposalDraftJsonSchema, supersedesProposalId: { type: 'string', format: 'uuid' },
+            }, required: ['draft'], additionalProperties: false } },
+];
+export const SCHEDULED_TASK_TOOL_ERROR_CODES = new Set([
+    'unavailable', 'source_unavailable', 'source_pending', 'invalid_input', 'request_conflict', 'request_pending',
+    'feature_disabled', 'limit', 'version_conflict', 'schedule_expired', 'invalid_time_zone', 'interval_too_short',
+    'target_read_only', 'target_unavailable', 'target_access_denied', 'target_binding_changed', 'session_unavailable',
+    'account_unavailable', 'model_unavailable', 'reasoning_effort_unavailable', 'revoked',
+].map(code => `scheduled_task_proposal_${code}`));
+const prepareArguments = z.object({ draft: z.unknown(), supersedesProposalId: z.string().uuid().optional() }).strict();
+const sourceKey = (source) => JSON.stringify([source.threadId, source.turnId, source.toolCallId]);
+/** Only a live root-native call can attest the source of a prepare-only bridge request. */
+export class WorkspaceScheduledTaskTools {
+    handler;
+    changed;
+    active = new Map();
+    settled = new Map();
+    constructor(handler, changed) {
+        this.handler = handler;
+        this.changed = changed;
+    }
+    isActive(source) {
+        const call = this.active.get(sourceKey(source));
+        return Boolean(call && call.source.bridge === source.bridge && call.current());
+    }
+    async request(requestId, payload, client, context) {
+        if (!context?.bridge || !context.current() || typeof payload.callId !== 'string' || !payload.callId.length
+            || payload.namespace)
+            return rejectTool(client, requestId, 'scheduled_task_proposal_source_unavailable');
+        const action = payload.tool === 'playcraft_get_scheduled_task_context' ? 'context'
+            : payload.tool === 'playcraft_propose_scheduled_task' ? 'prepare' : undefined;
+        const parsed = action === 'context' ? z.object({}).strict().safeParse(payload.arguments)
+            : prepareArguments.safeParse(payload.arguments);
+        if (!action || !parsed.success || (action === 'prepare'
+            && !scheduledTaskProposalDraftSchema.safeParse(parsed.data.draft).success))
+            return rejectTool(client, requestId, 'scheduled_task_proposal_invalid_input');
+        const source = { bridge: context.bridge, threadId: context.threadId, turnId: context.turnId, toolCallId: payload.callId };
+        const key = sourceKey(source), fingerprint = JSON.stringify([action, parsed.data]);
+        const prior = this.settled.get(key);
+        if (prior) {
+            if (prior.fingerprint !== fingerprint)
+                return rejectTool(client, requestId, 'scheduled_task_proposal_request_conflict');
+            await client.respond(requestId, { success: true, contentItems: toolContent(prior.result) });
+            return;
+        }
+        if (this.active.has(key))
+            return rejectTool(client, requestId, 'scheduled_task_proposal_request_pending');
+        this.active.set(key, { source, current: context.current });
+        try {
+            const result = await this.handler(action, source, parsed.data);
+            this.settled.set(key, { fingerprint, result });
+            if (this.settled.size > 256)
+                this.settled.delete(this.settled.keys().next().value);
+            if (action === 'prepare' && result && typeof result === 'object'
+                && 'proposalId' in result && typeof result.proposalId === 'string')
+                this.changed(result.proposalId, source);
+            await client.respond(requestId, { success: true, contentItems: toolContent(result) });
+        }
+        catch (error) {
+            await rejectTool(client, requestId, error instanceof Error && SCHEDULED_TASK_TOOL_ERROR_CODES.has(error.message)
+                ? error.message : 'scheduled_task_proposal_unavailable');
+        }
+        finally {
+            this.active.delete(key);
+        }
+    }
+}
+export function isWorkspaceScheduledTaskTool(value) {
+    return WORKSPACE_SCHEDULED_TASK_TOOLS.some(tool => tool.name === value);
+}

package/dist/workspace-runtime/serve.js

@@ -12,7 +12,7 @@ import { attachNativeCollector, executeOperation, recoverInterruptedParameterVer
 import { restoreDeferredDirectoryOperations } from './server/directory-access.js';
 import { handleRuntimeRequest } from './server/http.js';
 import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
-import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
+import { disposeTerminalHost, retireStoppedTerminals, terminalHost } from './server/terminal-host.js';
 import { handleExecutionGroupCrash } from './server/execution-group.js';
 import { RuntimeProcessLock } from './server/lock.js';
 import { probeGitBinary } from './workspaces/git.js';
@@ -33,6 +33,7 @@ import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
 import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
 import { platformExportTarget, readPlatformExport, startPlatformExport } from './workspaces/platform-export.js';
+import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
 export async function startWorkspaceRuntime(config, options = {}) {
     process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
     const negotiated = negotiateProtocol(config);
@@ -58,6 +59,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         await recoverInterruptedPreviews(journal);
         await recoverInterruptedParameterVerifications(journal);
         await recoverInterruptedDeliveries(config.stateDir);
+        await retireStoppedTerminals(journal, config.runtimeEpoch, previousEpoch);
         // shared: in multi-workspace mode this is /workspaces, the container both identities traverse.
         await mkdir(config.workspaceRoot, { recursive: true, mode: 0o2770 });
         const state = runtimeState = {
@@ -411,6 +413,7 @@ function defaultNativeAdapter(state) {
             config,
             workspaceUi: true,
             deliveryTools: deliveryToolHandlers(state),
+            scheduledTaskProposals: scheduledTaskProposalHandler(state),
             ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             ...(multi ? { loadMcpConfig: async (cwd) => {
                     const { workspaceId } = await workspaceContextFromRoot(state, cwd);

package/dist/workspace-runtime/server/directory-access.js

@@ -8,7 +8,7 @@ const instances = new WeakMap();
 const executing = new WeakMap();
 const freezing = new WeakMap();
 const TERMINAL = new Set(['completed', 'failed', 'interrupted']);
-const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'delivery.build', 'workspace.save', 'directory.create',
+const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'delivery.build', 'directory.create',
     'directory.rename', 'directory.delete', 'workspace.references.import', 'skills.update', 'parameter.verify',
     'checkpoint.create', 'checkpoint.restore']);
 export function managedDirectoryScope(state, value) {

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

@@ -33,6 +33,7 @@ import { previewFailureCode, previewWorkspaceRoot, runPreviewPublish, trackPrevi
 import { startManagedBackgroundWriter, stopBackgroundWriter, } from '../processes/managed-writes.js';
 import { wakeSourceEventUploader } from './source-uploader.js';
 import { batchDirectoryHeld } from '../batch/occupancy.js';
+import { trustedMemberPolicy } from '../batch/policy.js';
 import { BinaryWorkspaceWriteError, observeWorkspaceBinaryFile, writeWorkspaceBinaryFile } from '../workspaces/binary-write.js';
 import { importWorkspaceLibraryAssets } from '../workspaces/asset-library-import.js';
 import { createWorkspaceDirectory, WorkspaceDirectoryCreateError } from '../workspaces/directory-create.js';
@@ -217,7 +218,7 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
         if (operation.kind === 'session.steer')
             return executeSteer(state, scopeKey, current, payload);
         if (operation.kind === 'session.interrupt') {
-            return executeInterrupt(state, scopeKey, current);
+            return executeInterrupt(state, scopeKey, current, payload);
         }
         if (operation.kind === 'session.approval.respond') {
             return executeApproval(state, scopeKey, current, payload);
@@ -455,7 +456,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}\n\n`
         : '';
     const engineeringBatchContext = state.config.workspaceMode === 'multi' && operation.workspaceId
-        && operation.directoryName !== 'root' && !productionSessionAttemptId(sessionId)
+        && operation.directoryName !== 'root' && !productionSessionAttemptId(sessionId) && !trustedMemberPolicy(state, sessionId)
         ? `PlayCraft batch request context (trusted runtime identity): ${JSON.stringify({ workspaceId: operation.workspaceId,
             clientRequestId: operation.clientRequestId, sourceDirectoryName: binding.directoryName ?? 'basic',
             ...(typeof body.teamId === 'string' ? { teamId: body.teamId } : {}) })}`
@@ -496,6 +497,7 @@ async function executeTurn(state, scopeKey, operation, payload, recovery) {
             workMode: selection.data.workMode ?? 'execute',
             skillsLockHash: composer.skillsLockHash,
             uiSnapshot: uiSnapshot.data,
+            scheduledTaskProposalBridge: typeof body.scheduledTaskProposalBridge === 'string' ? body.scheduledTaskProposalBridge : undefined,
             simulateLostReceipt: body.simulateLostReceipt === true,
             persistReservation: async ({ nativeRequestId, modelConfigId, reasoningEffort, permissionMode }) => {
                 const selectedEffort = reasoningEffort ?? requestedEffort;
@@ -849,13 +851,18 @@ async function executeSteer(state, scopeKey, operation, payload) {
             } }]);
     return persist(state, scopeKey, transitionOperation(accepted, 'completed'));
 }
-async function executeInterrupt(state, scopeKey, operation) {
+async function executeInterrupt(state, scopeKey, operation, payload) {
     const sessionId = required(operation.sessionId, 'sessionId');
     const binding = state.journal.getSession(sessionId);
     if (!binding) {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'unknown_session' }));
     }
-    const result = await native(state).interrupt({ sessionId, threadId: binding.threadId });
+    const expectedTurnId = asRecord(payload).expectedTurnId;
+    if (expectedTurnId !== undefined && (typeof expectedTurnId !== 'string' || !expectedTurnId
+        || binding.activeTurnId !== expectedTurnId))
+        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'turn_changed' }));
+    const result = await native(state).interrupt({ sessionId, threadId: binding.threadId,
+        ...(typeof expectedTurnId === 'string' ? { expectedTurnId } : {}) });
     if (result.outcome === 'failed') {
         return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: result.error ?? 'turn_not_running' }));
     }
@@ -1273,11 +1280,12 @@ async function executeWorkspaceSave(state, scopeKey, operation, payload) {
     }
     const binding = operation.workspaceId ? state.journal.getWorkspace(operation.workspaceId) : undefined;
     try {
-        const saved = await saveWorkspaceGit(await gitWorkspaceRoot(state, operation), {
+        // Saves share the directory, and a deferred one runs outside the workspace queue; commit one at a time.
+        const saved = await state.journal.exclusive(`workspace-save:${revisionScope(state, operation.workspaceId, operation.directoryName) ?? 'single'}`, async () => saveWorkspaceGit(await gitWorkspaceRoot(state, operation), {
             message: parsed.data.trigger === 'auto' ? 'Autosave workspace' : 'Save workspace',
             push: savePushesBranch(binding?.targetKind, operation.directoryName),
             boundBranch: boundBranch(state, operation),
-        });
+        }));
         const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
         await recordNativeEvents(state, accepted, [
             {